Release v2.3.46

- Rename 'Router Agent' to 'Model Router' for consistency
- Fix docs link to point to /features/model-router
- Add model-routing template CLI command
- Add link to Model Router documentation

.github/actions/claude-code-action/action.yml

@@ -86,13 +86,29 @@ runs:
     - name: Extract GitHub Context and Create Prompt
       shell: bash
       id: prepare_context
+      env:
+        # Pass user-controlled inputs via environment variables to prevent script injection (GHSL-2025-093)
+        EVENT_COMMENT_BODY: ${{ github.event.comment.body }}
+        EVENT_ISSUE_TITLE: ${{ github.event.issue.title }}
+        EVENT_ISSUE_BODY: ${{ github.event.issue.body }}
+        EVENT_ISSUE_NUMBER: ${{ github.event.issue.number }}
+        EVENT_PR_TITLE: ${{ github.event.pull_request.title }}
+        EVENT_PR_NUMBER: ${{ github.event.pull_request.number }}
+        EVENT_REVIEW_BODY: ${{ github.event.review.body }}
+        EVENT_ASSIGNEE_LOGIN: ${{ github.event.assignee.login }}
+        INPUT_TRIGGER_PHRASE: ${{ inputs.trigger_phrase }}
+        INPUT_ASSIGNEE_TRIGGER: ${{ inputs.assignee_trigger }}
+        INPUT_DIRECT_PROMPT: ${{ inputs.direct_prompt }}
+        EVENT_ACTION: ${{ github.event.action }}
+        EVENT_NAME: ${{ github.event_name }}
+        REPO_NAME: ${{ github.repository }}
       run: |
-        echo "🔍 Extracting GitHub context from event: ${{ github.event_name }}"
+        echo "🔍 Extracting GitHub context from event: $EVENT_NAME"
         
         # Function to check for trigger phrase
         check_trigger() {
           local text="$1"
-          local trigger="${{ inputs.trigger_phrase }}"
+          local trigger="$INPUT_TRIGGER_PHRASE"
           if [[ "$text" == *"$trigger"* ]]; then
             return 0
           fi
@@ -104,11 +120,11 @@ runs:
         USER_REQUEST=""
         CONTEXT_INFO=""
         
-        case "${{ github.event_name }}" in
+        case "$EVENT_NAME" in
           "issue_comment")
-            COMMENT_BODY="${{ github.event.comment.body }}"
-            ISSUE_TITLE="${{ github.event.issue.title }}"
-            ISSUE_NUMBER="${{ github.event.issue.number }}"
+            COMMENT_BODY="$EVENT_COMMENT_BODY"
+            ISSUE_TITLE="$EVENT_ISSUE_TITLE"
+            ISSUE_NUMBER="$EVENT_ISSUE_NUMBER"
             
             if check_trigger "$COMMENT_BODY"; then
               TRIGGER_FOUND="true"
@@ -118,9 +134,9 @@ runs:
             ;;
             
           "pull_request_review_comment")
-            COMMENT_BODY="${{ github.event.comment.body }}"
-            PR_TITLE="${{ github.event.pull_request.title }}"
-            PR_NUMBER="${{ github.event.pull_request.number }}"
+            COMMENT_BODY="$EVENT_COMMENT_BODY"
+            PR_TITLE="$EVENT_PR_TITLE"
+            PR_NUMBER="$EVENT_PR_NUMBER"
             
             if check_trigger "$COMMENT_BODY"; then
               TRIGGER_FOUND="true"
@@ -130,9 +146,9 @@ runs:
             ;;
             
           "pull_request_review")
-            REVIEW_BODY="${{ github.event.review.body }}"
-            PR_TITLE="${{ github.event.pull_request.title }}"
-            PR_NUMBER="${{ github.event.pull_request.number }}"
+            REVIEW_BODY="$EVENT_REVIEW_BODY"
+            PR_TITLE="$EVENT_PR_TITLE"
+            PR_NUMBER="$EVENT_PR_NUMBER"
             
             if check_trigger "$REVIEW_BODY"; then
               TRIGGER_FOUND="true"
@@ -142,17 +158,17 @@ runs:
             ;;
             
           "issues")
-            ISSUE_BODY="${{ github.event.issue.body }}"
-            ISSUE_TITLE="${{ github.event.issue.title }}"
-            ISSUE_NUMBER="${{ github.event.issue.number }}"
+            ISSUE_BODY="$EVENT_ISSUE_BODY"
+            ISSUE_TITLE="$EVENT_ISSUE_TITLE"
+            ISSUE_NUMBER="$EVENT_ISSUE_NUMBER"
             
             if check_trigger "$ISSUE_TITLE" || check_trigger "$ISSUE_BODY"; then
               TRIGGER_FOUND="true"
               USER_REQUEST="$ISSUE_BODY"
               CONTEXT_INFO="Issue #$ISSUE_NUMBER: $ISSUE_TITLE"
-            elif [[ "${{ github.event.action }}" == "assigned" && -n "${{ inputs.assignee_trigger }}" ]]; then
-              ASSIGNEE="${{ github.event.assignee.login }}"
-              if [[ "$ASSIGNEE" == "${{ inputs.assignee_trigger }}" ]]; then
+            elif [[ "$EVENT_ACTION" == "assigned" && -n "$INPUT_ASSIGNEE_TRIGGER" ]]; then
+              ASSIGNEE="$EVENT_ASSIGNEE_LOGIN"
+              if [[ "$ASSIGNEE" == "$INPUT_ASSIGNEE_TRIGGER" ]]; then
                 TRIGGER_FOUND="true"
                 USER_REQUEST="$ISSUE_BODY"
                 CONTEXT_INFO="Issue #$ISSUE_NUMBER assigned to $ASSIGNEE: $ISSUE_TITLE"
@@ -162,9 +178,9 @@ runs:
         esac
         
         # Check for direct prompt override
-        if [[ -n "${{ inputs.direct_prompt }}" ]]; then
+        if [[ -n "$INPUT_DIRECT_PROMPT" ]]; then
           TRIGGER_FOUND="true"
-          USER_REQUEST="${{ inputs.direct_prompt }}"
+          USER_REQUEST="$INPUT_DIRECT_PROMPT"
           CONTEXT_INFO="Automated GitHub workflow"
         fi
         
@@ -181,9 +197,9 @@ runs:
         cat > /tmp/claude-action/github-context-prompt.txt << EOF
         You are Claude Code, an AI assistant helping with GitHub workflows and code.
         
-        Repository: ${{ github.repository }}
+        Repository: $REPO_NAME
         Context: $CONTEXT_INFO
-        Event: ${{ github.event_name }}
+        Event: $EVENT_NAME
         
         User Request:
         $USER_REQUEST

.github/actions/gemini/action.yml

@@ -0,0 +1,81 @@
+name: 'Gemini CLI Action'
+description: 'Uses the Gemini CLI to automate software development tasks.'
+author: 'Gemini'
+
+inputs:
+  prompt:
+    description: 'A specific prompt to guide Gemini.'
+    required: false
+    default: 'You are a helpful assistant.'
+  GEMINI_API_KEY:
+    description: 'Your Gemini API key.'
+    required: true
+  OTLP_GCP_WIF_PROVIDER:
+    description: 'The workload identity provider for GCP authentication.'
+    required: false
+  OTLP_GOOGLE_CLOUD_PROJECT:
+    description: 'The Google Cloud project for telemetry.'
+    required: false
+  settings_json:
+    description: |
+      A JSON string to configure the Gemini CLI. This will be written to .gemini/settings.json.
+      To enable observability with Google Cloud, include:
+      {"telemetry": {"enabled": true, "target": "gcp"}, "sandbox": false}
+    required: false
+  version:
+    description: |
+      The version of @google/gemini-cli to execute.
+      Can be a specific version from npm (e.g., '0.1.0', 'latest'), a branch name (e.g., 'main'), or a commit hash.
+    required: false
+    default: 'latest'
+
+runs:
+  using: "composite"
+  steps:
+    - name: Configure Gemini CLI
+      if: inputs.settings_json != ''
+      run: |
+        mkdir -p .gemini
+        echo "$SETTINGS_JSON" > .gemini/settings.json
+      shell: bash
+      env:
+        SETTINGS_JSON: ${{ inputs.settings_json }}
+
+    - name: Authenticate to Google Cloud for Telemetry 
+      if: inputs.OTLP_GCP_WIF_PROVIDER != ''
+      id: auth
+      uses: 'google-github-actions/auth@v2'
+      with:
+        project_id: ${{ inputs.OTLP_GOOGLE_CLOUD_PROJECT }}
+        workload_identity_provider: ${{ inputs.OTLP_GCP_WIF_PROVIDER }}
+
+    - name: Install Gemini CLI
+      id: install
+      run: |
+        if [[ "${{ inputs.version }}" == "latest" || "${{ inputs.version }}" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9\.-]+)?(\+[a-zA-Z0-9\.-]+)?$ ]]; then
+          echo "Installing Gemini CLI from npm: @google/gemini-cli@${{ inputs.version }}"
+          npm install -g @google/gemini-cli@${{ inputs.version }}
+        else
+          echo "Installing Gemini CLI from GitHub: github:google-gemini/gemini-cli#${{ inputs.version }}"
+          npm install -g github:google-gemini/gemini-cli#${{ inputs.version }}
+        fi
+        echo "Verifying installation:"
+        if command -v gemini >/dev/null 2>&1; then
+          gemini --version || echo "Gemini CLI installed successfully (version command not available)"
+        else
+          echo "Error: Gemini CLI not found in PATH"
+          exit 1
+        fi
+      shell: bash
+
+    - name: Run Gemini CLI
+      run: |
+        gemini --yolo --prompt "$PROMPT"
+      shell: bash
+      env:
+        GEMINI_API_KEY: ${{ inputs.GEMINI_API_KEY }}
+        PROMPT: ${{ inputs.prompt }}
+
+branding:
+  icon: 'terminal'
+  color: 'blue'

.github/workflows/auto-issue-comment.yml

@@ -1,4 +1,4 @@
-name: Auto Issue Comment
+name: Auto Issue Comment with PR Creation
 
 on:
   issues:
@@ -9,14 +9,18 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       issues: write
+      contents: write
+      pull-requests: write
+      actions: read
     steps:
       - name: Add automated comment
         uses: actions/github-script@v7
         with:
+          github-token: ${{ secrets.GH_TOKEN }}
           script: |
             github.rest.issues.createComment({
               issue_number: context.issue.number,
               owner: context.repo.owner,
               repo: context.repo.repo,
-              body: '@claude review this issue with multiple parallel running agents and do a detailed analysis and fix this if the existing code doesn\'t have the solution implemented. Making sure it has backward compatibility, no existing features removed. After making those changes, again use multi agents to review the applied changes'
-            }) 
+              body: '@claude review this issue and do a detailed analysis and fix this if the existing code doesn\'t have the solution implemented. Making sure it has backward compatibility, no existing features removed. After making those changes, again review the applied changes. Use @web to search if you dont know any information or to find the latest documentation or to find the latest version. Run the code if you think you need to run it to test it. Minimal code change to start with if required any changes. MAINLY IT SHOULD NOT IMPACT ON THE CURRENT SPEED OF EXECUTION of existing features, not increasing the overhead. **Please create a PR using gh tool with your changes**.'
+            })

.github/workflows/auto-pr-comment.yml

@@ -13,10 +13,11 @@ jobs:
       - name: Add automated comment
         uses: actions/github-script@v7
         with:
+          github-token: ${{ secrets.GH_TOKEN }}
           script: |
             github.rest.issues.createComment({
               issue_number: context.issue.number,
               owner: context.repo.owner,
               repo: context.repo.repo,
-              body: '@claude review this pull request with multiple parallel running agents and do a detailed analysis and fix this if the existing code doesn\'t have the solution implemented. Making sure it has backward compatibility, no existing features removed. After making those changes, again use multi agents to review the applied changes'
+              body: '@claude review this pull request and do a detailed analysis and fix this if the existing code doesn\'t have the solution implemented. Making sure it has backward compatibility, no existing features removed. After making those changes, again review the applied changes. Use @web to search if you dont know any information or to find the latest documentation or to find the latest version. Run the code if you think you need to run it to test it. Minimal code change to start with if required any changes. MAINLY IT SHOULD NOT IMPACT ON THE CURRENT SPEED OF EXECUTION of existing features, not increasing the overhead.'
             }) 

.github/workflows/build-image.yml

@@ -11,6 +11,7 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     permissions:
       contents: read
       packages: write

.github/workflows/claude.yml

@@ -1,4 +1,4 @@
-name: Claude Code
+name: Claude Assistant
 
 on:
   issue_comment:
@@ -6,34 +6,155 @@ on:
   pull_request_review_comment:
     types: [created]
   issues:
-    types: [opened, assigned]
+    types: [opened, assigned, labeled]
   pull_request_review:
     types: [submitted]
 
 jobs:
-  claude:
+  claude-response:
+    # Prevent certain bots from triggering this action (but allow github-actions[bot] for auto-comments)
     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')))
+      github.actor != 'dependabot[bot]' &&
+      github.actor != 'cursor[bot]' &&
+      github.actor != 'renovate[bot]' &&
+      !(contains(github.actor, '[bot]') && github.actor != 'github-actions[bot]')
     runs-on: ubuntu-latest
     permissions:
-      contents: read
-      pull-requests: read
-      issues: read
-      id-token: write
+      contents: write
+      pull-requests: write
+      issues: write
+      actions: read
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
-          fetch-depth: 1
-
-      - name: Run Claude Code (OAuth)
-        id: claude
-        uses: grll/claude-code-action@beta
+          fetch-depth: 0
+          
+      - uses: anthropics/claude-code-action@beta
         with:
-          use_oauth: true
-          claude_access_token: ${{ secrets.CLAUDE_ACCESS_TOKEN }}
-          claude_refresh_token: ${{ secrets.CLAUDE_REFRESH_TOKEN }}
-          claude_expires_at: ${{ secrets.CLAUDE_EXPIRES_AT }}
+          claude_code_oauth_token: ${{ secrets.CLAUDE_ACCESS_TOKEN }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          trigger_phrase: "@claude"
+          allowed_tools: |
+            Bash(git:*)
+            Bash(python:*)
+            Bash(pip:*)
+            Bash(conda:*)
+            Bash(pytest:*)
+            Bash(gh:*)
+            Bash(python -m pytest:*)
+            Bash(python -m pip:*)
+            Bash(poetry:*)
+            View
+            GlobTool
+            GrepTool
+            BatchTool
+            Edit
+            Replace
+            mcp__github__get_issue
+            mcp__github__get_issue_comments
+            mcp__github__update_issue
+          timeout_minutes: 30
+
+  post-review-comment:
+    needs: claude-response
+    if: success() && needs.claude-response.result == 'success'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: write
+    steps:
+      - name: Check for existing review comment
+        id: check-comment
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GH_TOKEN }}
+          script: |
+            const reviewText = '@claude review if the changes made in the above branch are as per the requirements and make changes to the above branch if issues still exist.';
+            let comments = [];
+            let issueNumber;
+            
+            try {
+              // Determine issue/PR number based on event type
+              if (context.eventName === 'pull_request_review_comment' || context.eventName === 'pull_request_review') {
+                issueNumber = context.payload.pull_request?.number || context.issue.number;
+              } else if (context.eventName === 'issue_comment' && context.payload.issue.pull_request) {
+                // This is a comment on a PR (not an issue)
+                issueNumber = context.payload.issue.number;
+              } else {
+                // This is a regular issue
+                issueNumber = context.issue.number;
+              }
+              
+              comments = await github.rest.issues.listComments({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber
+              });
+              
+              // Look for Claude's completed review comments
+              const claudeReviewComments = comments.data.filter(comment => 
+                (comment.user.login === 'claude[bot]' || comment.body.includes('✅') || comment.body.includes('## Summary')) &&
+                !comment.body.includes('⏳') && 
+                !comment.body.includes('🔄') &&
+                !comment.body.includes('Loading...')
+              );
+              
+              // Check if our review request comment already exists
+              const existingReviewRequest = comments.data.find(comment => 
+                comment.body.includes(reviewText)
+              );
+              
+              // Post if Claude has completed a review AND we haven't posted the review request yet
+              const shouldPost = claudeReviewComments.length > 0 && !existingReviewRequest;
+              core.setOutput('should-post', shouldPost);
+              console.log(`Claude review completed: ${claudeReviewComments.length > 0}`);
+              console.log(`Review request exists: ${!!existingReviewRequest}`);
+              console.log(`Should post comment: ${shouldPost}`);
+              
+            } catch (error) {
+              console.log('Error checking comments:', error);
+              core.setOutput('should-post', false); // If we can't check, don't post
+            }
+
+      - name: Wait 30 seconds before posting comment
+        if: steps.check-comment.outputs.should-post == 'true'
+        run: sleep 30
+
+      - name: Post review comment
+        if: steps.check-comment.outputs.should-post == 'true'
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GH_TOKEN }}
+          script: |
+            let issueNumber;
+            let isPR = false;
+            
+            // Determine issue/PR number and type based on event type
+            if (context.eventName === 'pull_request_review_comment' || context.eventName === 'pull_request_review') {
+              issueNumber = context.payload.pull_request?.number || context.issue.number;
+              isPR = true;
+            } else if (context.eventName === 'issue_comment' && context.payload.issue.pull_request) {
+              // This is a comment on a PR (not an issue)
+              issueNumber = context.payload.issue.number;
+              isPR = true;
+            } else {
+              // This is a regular issue - don't post review comment
+              issueNumber = context.issue.number;
+              isPR = false;
+            }
+            
+            // Only post review comment on PRs, not regular issues
+            if (isPR) {
+              console.log(`Posting review comment on PR #${issueNumber}`);
+              
+              await github.rest.issues.createComment({
+                issue_number: issueNumber,
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                body: '@claude review if the changes made in the above branch are as per the requirements and make changes to the above branch if issues still exist. MAINLY IT SHOULD NOT IMPACT ON THE CURRENT SPEED OF EXECUTION of existing features, not increasing the overhead.'
+              });
+            } else {
+              console.log(`Skipping review comment for regular issue #${issueNumber}`);
+            }

.github/workflows/coverage.yml

@@ -10,6 +10,7 @@ jobs:
   test:
     name: Run tests and collect coverage
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     
     steps:
       - name: Checkout
@@ -40,7 +41,7 @@ jobs:
         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 "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
           echo "LOGLEVEL=DEBUG" >> $GITHUB_ENV
           echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
 

.github/workflows/docker-publish.yml

@@ -1,44 +1,54 @@
-name: Daily Publish Docker
+name: Publish Docker
 
 on:
-  push:
-    branches:
-      - main
-  schedule:
-    - cron: '0 0 * * *'
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Docker image tag (default: latest)'
+        required: false
+        default: 'latest'
 
 jobs:
-  check-and-build:
+  build-and-push:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
     
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
-
-      - name: Check last commit time
-        id: check_commit
-        run: |
-          last_commit_time=$(git log -1 --format=%ct)
-          current_time=$(date +%s)
-          time_diff=$((current_time - last_commit_time))
-          if [ $time_diff -ge 120 ] && [ $time_diff -lt 240 ]; then
-            echo "should_run=true" >> $GITHUB_OUTPUT
-          else
-            echo "should_run=false" >> $GITHUB_OUTPUT
-          fi
+        uses: actions/checkout@v4
 
       - name: Set up Docker Buildx
-        if: steps.check_commit.outputs.should_run == 'true'
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v3
 
-      - name: Log in to the GitHub Container Registry
-        if: steps.check_commit.outputs.should_run == 'true'
-        run: echo ${{ secrets.GH_TOKEN }} | docker login ghcr.io -u USERNAME --password-stdin
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/mervinpraison/praisonai
+          tags: |
+            type=raw,value=latest,enable=${{ github.event_name == 'release' }}
+            type=semver,pattern={{version}},enable=${{ github.event_name == 'release' }}
+            type=semver,pattern={{major}}.{{minor}},enable=${{ github.event_name == 'release' }}
+            type=raw,value=${{ github.event.inputs.tag || 'latest' }},enable=${{ github.event_name == 'workflow_dispatch' }}
 
       - name: Build and push Docker image
-        if: steps.check_commit.outputs.should_run == 'true'
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v5
         with:
           context: .
+          file: ./docker/Dockerfile
           push: true
-          tags: ghcr.io/mervinpraison/praisonai:latest
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/gemini-issue-automated-triage.yml

@@ -0,0 +1,76 @@
+name: Gemini Automated Issue Triage
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  triage-issue:
+    if: >
+      github.event_name == 'issue_comment' &&
+      !github.event.issue.pull_request &&
+      contains(github.event.comment.body, '@gemini triage') &&
+      (github.event.comment.author_association == 'OWNER' ||
+       github.event.comment.author_association == 'MEMBER' ||
+       github.event.comment.author_association == 'COLLABORATOR')
+    timeout-minutes: 5
+    permissions:
+      issues: write
+      contents: read
+      id-token: write
+    concurrency:
+      group: ${{ github.workflow }}-${{ github.event.issue.number }}
+      cancel-in-progress: true
+    runs-on: ubuntu-latest
+    steps:
+      - name: Generate GitHub App Token
+        id: generate_token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.PRIVATE_KEY }}
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          token: ${{ steps.generate_token.outputs.token }}
+
+      - name: Run Gemini Issue Triage
+        uses: google-gemini/gemini-cli-action@main
+        env:
+          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
+          ISSUE_TITLE: ${{ github.event.issue.title }}
+          ISSUE_BODY: ${{ github.event.issue.body }}
+          ISSUE_NUMBER: ${{ github.event.issue.number }}
+          REPOSITORY: ${{ github.repository }}
+        with:
+          version: 0.1.8-rc.0
+          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+          OTLP_GCP_WIF_PROVIDER: ${{ secrets.OTLP_GCP_WIF_PROVIDER }}
+          OTLP_GOOGLE_CLOUD_PROJECT: ${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}
+          settings_json: |
+            {
+              "coreTools": [
+                "run_shell_command(gh label list)",
+                "run_shell_command(gh issue edit)"
+              ],
+              "telemetry": {
+                "enabled": true,
+                "target": "gcp"
+              },
+              "sandbox": false
+            }
+          prompt: |
+            You are an issue triage assistant. Analyze the current GitHub issue and apply the most appropriate existing labels.
+
+            Steps:
+            1. Run: `gh label list --limit 100` to get all available labels.
+            2. Review the issue title and body provided in the environment variables.
+            3. Select the most relevant labels from the existing labels, focusing on kind/*, area/*, and priority/*.
+            4. Apply the selected labels to this issue using: `gh issue edit ISSUE_NUMBER --add-label "label1,label2"`
+
+            Guidelines:
+            - Only use labels that already exist in the repository.
+            - Do not add comments or modify the issue content.
+            - Triage only the current issue.
+            - Assign all applicable kind/*, area/*, and priority/* labels based on the issue content.

.github/workflows/gemini-issue-review.yml

@@ -0,0 +1,202 @@
+name: Gemini Issue Review
+
+on:
+  workflow_dispatch:
+  issue_comment:
+    types: [created]
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: read
+
+jobs:
+  review-issue:
+    if: >
+      github.event_name == 'workflow_dispatch' ||
+      (github.event_name == 'issue_comment' && 
+       !github.event.issue.pull_request && 
+       contains(github.event.comment.body, '@gemini') &&
+       !contains(github.event.comment.body, '@gemini triage') &&
+       (github.event.comment.author_association == 'OWNER' ||
+        github.event.comment.author_association == 'MEMBER' ||
+        github.event.comment.author_association == 'COLLABORATOR'))
+    runs-on: ubuntu-latest
+    env:
+      GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+    steps:
+      - name: Generate token
+        id: generate_token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.PRIVATE_KEY }}
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          token: ${{ steps.generate_token.outputs.token }}
+
+      - name: Set up Git
+        run: |
+          git config --local user.email "[email protected]"
+          git config --local user.name "Gemini Bot"
+
+      - name: Get issue data
+        id: issue_data
+        env:
+          GH_TOKEN: ${{ steps.generate_token.outputs.token }}
+          # Pass user-controlled inputs via environment variables to prevent script injection (GHSL-2025-093)
+          EVENT_NAME: ${{ github.event_name }}
+          EVENT_ISSUE_NUMBER: ${{ github.event.issue.number }}
+          EVENT_COMMENT_BODY: ${{ github.event.comment.body }}
+        run: |
+          # Get issue number from event or context
+          if [ "$EVENT_NAME" = "issue_comment" ]; then
+            ISSUE_NUMBER="$EVENT_ISSUE_NUMBER"
+          elif [ "$EVENT_NAME" = "issues" ]; then
+            ISSUE_NUMBER="$EVENT_ISSUE_NUMBER"
+          else
+            echo "Unable to determine issue number"
+            exit 1
+          fi
+          
+          # Get issue details
+          gh issue view $ISSUE_NUMBER --json title,body,labels,assignees > issue_details.json
+          
+          # Extract additional instructions from comment if triggered by comment
+          ADDITIONAL_INSTRUCTIONS=""
+          if [ "$EVENT_NAME" = "issue_comment" ]; then
+            COMMENT_BODY="$EVENT_COMMENT_BODY"
+            ADDITIONAL_INSTRUCTIONS=$(echo "$COMMENT_BODY" | sed -n 's/.*@gemini[[:space:]]*\(.*\)/\1/p' | head -1)
+          fi
+          
+          echo "ISSUE_NUMBER=$ISSUE_NUMBER" >> $GITHUB_OUTPUT
+          echo "ADDITIONAL_INSTRUCTIONS=$ADDITIONAL_INSTRUCTIONS" >> $GITHUB_OUTPUT
+
+      - name: Run Gemini CLI
+        uses: ./.github/actions/gemini
+        env:
+          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
+          ISSUE_NUMBER: ${{ steps.issue_data.outputs.ISSUE_NUMBER }}
+          ADDITIONAL_INSTRUCTIONS: ${{ steps.issue_data.outputs.ADDITIONAL_INSTRUCTIONS }}
+          REPOSITORY: ${{ github.repository }}
+        with:
+          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+          OTLP_GCP_WIF_PROVIDER: ${{ secrets.OTLP_GCP_WIF_PROVIDER }}
+          OTLP_GOOGLE_CLOUD_PROJECT: ${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}
+          prompt: |
+            You are a helpful GitHub issue assistant. Your task is to analyze and help with GitHub issues.
+            
+            **Issue Details:**
+            - Issue Number: #${ISSUE_NUMBER}
+            - Repository: ${REPOSITORY}
+            - Issue URL: ${{ github.event.issue.html_url }}
+            
+            **Additional Instructions:** ${ADDITIONAL_INSTRUCTIONS}
+            
+            **CRITICAL: When making code modifications, follow this EXACT workflow:**
+            
+            **STEP 1: Analyze the Issue**
+            - Use: `gh issue view ${ISSUE_NUMBER} --json title,body,labels,assignees`
+            - Analyze issue content thoroughly
+            - Search codebase for related files using `glob`, `search_file_content`, `list_directory`
+            
+            **STEP 2: If Code Changes Are Needed**
+            Create a new branch with 'gemini/' prefix:
+            - Use: `git checkout -b gemini/issue-${ISSUE_NUMBER}-description`
+            - Example: `git checkout -b gemini/issue-123-fix-sequential-tools`
+            
+            **STEP 3: Make Code Modifications**
+            - Use `read_file` to examine existing code
+            - Use `write_file` or `replace` to make changes
+            - Use `search_file_content` to find related code
+            - Make focused, targeted changes to fix the issue
+            
+            **STEP 4: Test Changes (if applicable)**
+            - Run relevant tests if test files exist
+            - Use `run_shell_command` to execute test commands
+            
+            **STEP 5: Commit and Push Changes**
+            - Use: `git add .` (or specific files)
+            - Use: `git commit -m "Gemini: [Issue #${ISSUE_NUMBER}] Brief description of fix"`
+            - Use: `git push -u origin gemini/issue-${ISSUE_NUMBER}-description`
+            
+            **STEP 6: Create Pull Request**
+            - Use: `gh pr create --title "Fix #${ISSUE_NUMBER}: Issue description" --body "Fixes #${ISSUE_NUMBER}\n\nSummary of changes:\n- Change 1\n- Change 2" --head gemini/issue-${ISSUE_NUMBER}-description --base main`
+            - This will return a PR URL like: https://github.com/repo/pull/123
+            
+            **STEP 7: Comment on Issue with Results**
+            Use: `gh issue comment ${ISSUE_NUMBER} -b "MESSAGE"`
+            
+            **Your final comment MUST include:**
+            - Summary of what was analyzed
+            - What changes were made (if any)
+            - Link to the created PR (if applicable)
+            - Brief explanation of the solution
+            
+            **Example final comment:**
+            ```
+            Hi! I've analyzed and fixed this issue.
+            
+            **Problem:** Sequential tool calling was getting stuck after first tool call.
+            
+            **Solution:** Added proper prompt handling after each tool call in the Ollama model integration.
+            
+            **Changes Made:**
+            - Modified `src/praisonai-agents/ollama-sequential.py`
+            - Added continuation prompts for multi-step tool execution
+            
+            **Pull Request:** https://github.com/MervinPraison/PraisonAI/pull/856
+            
+            The fix is ready for review. Please test and let me know if you encounter any issues!
+            ```
+            
+            **IMPORTANT NOTES:**
+            - Always create branches with 'gemini/' prefix
+            - Always include issue number in branch name and commit message
+            - Always create PR that references the issue
+            - Always provide PR link in your final response
+            - Use the GITHUB_TOKEN environment variable for authentication
+            
+            Please proceed with helping resolve this issue following this exact workflow.
+
+          settings_json: |
+            {
+              "coreTools": [
+                "run_shell_command(echo)",
+                "run_shell_command(gh issue view)",
+                "run_shell_command(gh issue comment)",
+                "run_shell_command(gh issue list)",
+                "run_shell_command(gh issue edit)",
+                "run_shell_command(gh pr create)",
+                "run_shell_command(gh pr view)",
+                "run_shell_command(gh pr list)",
+                "run_shell_command(cat)",
+                "run_shell_command(head)",
+                "run_shell_command(tail)",
+                "run_shell_command(grep)",
+                "run_shell_command(find)",
+                "run_shell_command(git checkout)",
+                "run_shell_command(git add)",
+                "run_shell_command(git commit)",
+                "run_shell_command(git push)",
+                "run_shell_command(git status)",
+                "run_shell_command(git branch)",
+                "list_directory",
+                "read_file",
+                "read_many_files",
+                "write_file",
+                "replace",
+                "glob",
+                "search_file_content",
+                "web_fetch",
+                "google_web_search",
+                "save_memory"
+              ],
+              "telemetry": {
+                "enabled": false,
+                "otlpGcpWifProvider": "${{ secrets.OTLP_GCP_WIF_PROVIDER }}",
+                "googleCloudProject": "${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}"
+              }
+            }

.github/workflows/gemini-pr-review.yml

@@ -0,0 +1,248 @@
+name: Gemini PR Review
+
+on:
+  issue_comment:
+    types: [created]
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: 'PR number to review'
+        required: true
+        type: number
+
+jobs:
+  review-pr:
+    if: >
+      github.event_name == 'workflow_dispatch' ||
+      (github.event_name == 'issue_comment' && 
+       github.event.issue.pull_request && 
+       contains(github.event.comment.body, '@gemini') &&
+       (github.event.comment.author_association == 'OWNER' ||
+        github.event.comment.author_association == 'MEMBER' ||
+        github.event.comment.author_association == 'COLLABORATOR'))
+    timeout-minutes: 15
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+      pull-requests: write
+      issues: write
+    steps:
+      - name: Generate GitHub App Token
+        id: generate_token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.PRIVATE_KEY }}
+
+      - name: Determine checkout ref
+        id: checkout_ref
+        run: |
+          if [ "${{ github.event_name }}" = "issue_comment" ]; then
+            echo "ref=refs/pull/${{ github.event.issue.number }}/head" >> "$GITHUB_OUTPUT"
+          else
+            echo "ref=${{ github.event.pull_request.head.sha }}" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Checkout PR code
+        uses: actions/checkout@v4
+        with:
+          token: ${{ steps.generate_token.outputs.token }}
+          ref: ${{ steps.checkout_ref.outputs.ref }}
+          fetch-depth: 0
+
+      - name: Get PR details
+        id: get_pr
+        env:
+          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
+          # Pass user-controlled inputs via environment variables to prevent script injection (GHSL-2025-093)
+          EVENT_NAME: ${{ github.event_name }}
+          EVENT_INPUTS_PR_NUMBER: ${{ github.event.inputs.pr_number }}
+          EVENT_ISSUE_NUMBER: ${{ github.event.issue.number }}
+          EVENT_PR_NUMBER: ${{ github.event.pull_request.number }}
+          EVENT_COMMENT_BODY: ${{ github.event.comment.body }}
+        run: |
+          if [ "$EVENT_NAME" = "workflow_dispatch" ]; then
+            PR_NUMBER=$EVENT_INPUTS_PR_NUMBER
+          elif [ "$EVENT_NAME" = "issue_comment" ]; then
+            PR_NUMBER=$EVENT_ISSUE_NUMBER
+          else
+            PR_NUMBER=$EVENT_PR_NUMBER
+          fi
+          
+          echo "pr_number=$PR_NUMBER" >> "$GITHUB_OUTPUT"
+          
+          # Extract additional instructions from comment (if triggered by comment)
+          ADDITIONAL_INSTRUCTIONS=""
+          if [ "$EVENT_NAME" = "issue_comment" ]; then
+            COMMENT_BODY="$EVENT_COMMENT_BODY"
+            ADDITIONAL_INSTRUCTIONS=$(echo "$COMMENT_BODY" | sed 's/.*@gemini//' | xargs)
+          fi
+          echo "additional_instructions=$ADDITIONAL_INSTRUCTIONS" >> "$GITHUB_OUTPUT"
+          
+          # Get PR details
+          PR_DATA=$(gh pr view $PR_NUMBER --json title,body,additions,deletions,changedFiles,baseRefName,headRefName)
+          echo "pr_data=$PR_DATA" >> "$GITHUB_OUTPUT"
+          
+          # Get file changes
+          CHANGED_FILES=$(gh pr diff $PR_NUMBER --name-only)
+          echo "changed_files<<EOF" >> "$GITHUB_OUTPUT"
+          echo "$CHANGED_FILES" >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+      - name: Run Gemini PR Review
+        uses: ./.github/actions/gemini
+        env:
+          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
+          PR_NUMBER: ${{ steps.get_pr.outputs.pr_number }}
+          PR_DATA: ${{ steps.get_pr.outputs.pr_data }}
+          CHANGED_FILES: ${{ steps.get_pr.outputs.changed_files }}
+          ADDITIONAL_INSTRUCTIONS: ${{ steps.get_pr.outputs.additional_instructions }}
+          REPOSITORY: ${{ github.repository }}
+        with:
+          version: 0.1.8-rc.0
+          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+          OTLP_GCP_WIF_PROVIDER: ${{ secrets.OTLP_GCP_WIF_PROVIDER }}
+          OTLP_GOOGLE_CLOUD_PROJECT: ${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}
+          settings_json: |
+            {
+              "coreTools": [
+                "run_shell_command(echo)",
+                "run_shell_command(gh pr view)",
+                "run_shell_command(gh pr diff)",
+                "run_shell_command(gh pr comment)",
+                "run_shell_command(gh pr list)",
+                "run_shell_command(cat)",
+                "run_shell_command(head)",
+                "run_shell_command(tail)",
+                "run_shell_command(grep)",
+                "run_shell_command(find)",
+                "run_shell_command(git checkout)",
+                "run_shell_command(git add)",
+                "run_shell_command(git commit)",
+                "run_shell_command(git push)",
+                "run_shell_command(git status)",
+                "run_shell_command(git branch)",
+                "run_shell_command(git fetch)",
+                "list_directory",
+                "read_file",
+                "read_many_files",
+                "write_file",
+                "replace",
+                "glob",
+                "search_file_content",
+                "web_fetch",
+                "google_web_search",
+                "save_memory"
+              ],
+              "telemetry": {
+                "enabled": false,
+                "target": "gcp"
+              },
+              "sandbox": false
+            }
+          prompt: |
+            You are an expert code reviewer and AI assistant for Pull Requests. You can review code AND make modifications to improve the PR.
+
+            **PR Details:**
+            - PR Number: #$PR_NUMBER
+            - Repository: $REPOSITORY
+            - Additional Instructions: $ADDITIONAL_INSTRUCTIONS
+
+            **CRITICAL: When making code modifications, follow this EXACT workflow:**
+
+            **STEP 1: Analyze the PR**
+            - Use: `echo "$PR_DATA"` to get PR details (JSON format)
+            - Use: `echo "$CHANGED_FILES"` to get changed files list
+            - Use: `gh pr diff ${PR_NUMBER}` to see the full diff
+            - Use: `gh pr view ${PR_NUMBER} --json title,body,headRefName` to get PR info
+            - Analyze the code changes thoroughly
+
+            **STEP 2: If Code Improvements Are Needed**
+            **IMPORTANT:** DO NOT create a new branch! Work on the EXISTING PR branch.
+            - Use: `git fetch origin` to get latest changes
+            - Get PR branch name: `gh pr view ${PR_NUMBER} --json headRefName`
+            - Switch to PR branch: `git checkout BRANCH_NAME` (use actual branch name from PR)
+            - Use: `git pull origin BRANCH_NAME` to get latest PR changes
+
+            **STEP 3: Make Code Modifications**
+            - Use `read_file` to examine existing code
+            - Use `write_file` or `replace` to make improvements
+            - Use `search_file_content` to find related code
+            - Make focused, targeted improvements to the PR
+
+            **STEP 4: Test Changes (if applicable)**
+            - Run relevant tests if test files exist
+            - Use `run_shell_command` to execute test commands
+
+            **STEP 5: Commit and Push Changes to EXISTING PR Branch**
+            - Use: `git add .` (or specific files)
+            - Use: `git commit -m "Gemini: [PR #${PR_NUMBER}] Brief description of improvements"`
+            - Use: `git push origin BRANCH_NAME` (push to EXISTING PR branch)
+
+            **STEP 6: Review and Comment on PR**
+            Write comprehensive review and post comment with your analysis and any improvements made.
+            Use: `gh pr comment ${PR_NUMBER} -b "MESSAGE"`
+
+            Review Guidelines:
+            - Focus on code quality, security, performance, and maintainability
+            - Check for common issues: potential bugs, security vulnerabilities, performance bottlenecks
+            - Verify error handling and edge cases
+            - Look for code style and best practices
+            - Comment on architecture and design decisions if significant
+            - Be constructive and specific in feedback
+            - Highlight both issues and positive aspects
+            - Suggest improvements with examples when possible
+            
+            Review Areas:
+            - **Security**: Authentication, authorization, input validation, data sanitization
+            - **Performance**: Algorithms, database queries, caching, resource usage
+            - **Reliability**: Error handling, logging, testing coverage, edge cases
+            - **Maintainability**: Code structure, documentation, naming conventions
+            - **Functionality**: Logic correctness, requirements fulfillment
+            
+            Output Format:
+            Structure your review using this exact format with markdown:
+
+            ## 📋 Review Summary
+            Provide a brief 2-3 sentence overview of the PR and overall assessment.
+
+            ## 🔍 General Feedback
+            - List general observations about code quality
+            - Mention overall patterns or architectural decisions
+            - Highlight positive aspects of the implementation
+            - Note any recurring themes across files
+
+            ## 🎯 Specific Feedback
+            Only include sections below that have actual issues. If there are no issues in a priority category, omit that entire section.
+
+            ### 🔴 Critical
+            (Only include this section if there are critical issues)
+            Issues that must be addressed before merging (security vulnerabilities, breaking changes, major bugs):
+            - **File: `filename:line`** - Description of critical issue with specific recommendation
+
+            ### 🟡 High
+            (Only include this section if there are high priority issues)
+            Important issues that should be addressed (performance problems, design flaws, significant bugs):
+            - **File: `filename:line`** - Description of high priority issue with suggested fix
+
+            ### 🟢 Medium
+            (Only include this section if there are medium priority issues)
+            Improvements that would enhance code quality (style issues, minor optimizations, better practices):
+            - **File: `filename:line`** - Description of medium priority improvement
+
+            ### 🔵 Low
+            (Only include this section if there are suggestions)
+            Nice-to-have improvements and suggestions (documentation, naming, minor refactoring):
+            - **File: `filename:line`** - Description of suggestion or enhancement
+
+            **Note**: If no specific issues are found in any category, simply state "No specific issues identified in this review."
+
+            ## ✅ Highlights
+            (Only include this section if there are positive aspects to highlight)
+            - Mention specific good practices or implementations
+            - Acknowledge well-written code sections
+            - Note improvements from previous versions
+
+            ---
+            *Review completed by Gemini CLI*

.github/workflows/python-package.yml

@@ -29,7 +29,7 @@ jobs:
       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 "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
         echo "LOGLEVEL=DEBUG" >> $GITHUB_ENV
 
     - name: Install dependencies

.github/workflows/test-comprehensive.yml

@@ -26,6 +26,10 @@ on:
 jobs:
   comprehensive-test:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
+    env:
+      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+      OPENAI_MODEL_NAME: gpt-4o-mini
     strategy:
       matrix:
         python-version: ["3.11"]
@@ -54,11 +58,13 @@ jobs:
         # Install knowledge dependencies from praisonai-agents
         uv pip install --system "praisonaiagents[knowledge]"
 
-    - name: Set environment variables
+    - name: Verify 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
+        if [ -n "$OPENAI_API_KEY" ]; then
+          echo "✅ OPENAI_API_KEY is set (length: ${#OPENAI_API_KEY})"
+        else
+          echo "⚠️ OPENAI_API_KEY is NOT set"
+        fi
 
     - name: Run Comprehensive Test Suite
       run: |

.github/workflows/test-core.yml

@@ -9,6 +9,7 @@ on:
 jobs:
   test-core:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     strategy:
       matrix:
         python-version: [3.11]
@@ -33,7 +34,7 @@ jobs:
         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
+        uv pip install --system pytest pytest-asyncio pytest-cov pytest-timeout
         # Install knowledge dependencies from praisonai-agents
         uv pip install --system "praisonaiagents[knowledge]"
 
@@ -41,13 +42,13 @@ jobs:
       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 "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $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 OPENAI_MODEL_NAME="${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}"
         export LOGLEVEL=DEBUG
         # Verify immediate availability
         echo "🔧 Immediate verification in same step:"
@@ -125,7 +126,7 @@ jobs:
       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' }}
+        OPENAI_MODEL_NAME: ${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}
         LOGLEVEL: DEBUG
       run: |
         echo "🔍 Testing PraisonAI API key usage directly..."
@@ -151,7 +152,7 @@ jobs:
             return 'INVALID_TYPE'
 
         print('🔧 Direct PraisonAI API Key Check:')
-        env_api_key = os.environ.get(\\"OPENAI_API_KEY\\", \\"NOT_SET\\")
+        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
@@ -163,9 +164,9 @@ jobs:
         
         from praisonai.inc.models import PraisonAIModel
         
-        print('\\\\n🧪 Testing PraisonAIModel with explicit API key (CrewAI method):')
+        print('\\n🧪 Testing PraisonAIModel with explicit API key (CrewAI method):')
         model_with_explicit_key = PraisonAIModel(
-            model='openai/gpt-4o-mini',
+            model='openai/gpt-5-nano',
             base_url=praisonai.config_list[0].get('base_url'),
             api_key=api_key_from_config # This will be a string from praisonai.config_list
         )
@@ -250,7 +251,7 @@ jobs:
       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' }}
+        OPENAI_MODEL_NAME: ${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}
         LOGLEVEL: DEBUG
       run: |
         echo "🧪 Running legacy tests with real API key..."
@@ -261,7 +262,7 @@ jobs:
         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
+        cd src/praisonai && python -m pytest tests/test.py -v --tb=short --disable-warnings -m "not real" --timeout=60
 
     - name: Upload coverage reports to Codecov
       if: matrix.python-version == '3.11'

.github/workflows/test-extended.yml

@@ -13,6 +13,7 @@ on:
 jobs:
   test-examples:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     
     steps:
     - name: Checkout code
@@ -41,8 +42,11 @@ jobs:
       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 "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
         echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
+        echo "PRAISONAI_TELEMETRY_DISABLED=true" >> $GITHUB_ENV
+        echo "PRAISONAI_DISABLE_TELEMETRY=true" >> $GITHUB_ENV
+        echo "DO_NOT_TRACK=true" >> $GITHUB_ENV
 
     - name: Test Key Example Scripts
       run: |
@@ -73,6 +77,7 @@ jobs:
 
   performance-test:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     
     steps:
     - name: Checkout code
@@ -97,6 +102,12 @@ jobs:
         # Install knowledge dependencies from praisonai-agents
         uv pip install --system "praisonaiagents[knowledge]"
 
+    - name: Set environment variables
+      run: |
+        echo "PRAISONAI_TELEMETRY_DISABLED=true" >> $GITHUB_ENV
+        echo "PRAISONAI_DISABLE_TELEMETRY=true" >> $GITHUB_ENV
+        echo "DO_NOT_TRACK=true" >> $GITHUB_ENV
+
     - name: Run Performance Benchmarks
       run: |
         echo "🏃 Running performance benchmarks..."
@@ -161,4 +172,4 @@ jobs:
       with:
         name: performance-report
         path: performance_report.md
-        retention-days: 30 
+        retention-days: 5

.github/workflows/test-frameworks.yml

@@ -24,6 +24,7 @@ on:
 jobs:
   framework-tests:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     strategy:
       matrix:
         python-version: [3.11]
@@ -55,7 +56,7 @@ jobs:
       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 "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
 
     - name: Test ${{ matrix.framework }} Framework
       run: |

.github/workflows/test-real.yml

@@ -26,6 +26,7 @@ jobs:
   real-tests:
     runs-on: ubuntu-latest
     if: ${{ github.event.inputs.confirm_costs == 'true' && github.event.inputs.framework != 'none' }}
+    timeout-minutes: 15
     
     strategy:
       matrix:

.github/workflows/unittest.yml

@@ -5,6 +5,7 @@ on: [push, pull_request]
 jobs:
   quick-test:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
 
     steps:
     - name: Checkout code
@@ -26,7 +27,7 @@ jobs:
         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
+        uv pip install --system pytest pytest-asyncio pytest-cov pytest-timeout
         # Install knowledge dependencies from praisonai-agents
         uv pip install --system "praisonaiagents[knowledge]"
 
@@ -34,7 +35,7 @@ jobs:
       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 "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
         echo "LOGLEVEL=DEBUG" >> $GITHUB_ENV
         echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
 
@@ -315,8 +316,8 @@ jobs:
         try:
             from praisonai.inc.models import PraisonAIModel
             
-            # Test PraisonAIModel with openai/gpt-4o-mini (from YAML)
-            model = PraisonAIModel(model='openai/gpt-4o-mini')
+            # Test PraisonAIModel with openai/gpt-5-nano (from YAML)
+            model = PraisonAIModel(model='openai/gpt-5-nano')
             
             print('🤖 PraisonAIModel Configuration:')
             print(f'  model: {model.model}')
@@ -488,7 +489,7 @@ jobs:
 
     - name: Run Legacy Example Tests
       run: |
-        cd src/praisonai && python -m pytest tests/test.py -v --tb=short --disable-warnings
+        cd src/praisonai && python -m pytest tests/test.py -v --tb=short --disable-warnings -m "not real" --timeout=60
       continue-on-error: true
 
     - name: Upload coverage reports to Codecov

.gitignore

@@ -75,4 +75,9 @@ agents/praisonaiagents/praisonaiagents.egg-info
 # Local Netlify folder
 .netlify
 .qodo
-CopilotKit*
+CopilotKit*
+.gemini
+issue_details.json
+
+# MCP Registry tokens
+.mcpregistry_*

docker/Dockerfile

@@ -14,9 +14,10 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN mkdir -p /root/.praison
 
 # Install Python packages (using latest versions)
+# Note: praisonai is installed from PyPI - remove version pin to use latest available
 RUN pip install --no-cache-dir \
     flask \
-    "praisonai>=2.2.48" \
+    praisonai \
     "praisonai[api]" \
     gunicorn \
     markdown

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.48" \
+    "praisonai>=2.3.46" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.48" \
+    "praisonai>=2.3.46" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.serve

@@ -0,0 +1,25 @@
+# Dockerfile for PraisonAI Serve API
+# Deploy to Railway, Render, Fly.io, or any container platform
+#
+# Build: docker build -f Dockerfile.serve -t praisonai-serve .
+# Run:   docker run -p 8005:8005 -e OPENAI_API_KEY=sk-xxx praisonai-serve
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install dependencies
+RUN pip install --no-cache-dir praisonai praisonaiagents
+
+# Copy agents configuration
+COPY agents.yaml .
+
+# Expose the API port
+EXPOSE 8005
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8005/health || exit 1
+
+# Start the API server
+CMD ["praisonai", "serve", "agents.yaml", "--host", "0.0.0.0", "--port", "8005"]

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.48" \
+    "praisonai>=2.3.46" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

docker/README.md

@@ -121,7 +121,7 @@ healthcheck:
 ## 📦 Package Versions
 
 All Docker images use consistent, up-to-date versions:
-- PraisonAI: `>=2.2.48`
+- PraisonAI: `>=2.2.95`
 - PraisonAI Agents: `>=0.0.92`
 - Python: `3.11-slim`
 
@@ -218,7 +218,7 @@ docker-compose up -d
 ### Version Pinning
 To use specific versions, update the Dockerfile:
 ```dockerfile
-RUN pip install "praisonai==2.2.48" "praisonaiagents==0.0.92"
+RUN pip install "praisonai==2.2.95" "praisonaiagents==0.0.92"
 ```
 
 ## 🌐 Production Deployment

docker/docker-compose.dev.yml

@@ -137,22 +137,11 @@ services:
       POSTGRES_USER: praisonai
       POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-praisonai_dev_pass}
     volumes:
-   database:
-     image: postgres:15-alpine
-     environment:
-       POSTGRES_DB: praisonai_dev
-       POSTGRES_USER: praisonai
-       POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-praisonai_dev_pass}
-     volumes:
-       - postgres_data:/var/lib/postgresql/data
-     read_only: true
-     tmpfs:
-       - /tmp
-       - /var/tmp
-     ports:
-       - "5432:5432"
-     networks:
       - postgres_data:/var/lib/postgresql/data
+    read_only: true
+    tmpfs:
+      - /tmp
+      - /var/tmp
     ports:
       - "5432:5432"
     networks:

examples/README.md

@@ -0,0 +1,49 @@
+# PraisonAI Examples
+
+This folder contains examples for PraisonAI. For detailed documentation, visit [docs.praison.ai](https://docs.praison.ai).
+
+## Structure
+
+```
+examples/
+├── python/           # Python examples
+│   ├── agents/       # Agent examples (single, multi, router, etc.)
+│   ├── workflows/    # Workflow patterns (routing, parallel, loop)
+│   ├── tools/        # Custom tools examples
+│   ├── mcp/          # MCP protocol examples
+│   ├── memory/       # Memory and sessions
+│   ├── code/         # Code editing and external CLI tools
+│   └── ...
+├── yaml/             # YAML workflow examples
+└── cookbooks/        # Complete use-case examples
+```
+
+## Quick Links
+
+| Category | Examples | Docs |
+|----------|----------|------|
+| **Agents** | [python/agents/](python/agents/) | [📖](https://docs.praison.ai/concepts/agents) |
+| **Workflows** | [python/workflows/](python/workflows/) | [📖](https://docs.praison.ai/features/workflows) |
+| **Model Router** | [python/agents/router-agent-cost-optimization.py](python/agents/router-agent-cost-optimization.py) | [📖](https://docs.praison.ai/features/model-router) |
+| **MCP** | [python/mcp/](python/mcp/) | [📖](https://docs.praison.ai/mcp) |
+| **Memory** | [python/memory/](python/memory/) | [📖](https://docs.praison.ai/concepts/memory) |
+| **Tools** | [python/tools/](python/tools/) | [📖](https://docs.praison.ai/tools) |
+| **Code** | [python/code/](python/code/) | [📖](https://docs.praison.ai/code) |
+| **YAML** | [yaml/](yaml/) | [📖](https://docs.praison.ai/features/yaml-workflows) |
+
+## Running Examples
+
+```bash
+# Install PraisonAI
+pip install praisonai
+
+# Set API key
+export OPENAI_API_KEY=your_key_here
+
+# Run an example
+python examples/python/agents/single-agent.py
+```
+
+## CLI Commands
+
+See the main [README.md](../README.md#-cli--no-code-interface) for all CLI commands.

examples/context/00_agent_fast_context_basic.py

@@ -0,0 +1,89 @@
+"""
+Fast Context with Agent - Basic Example
+
+This is the simplest way to use Fast Context with an Agent.
+Just set fast_context=True and the agent will automatically
+have access to rapid code search capabilities.
+
+Fast Context provides:
+- 10-20x faster code search than traditional methods
+- Parallel execution (8 concurrent searches)
+- Automatic caching for repeated queries
+- Seamless integration with Agent workflows
+"""
+
+from praisonaiagents import Agent
+
+def main():
+    print("=" * 60)
+    print("Agent with Fast Context - Basic Example")
+    print("=" * 60)
+    
+    # Create an agent with Fast Context enabled
+    # This is the simplest configuration
+    agent = Agent(
+        name="CodeAssistant",
+        instructions="You are a helpful code assistant.",
+        fast_context=True,  # Enable Fast Context
+        fast_context_path=".",  # Search in current directory
+        verbose=False
+    )
+    
+    print("\n✓ Agent created with Fast Context enabled")
+    print(f"  - fast_context_enabled: {agent.fast_context_enabled}")
+    print(f"  - fast_context_path: {agent.fast_context_path}")
+    print(f"  - fast_context_model: {agent.fast_context_model}")
+    
+    # Use delegate_to_fast_context to search code
+    print("\n" + "-" * 60)
+    print("Searching for 'class Agent' in the codebase...")
+    print("-" * 60)
+    
+    context = agent.delegate_to_fast_context("class Agent")
+    
+    if context:
+        print(f"\n✓ Found relevant code!")
+        print(f"  Context length: {len(context)} characters")
+        print("\nPreview of found context:")
+        print("-" * 40)
+        # Show first 500 characters
+        preview = context[:500]
+        print(preview)
+        if len(context) > 500:
+            print("...")
+    else:
+        print("\n✗ No relevant code found")
+    
+    # Another search example
+    print("\n" + "-" * 60)
+    print("Searching for 'def chat' in the codebase...")
+    print("-" * 60)
+    
+    context = agent.delegate_to_fast_context("def chat")
+    
+    if context:
+        print(f"\n✓ Found relevant code!")
+        print(f"  Context length: {len(context)} characters")
+    else:
+        print("\n✗ No relevant code found")
+    
+    # Access FastContext directly for more control
+    print("\n" + "-" * 60)
+    print("Direct FastContext access for advanced usage...")
+    print("-" * 60)
+    
+    fc = agent.fast_context
+    if fc:
+        result = fc.search("import")
+        print(f"\n✓ Direct search for 'import':")
+        print(f"  Files found: {result.total_files}")
+        print(f"  Search time: {result.search_time_ms}ms")
+        print(f"  From cache: {result.from_cache}")
+    
+    print("\n" + "=" * 60)
+    print("Fast Context makes code search instant for your agents!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

examples/context/01_basic_fast_context.py

@@ -0,0 +1,84 @@
+"""
+Example 1: Basic Fast Context Usage
+
+This example demonstrates the basic usage of Fast Context for rapid code search.
+Fast Context is 10-20x faster than traditional sequential search because it:
+- Executes up to 8 tool calls in parallel
+- Limits search to 4 turns maximum
+- Uses a lightweight model optimized for search
+"""
+
+from praisonaiagents.context.fast import FastContext
+import time
+
+def main():
+    print("=" * 70)
+    print("Fast Context - Basic Usage Example")
+    print("=" * 70)
+    
+    # Create FastContext instance pointing to the praisonai-agents codebase
+    fc = FastContext(
+        workspace_path="/Users/praison/praisonai-package/src/praisonai-agents"
+    )
+    
+    # Example 1: Simple pattern search
+    print("\n1. Simple Pattern Search")
+    print("-" * 40)
+    
+    start = time.perf_counter()
+    result = fc.search("def chat")
+    elapsed = (time.perf_counter() - start) * 1000
+    
+    print(f"   Query: 'def chat'")
+    print(f"   Files found: {result.total_files}")
+    print(f"   Search time: {result.search_time_ms}ms (total: {elapsed:.0f}ms)")
+    print(f"   Turns used: {result.turns_used}")
+    print(f"   Tool calls: {result.total_tool_calls}")
+    
+    if result.files:
+        print("\n   Top matches:")
+        for f in result.files[:3]:
+            print(f"   - {f.path}")
+            for lr in f.line_ranges[:2]:
+                print(f"     Lines {lr.start}-{lr.end}")
+    
+    # Example 2: Search for class definitions
+    print("\n2. Search for Class Definitions")
+    print("-" * 40)
+    
+    result = fc.search("class Agent")
+    print(f"   Query: 'class Agent'")
+    print(f"   Files found: {result.total_files}")
+    print(f"   Search time: {result.search_time_ms}ms")
+    
+    if result.files:
+        print("\n   Files containing 'class Agent':")
+        for f in result.files[:5]:
+            print(f"   - {f.path} (relevance: {f.relevance_score:.2f})")
+    
+    # Example 3: Search for imports
+    print("\n3. Search for Specific Imports")
+    print("-" * 40)
+    
+    result = fc.search("from typing import")
+    print(f"   Query: 'from typing import'")
+    print(f"   Files found: {result.total_files}")
+    print(f"   Search time: {result.search_time_ms}ms")
+    
+    # Example 4: Get formatted context string
+    print("\n4. Get Formatted Context for Agent")
+    print("-" * 40)
+    
+    context = fc.get_context_for_agent("authentication", max_files=3)
+    print(f"   Context length: {len(context)} characters")
+    print(f"   Preview:")
+    preview = context[:300].replace('\n', '\n   ')
+    print(f"   {preview}...")
+    
+    print("\n" + "=" * 70)
+    print("Fast Context provides rapid, parallel code search!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

examples/context/02_parallel_vs_sequential.py

@@ -0,0 +1,113 @@
+"""
+Example 2: Parallel vs Sequential Search Comparison
+
+This example demonstrates the speed advantage of Fast Context's parallel
+execution compared to traditional sequential search.
+
+Key insight: Fast Context executes up to 8 searches simultaneously,
+making it 5-10x faster for complex queries.
+"""
+
+import time
+import os
+from praisonaiagents.context.fast import FastContext
+from praisonaiagents.context.fast.search_tools import grep_search, glob_search
+
+WORKSPACE = "/Users/praison/praisonai-package/src/praisonai-agents"
+
+
+def sequential_search(queries: list) -> dict:
+    """Traditional sequential search - one query at a time."""
+    results = {}
+    for query in queries:
+        results[query] = grep_search(
+            search_path=WORKSPACE,
+            pattern=query,
+            max_results=20
+        )
+    return results
+
+
+def parallel_search_with_fast_context(queries: list) -> dict:
+    """Fast Context parallel search - multiple queries at once."""
+    fc = FastContext(workspace_path=WORKSPACE)
+    results = {}
+    for query in queries:
+        result = fc.search(query)
+        results[query] = result
+    return results
+
+
+def main():
+    print("=" * 70)
+    print("Parallel vs Sequential Search Comparison")
+    print("=" * 70)
+    
+    # Define multiple search queries
+    queries = [
+        "def __init__",
+        "class Agent",
+        "async def",
+        "import logging",
+        "from typing",
+    ]
+    
+    print(f"\nSearching for {len(queries)} patterns in the codebase...")
+    print(f"Workspace: {WORKSPACE}")
+    
+    # Sequential search
+    print("\n1. Sequential Search (Traditional)")
+    print("-" * 40)
+    
+    start = time.perf_counter()
+    seq_results = sequential_search(queries)
+    seq_time = (time.perf_counter() - start) * 1000
+    
+    total_seq_matches = sum(len(r) for r in seq_results.values())
+    print(f"   Total matches: {total_seq_matches}")
+    print(f"   Time: {seq_time:.0f}ms")
+    
+    # Fast Context search (with caching disabled for fair comparison)
+    print("\n2. Fast Context Search (Parallel)")
+    print("-" * 40)
+    
+    fc = FastContext(workspace_path=WORKSPACE, cache_enabled=False)
+    
+    start = time.perf_counter()
+    fc_results = {}
+    for query in queries:
+        fc_results[query] = fc.search(query)
+    fc_time = (time.perf_counter() - start) * 1000
+    
+    total_fc_matches = sum(r.total_files for r in fc_results.values())
+    print(f"   Total files found: {total_fc_matches}")
+    print(f"   Time: {fc_time:.0f}ms")
+    
+    # Comparison
+    print("\n3. Comparison")
+    print("-" * 40)
+    
+    speedup = seq_time / fc_time if fc_time > 0 else float('inf')
+    print(f"   Sequential: {seq_time:.0f}ms")
+    print(f"   Fast Context: {fc_time:.0f}ms")
+    print(f"   Speedup: {speedup:.1f}x faster")
+    
+    # Detailed results
+    print("\n4. Results by Query")
+    print("-" * 40)
+    
+    for query in queries:
+        seq_count = len(seq_results[query])
+        fc_count = fc_results[query].total_files
+        fc_ms = fc_results[query].search_time_ms
+        print(f"   '{query}':")
+        print(f"      Sequential: {seq_count} matches")
+        print(f"      Fast Context: {fc_count} files in {fc_ms}ms")
+    
+    print("\n" + "=" * 70)
+    print(f"Fast Context is {speedup:.1f}x faster due to parallel execution!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

examples/context/03_caching_performance.py

@@ -0,0 +1,132 @@
+"""
+Example 3: Caching Performance Demonstration
+
+This example shows how Fast Context's caching dramatically improves
+performance for repeated queries.
+
+Key benefits:
+- First query: Full search execution
+- Subsequent queries: Instant cache hit (0ms search time)
+- Configurable TTL (time-to-live)
+"""
+
+import time
+from praisonaiagents.context.fast import FastContext
+
+WORKSPACE = "/Users/praison/praisonai-package/src/praisonai-agents"
+
+
+def main():
+    print("=" * 70)
+    print("Fast Context Caching Performance")
+    print("=" * 70)
+    
+    # Create FastContext with caching enabled
+    fc = FastContext(
+        workspace_path=WORKSPACE,
+        cache_enabled=True,
+        cache_ttl=300  # 5 minutes
+    )
+    
+    query = "def execute"
+    
+    print(f"\nQuery: '{query}'")
+    print(f"Cache TTL: 300 seconds")
+    
+    # First search - cache miss
+    print("\n1. First Search (Cache Miss)")
+    print("-" * 40)
+    
+    start = time.perf_counter()
+    result1 = fc.search(query)
+    elapsed1 = (time.perf_counter() - start) * 1000
+    
+    print(f"   Files found: {result1.total_files}")
+    print(f"   From cache: {result1.from_cache}")
+    print(f"   Search time: {result1.search_time_ms}ms")
+    print(f"   Total time: {elapsed1:.1f}ms")
+    
+    # Second search - cache hit
+    print("\n2. Second Search (Cache Hit)")
+    print("-" * 40)
+    
+    start = time.perf_counter()
+    result2 = fc.search(query)
+    elapsed2 = (time.perf_counter() - start) * 1000
+    
+    print(f"   Files found: {result2.total_files}")
+    print(f"   From cache: {result2.from_cache}")
+    print(f"   Search time: {result2.search_time_ms}ms")
+    print(f"   Total time: {elapsed2:.1f}ms")
+    
+    # Third search - still cached
+    print("\n3. Third Search (Still Cached)")
+    print("-" * 40)
+    
+    start = time.perf_counter()
+    result3 = fc.search(query)
+    elapsed3 = (time.perf_counter() - start) * 1000
+    
+    print(f"   Files found: {result3.total_files}")
+    print(f"   From cache: {result3.from_cache}")
+    print(f"   Total time: {elapsed3:.1f}ms")
+    
+    # Clear cache and search again
+    print("\n4. After Cache Clear")
+    print("-" * 40)
+    
+    fc.clear_cache()
+    print("   Cache cleared!")
+    
+    start = time.perf_counter()
+    result4 = fc.search(query)
+    elapsed4 = (time.perf_counter() - start) * 1000
+    
+    print(f"   Files found: {result4.total_files}")
+    print(f"   From cache: {result4.from_cache}")
+    print(f"   Search time: {result4.search_time_ms}ms")
+    print(f"   Total time: {elapsed4:.1f}ms")
+    
+    # Performance comparison
+    print("\n5. Performance Summary")
+    print("-" * 40)
+    
+    cache_speedup = elapsed1 / elapsed2 if elapsed2 > 0 else float('inf')
+    
+    print(f"   First search (no cache): {elapsed1:.1f}ms")
+    print(f"   Cached searches: ~{elapsed2:.1f}ms")
+    print(f"   Cache speedup: {cache_speedup:.0f}x faster")
+    
+    # Multiple different queries
+    print("\n6. Multiple Query Caching")
+    print("-" * 40)
+    
+    queries = ["class Agent", "async def", "import os", "def __init__"]
+    
+    # First pass - populate cache
+    print("   First pass (populating cache):")
+    start = time.perf_counter()
+    for q in queries:
+        fc.search(q)
+    first_pass = (time.perf_counter() - start) * 1000
+    print(f"   Time: {first_pass:.0f}ms")
+    
+    # Second pass - all cached
+    print("   Second pass (all cached):")
+    start = time.perf_counter()
+    for q in queries:
+        r = fc.search(q)
+        assert r.from_cache, f"Expected cache hit for '{q}'"
+    second_pass = (time.perf_counter() - start) * 1000
+    print(f"   Time: {second_pass:.1f}ms")
+    
+    multi_speedup = first_pass / second_pass if second_pass > 0 else float('inf')
+    print(f"   Speedup: {multi_speedup:.0f}x faster")
+    
+    print("\n" + "=" * 70)
+    print("Caching provides instant results for repeated queries!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

examples/context/04_agent_integration.py

@@ -0,0 +1,112 @@
+"""
+Example 4: Agent Integration with Fast Context
+
+This example shows how to use Fast Context integrated with the Agent class
+for automatic code search delegation.
+
+Benefits:
+- Seamless integration with existing Agent workflows
+- Automatic context injection for code-related queries
+- Configurable via Agent parameters or environment variables
+"""
+
+from praisonaiagents import Agent
+
+WORKSPACE = "/Users/praison/praisonai-package/src/praisonai-agents"
+
+
+def main():
+    print("=" * 70)
+    print("Agent Integration with Fast Context")
+    print("=" * 70)
+    
+    # Create an agent with Fast Context enabled
+    print("\n1. Creating Agent with Fast Context")
+    print("-" * 40)
+    
+    agent = Agent(
+        name="CodeAssistant",
+        instructions="You are a helpful code assistant that can search and analyze code.",
+        fast_context=True,
+        fast_context_path=WORKSPACE,
+        fast_context_model="gpt-4o-mini",
+        fast_context_max_turns=4,
+        fast_context_parallelism=8,
+        fast_context_timeout=30.0,
+        verbose=False
+    )
+    
+    print(f"   Agent name: {agent.name}")
+    print(f"   Fast Context enabled: {agent.fast_context_enabled}")
+    print(f"   Fast Context path: {agent.fast_context_path}")
+    print(f"   Fast Context model: {agent.fast_context_model}")
+    print(f"   Max turns: {agent.fast_context_max_turns}")
+    print(f"   Parallelism: {agent.fast_context_parallelism}")
+    
+    # Use delegate_to_fast_context for code search
+    print("\n2. Delegating Code Search to Fast Context")
+    print("-" * 40)
+    
+    queries = [
+        "find the Agent class definition",
+        "search for authentication handlers",
+        "locate memory management code",
+    ]
+    
+    for query in queries:
+        print(f"\n   Query: '{query}'")
+        context = agent.delegate_to_fast_context(query)
+        
+        if context:
+            # Show preview of context
+            lines = context.split('\n')
+            preview_lines = lines[:5]
+            print(f"   Found context ({len(context)} chars):")
+            for line in preview_lines:
+                print(f"      {line[:60]}{'...' if len(line) > 60 else ''}")
+            if len(lines) > 5:
+                print(f"      ... and {len(lines) - 5} more lines")
+        else:
+            print("   No relevant code found")
+    
+    # Access the FastContext instance directly
+    print("\n3. Direct FastContext Access")
+    print("-" * 40)
+    
+    fc = agent.fast_context
+    if fc:
+        result = fc.search("def chat")
+        print(f"   Direct search for 'def chat':")
+        print(f"   Files found: {result.total_files}")
+        print(f"   Search time: {result.search_time_ms}ms")
+        
+        for f in result.files[:3]:
+            print(f"   - {f.path}")
+    
+    # Show configuration options
+    print("\n4. Configuration Options")
+    print("-" * 40)
+    
+    print("   Agent parameters:")
+    print("   - fast_context=True              # Enable Fast Context")
+    print("   - fast_context_path='.'          # Workspace path")
+    print("   - fast_context_model='gpt-4o-mini'  # Search model")
+    print("   - fast_context_max_turns=4       # Max search turns")
+    print("   - fast_context_parallelism=8     # Parallel calls")
+    print("   - fast_context_timeout=30.0      # Timeout (seconds)")
+    
+    print("\n   Environment variables:")
+    print("   - FAST_CONTEXT_MODEL")
+    print("   - FAST_CONTEXT_MAX_TURNS")
+    print("   - FAST_CONTEXT_PARALLELISM")
+    print("   - FAST_CONTEXT_TIMEOUT")
+    print("   - FAST_CONTEXT_CACHE")
+    print("   - FAST_CONTEXT_CACHE_TTL")
+    
+    print("\n" + "=" * 70)
+    print("Fast Context integrates seamlessly with Agent for code search!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

examples/context/05_file_and_symbol_indexing.py

@@ -0,0 +1,121 @@
+"""
+Example 5: File and Symbol Indexing
+
+This example demonstrates the file and symbol indexing capabilities
+that power Fast Context's rapid search.
+
+Features:
+- FileIndexer: Index file metadata for fast lookups
+- SymbolIndexer: Extract code symbols (functions, classes, imports)
+- Support for Python, JavaScript, TypeScript, Go, Rust, Java
+"""
+
+import time
+from praisonaiagents.context.fast.indexer import (
+    FileIndexer,
+    SymbolIndexer,
+    SymbolType
+)
+
+WORKSPACE = "/Users/praison/praisonai-package/src/praisonai-agents"
+
+
+def main():
+    print("=" * 70)
+    print("File and Symbol Indexing")
+    print("=" * 70)
+    
+    # File Indexer
+    print("\n1. File Indexer")
+    print("-" * 40)
+    
+    start = time.perf_counter()
+    file_indexer = FileIndexer(workspace_path=WORKSPACE)
+    file_count = file_indexer.index()
+    file_time = (time.perf_counter() - start) * 1000
+    
+    print(f"   Indexed {file_count} files in {file_time:.0f}ms")
+    
+    stats = file_indexer.get_stats()
+    print(f"   Total size: {stats['total_size_mb']} MB")
+    print(f"   Extensions: {list(stats['extensions'].keys())[:5]}")
+    
+    # Find files by pattern
+    print("\n   Finding files by pattern:")
+    py_files = file_indexer.find_by_pattern("**/*.py")
+    print(f"   - Python files (*.py): {len(py_files)}")
+    
+    agent_files = file_indexer.find_by_pattern("**/agent*.py")
+    print(f"   - Agent files (agent*.py): {len(agent_files)}")
+    
+    # Find files by name
+    print("\n   Finding files by name:")
+    init_files = file_indexer.find_by_name("__init__.py", exact=True)
+    print(f"   - __init__.py files: {len(init_files)}")
+    
+    agent_matches = file_indexer.find_by_name("agent")
+    print(f"   - Files containing 'agent': {len(agent_matches)}")
+    
+    # Symbol Indexer
+    print("\n2. Symbol Indexer")
+    print("-" * 40)
+    
+    start = time.perf_counter()
+    symbol_indexer = SymbolIndexer(workspace_path=WORKSPACE)
+    symbol_count = symbol_indexer.index()
+    symbol_time = (time.perf_counter() - start) * 1000
+    
+    print(f"   Indexed {symbol_count} symbols in {symbol_time:.0f}ms")
+    
+    stats = symbol_indexer.get_stats()
+    print(f"   Files indexed: {stats['total_files']}")
+    print(f"   Symbols by type:")
+    for sym_type, count in stats['by_type'].items():
+        print(f"      - {sym_type}: {count}")
+    
+    # Find symbols by name
+    print("\n   Finding symbols by name:")
+    
+    agent_symbols = symbol_indexer.find_by_name("Agent", exact=True)
+    print(f"   - 'Agent' (exact): {len(agent_symbols)} symbols")
+    for sym in agent_symbols[:3]:
+        print(f"      {sym.symbol_type.value}: {sym.name} in {sym.file_path}:{sym.line_number}")
+    
+    chat_symbols = symbol_indexer.find_by_name("chat")
+    print(f"   - 'chat' (partial): {len(chat_symbols)} symbols")
+    for sym in chat_symbols[:3]:
+        print(f"      {sym.symbol_type.value}: {sym.name} in {sym.file_path}:{sym.line_number}")
+    
+    # Find symbols by type
+    print("\n   Finding symbols by type:")
+    
+    classes = symbol_indexer.find_by_type(SymbolType.CLASS)
+    print(f"   - Classes: {len(classes)}")
+    for cls in classes[:5]:
+        print(f"      class {cls.name} in {cls.file_path}:{cls.line_number}")
+    
+    functions = symbol_indexer.find_by_type(SymbolType.FUNCTION)
+    print(f"   - Functions: {len(functions)}")
+    
+    methods = symbol_indexer.find_by_type(SymbolType.METHOD)
+    print(f"   - Methods: {len(methods)}")
+    
+    imports = symbol_indexer.find_by_type(SymbolType.IMPORT)
+    print(f"   - Imports: {len(imports)}")
+    
+    # Performance comparison
+    print("\n3. Performance Summary")
+    print("-" * 40)
+    
+    print(f"   File indexing: {file_time:.0f}ms for {file_count} files")
+    print(f"   Symbol indexing: {symbol_time:.0f}ms for {symbol_count} symbols")
+    print(f"   Files per second: {file_count / (file_time / 1000):.0f}")
+    print(f"   Symbols per second: {symbol_count / (symbol_time / 1000):.0f}")
+    
+    print("\n" + "=" * 70)
+    print("Indexing enables instant lookups for files and symbols!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

examples/context/06_context_injection.py

@@ -0,0 +1,163 @@
+"""
+Example 6: Context Injection for Agents
+
+This example demonstrates how Fast Context results can be formatted
+and injected into agent prompts for better code understanding.
+
+Features:
+- Multiple format styles (markdown, xml, plain)
+- Token budget management
+- Precision over recall (avoid context pollution)
+"""
+
+from praisonaiagents.context.fast import FastContext
+from praisonaiagents.context.fast.context_injector import (
+    ContextInjector,
+    InjectionConfig,
+    inject_fast_context
+)
+
+WORKSPACE = "/Users/praison/praisonai-package/src/praisonai-agents"
+
+
+def main():
+    print("=" * 70)
+    print("Context Injection for Agents")
+    print("=" * 70)
+    
+    # Search for code
+    fc = FastContext(workspace_path=WORKSPACE)
+    result = fc.search("class Agent")
+    
+    print(f"\nSearch results: {result.total_files} files found")
+    
+    # Markdown format (default)
+    print("\n1. Markdown Format")
+    print("-" * 40)
+    
+    config_md = InjectionConfig(
+        max_tokens=2000,
+        max_files=3,
+        max_lines_per_file=20,
+        format_style="markdown",
+        include_line_numbers=True,
+        include_file_content=True,
+        prioritize_precision=True
+    )
+    
+    injector_md = ContextInjector(config_md)
+    md_context = injector_md.format_context(result)
+    
+    print(f"   Format: Markdown")
+    print(f"   Length: {len(md_context)} chars (~{len(md_context)//4} tokens)")
+    print(f"   Preview:")
+    for line in md_context.split('\n')[:10]:
+        print(f"   {line[:70]}")
+    print("   ...")
+    
+    # XML format
+    print("\n2. XML Format")
+    print("-" * 40)
+    
+    config_xml = InjectionConfig(
+        max_tokens=2000,
+        max_files=3,
+        format_style="xml",
+        prioritize_precision=True
+    )
+    
+    injector_xml = ContextInjector(config_xml)
+    xml_context = injector_xml.format_context(result)
+    
+    print(f"   Format: XML")
+    print(f"   Length: {len(xml_context)} chars")
+    print(f"   Preview:")
+    for line in xml_context.split('\n')[:10]:
+        print(f"   {line[:70]}")
+    print("   ...")
+    
+    # Plain text format
+    print("\n3. Plain Text Format")
+    print("-" * 40)
+    
+    config_plain = InjectionConfig(
+        max_tokens=2000,
+        max_files=3,
+        format_style="plain"
+    )
+    
+    injector_plain = ContextInjector(config_plain)
+    plain_context = injector_plain.format_context(result)
+    
+    print(f"   Format: Plain")
+    print(f"   Length: {len(plain_context)} chars")
+    print(f"   Preview:")
+    for line in plain_context.split('\n')[:8]:
+        print(f"   {line[:70]}")
+    print("   ...")
+    
+    # Inject into prompts
+    print("\n4. Injecting into Prompts")
+    print("-" * 40)
+    
+    system_prompt = "You are a helpful code assistant."
+    user_message = "Explain how the Agent class works."
+    
+    injected = inject_fast_context(
+        result=result,
+        system_prompt=system_prompt,
+        user_message=user_message,
+        max_tokens=1500,
+        format_style="markdown"
+    )
+    
+    print(f"   Original system prompt: {len(system_prompt)} chars")
+    print(f"   Injected system prompt: {len(injected['system_prompt'])} chars")
+    print(f"   User message unchanged: {injected['user_message'] == user_message}")
+    
+    # Token budget management
+    print("\n5. Token Budget Management")
+    print("-" * 40)
+    
+    budgets = [500, 1000, 2000, 4000]
+    
+    for budget in budgets:
+        config = InjectionConfig(max_tokens=budget, max_files=10)
+        injector = ContextInjector(config)
+        context = injector.format_context(result)
+        estimated_tokens = len(context) // 4
+        print(f"   Budget: {budget} tokens -> {len(context)} chars (~{estimated_tokens} tokens)")
+    
+    # Precision mode
+    print("\n6. Precision vs Recall")
+    print("-" * 40)
+    
+    # High precision (fewer, more relevant results)
+    config_precision = InjectionConfig(
+        max_tokens=2000,
+        max_files=5,
+        prioritize_precision=True
+    )
+    injector_precision = ContextInjector(config_precision)
+    precision_context = injector_precision.format_context(result)
+    
+    # Lower precision (more results)
+    config_recall = InjectionConfig(
+        max_tokens=2000,
+        max_files=10,
+        prioritize_precision=False
+    )
+    injector_recall = ContextInjector(config_recall)
+    recall_context = injector_recall.format_context(result)
+    
+    print(f"   High precision mode: {len(precision_context)} chars")
+    print(f"   High recall mode: {len(recall_context)} chars")
+    print(f"   Precision mode is more focused for better agent understanding")
+    
+    print("\n" + "=" * 70)
+    print("Context injection formats search results for optimal agent use!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

examples/context/07_search_tools_demo.py

@@ -0,0 +1,213 @@
+"""
+Example 7: Search Tools Deep Dive
+
+This example demonstrates the individual search tools that power Fast Context:
+- grep_search: Pattern-based search with regex support
+- glob_search: File pattern matching
+- read_file: Read file contents with line ranges
+- list_directory: Directory listing with filtering
+"""
+
+import time
+from praisonaiagents.context.fast.search_tools import (
+    grep_search,
+    glob_search,
+    read_file,
+    list_directory
+)
+
+WORKSPACE = "/Users/praison/praisonai-package/src/praisonai-agents"
+
+
+def main():
+    print("=" * 70)
+    print("Search Tools Deep Dive")
+    print("=" * 70)
+    
+    # grep_search
+    print("\n1. grep_search - Pattern Search")
+    print("-" * 40)
+    
+    # Simple pattern
+    start = time.perf_counter()
+    results = grep_search(
+        search_path=WORKSPACE,
+        pattern="def __init__",
+        max_results=10
+    )
+    elapsed = (time.perf_counter() - start) * 1000
+    
+    print(f"   Pattern: 'def __init__'")
+    print(f"   Matches: {len(results)}")
+    print(f"   Time: {elapsed:.0f}ms")
+    if results:
+        print(f"   First match: {results[0]['path']}:{results[0]['line_number']}")
+    
+    # Regex pattern
+    results = grep_search(
+        search_path=WORKSPACE,
+        pattern=r"class \w+Agent",
+        is_regex=True,
+        max_results=10
+    )
+    print(f"\n   Regex: 'class \\w+Agent'")
+    print(f"   Matches: {len(results)}")
+    for r in results[:3]:
+        print(f"   - {r['path']}:{r['line_number']}: {r['content'][:50]}...")
+    
+    # Case sensitive
+    results_sensitive = grep_search(
+        search_path=WORKSPACE,
+        pattern="Agent",
+        case_sensitive=True,
+        max_results=50
+    )
+    results_insensitive = grep_search(
+        search_path=WORKSPACE,
+        pattern="agent",
+        case_sensitive=False,
+        max_results=50
+    )
+    print(f"\n   Case sensitive 'Agent': {len(results_sensitive)} matches")
+    print(f"   Case insensitive 'agent': {len(results_insensitive)} matches")
+    
+    # With context lines
+    results = grep_search(
+        search_path=WORKSPACE,
+        pattern="class Agent:",
+        context_lines=2,
+        max_results=3
+    )
+    print(f"\n   With 2 context lines:")
+    if results:
+        print(f"   {results[0]['path']}:")
+        if results[0].get('context'):
+            for line in results[0]['context'].split('\n')[:5]:
+                print(f"      {line[:60]}")
+    
+    # glob_search
+    print("\n2. glob_search - File Pattern Matching")
+    print("-" * 40)
+    
+    # Find Python files
+    start = time.perf_counter()
+    results = glob_search(
+        search_path=WORKSPACE,
+        pattern="**/*.py",
+        max_results=100
+    )
+    elapsed = (time.perf_counter() - start) * 1000
+    
+    print(f"   Pattern: '**/*.py'")
+    print(f"   Files found: {len(results)}")
+    print(f"   Time: {elapsed:.0f}ms")
+    
+    # Find specific files
+    results = glob_search(
+        search_path=WORKSPACE,
+        pattern="**/agent*.py",
+        max_results=20
+    )
+    print(f"\n   Pattern: '**/agent*.py'")
+    print(f"   Files found: {len(results)}")
+    for r in results[:5]:
+        print(f"   - {r['path']} ({r['size']} bytes)")
+    
+    # Find test files
+    results = glob_search(
+        search_path=WORKSPACE,
+        pattern="**/test_*.py",
+        max_results=50
+    )
+    print(f"\n   Pattern: '**/test_*.py'")
+    print(f"   Test files: {len(results)}")
+    
+    # read_file
+    print("\n3. read_file - Read File Contents")
+    print("-" * 40)
+    
+    # Read entire file
+    result = read_file(
+        filepath=f"{WORKSPACE}/praisonaiagents/__init__.py",
+        max_lines=20
+    )
+    
+    print(f"   File: praisonaiagents/__init__.py")
+    print(f"   Success: {result['success']}")
+    print(f"   Lines: {result.get('total_lines', 'N/A')}")
+    if result['success']:
+        lines = result['content'].split('\n')[:5]
+        print(f"   Preview:")
+        for line in lines:
+            print(f"      {line[:60]}")
+    
+    # Read specific line range
+    result = read_file(
+        filepath=f"{WORKSPACE}/praisonaiagents/agent/agent.py",
+        start_line=1,
+        end_line=20
+    )
+    
+    print(f"\n   File: agent/agent.py (lines 1-20)")
+    print(f"   Success: {result['success']}")
+    if result['success']:
+        lines = result['content'].split('\n')[:5]
+        print(f"   Preview:")
+        for line in lines:
+            print(f"      {line[:60]}")
+    
+    # Read with context
+    result = read_file(
+        filepath=f"{WORKSPACE}/praisonaiagents/agent/agent.py",
+        start_line=100,
+        end_line=105,
+        context_lines=3
+    )
+    
+    print(f"\n   File: agent/agent.py (lines 100-105 with 3 context lines)")
+    print(f"   Success: {result['success']}")
+    
+    # list_directory
+    print("\n4. list_directory - Directory Listing")
+    print("-" * 40)
+    
+    # List root
+    result = list_directory(
+        dir_path=WORKSPACE,
+        recursive=False,
+        max_entries=20
+    )
+    
+    print(f"   Directory: {WORKSPACE}")
+    print(f"   Success: {result['success']}")
+    print(f"   Entries: {len(result.get('entries', []))}")
+    
+    dirs = [e for e in result.get('entries', []) if e.get('is_dir')]
+    files = [e for e in result.get('entries', []) if not e.get('is_dir')]
+    print(f"   Directories: {len(dirs)}")
+    print(f"   Files: {len(files)}")
+    
+    # List recursive with depth limit
+    result = list_directory(
+        dir_path=f"{WORKSPACE}/praisonaiagents",
+        recursive=True,
+        max_depth=2,
+        max_entries=50
+    )
+    
+    print(f"\n   Directory: praisonaiagents (recursive, depth=2)")
+    print(f"   Entries: {len(result.get('entries', []))}")
+    
+    # Show directory structure
+    print(f"   Structure:")
+    for entry in result.get('entries', [])[:10]:
+        prefix = "📁" if entry.get('is_dir') else "📄"
+        print(f"      {prefix} {entry['name']}")
+    
+    print("\n" + "=" * 70)
+    print("These search tools power Fast Context's rapid code search!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

examples/context/08_comprehensive_benchmark.py

@@ -0,0 +1,227 @@
+"""
+Example 8: Comprehensive Benchmark
+
+This example provides a comprehensive benchmark comparing Fast Context
+performance against traditional search approaches.
+
+Metrics measured:
+- Search latency
+- Throughput (queries per second)
+- Cache effectiveness
+- Parallel execution speedup
+"""
+
+import time
+import statistics
+from praisonaiagents.context.fast import FastContext
+from praisonaiagents.context.fast.search_tools import grep_search
+from praisonaiagents.context.fast.indexer import FileIndexer, SymbolIndexer
+
+WORKSPACE = "/Users/praison/praisonai-package/src/praisonai-agents"
+
+
+def benchmark_search_latency():
+    """Benchmark search latency."""
+    print("\n1. Search Latency Benchmark")
+    print("-" * 50)
+    
+    fc = FastContext(workspace_path=WORKSPACE, cache_enabled=False)
+    
+    queries = [
+        "def __init__",
+        "class Agent",
+        "import logging",
+        "async def",
+        "from typing import",
+    ]
+    
+    # Warm up
+    fc.search("warmup")
+    
+    # Benchmark each query
+    latencies = []
+    for query in queries:
+        times = []
+        for _ in range(3):  # 3 runs per query
+            start = time.perf_counter()
+            fc.search(query)
+            elapsed = (time.perf_counter() - start) * 1000
+            times.append(elapsed)
+        
+        avg = statistics.mean(times)
+        latencies.append(avg)
+        print(f"   '{query}': {avg:.1f}ms (min: {min(times):.1f}, max: {max(times):.1f})")
+    
+    print(f"\n   Average latency: {statistics.mean(latencies):.1f}ms")
+    print(f"   Median latency: {statistics.median(latencies):.1f}ms")
+    print(f"   P95 latency: {sorted(latencies)[int(len(latencies)*0.95)]:.1f}ms")
+
+
+def benchmark_throughput():
+    """Benchmark queries per second."""
+    print("\n2. Throughput Benchmark")
+    print("-" * 50)
+    
+    fc = FastContext(workspace_path=WORKSPACE, cache_enabled=True)
+    
+    queries = ["def", "class", "import", "return", "if", "for", "while", "try"]
+    
+    # Cold run (no cache)
+    fc.clear_cache()
+    start = time.perf_counter()
+    for query in queries:
+        fc.search(query)
+    cold_time = time.perf_counter() - start
+    cold_qps = len(queries) / cold_time
+    
+    print(f"   Cold (no cache):")
+    print(f"      Queries: {len(queries)}")
+    print(f"      Time: {cold_time*1000:.0f}ms")
+    print(f"      Throughput: {cold_qps:.1f} queries/second")
+    
+    # Warm run (cached)
+    start = time.perf_counter()
+    for _ in range(10):  # 10 iterations
+        for query in queries:
+            fc.search(query)
+    warm_time = time.perf_counter() - start
+    warm_qps = (len(queries) * 10) / warm_time
+    
+    print(f"\n   Warm (cached):")
+    print(f"      Queries: {len(queries) * 10}")
+    print(f"      Time: {warm_time*1000:.0f}ms")
+    print(f"      Throughput: {warm_qps:.0f} queries/second")
+    
+    print(f"\n   Cache speedup: {warm_qps/cold_qps:.0f}x")
+
+
+def benchmark_cache_effectiveness():
+    """Benchmark cache hit rate and speedup."""
+    print("\n3. Cache Effectiveness Benchmark")
+    print("-" * 50)
+    
+    fc = FastContext(workspace_path=WORKSPACE, cache_enabled=True)
+    fc.clear_cache()
+    
+    queries = ["Agent", "chat", "memory", "tool", "execute"]
+    
+    # First pass - cache misses
+    miss_times = []
+    for query in queries:
+        start = time.perf_counter()
+        result = fc.search(query)
+        elapsed = (time.perf_counter() - start) * 1000
+        miss_times.append(elapsed)
+        assert not result.from_cache
+    
+    # Second pass - cache hits
+    hit_times = []
+    for query in queries:
+        start = time.perf_counter()
+        result = fc.search(query)
+        elapsed = (time.perf_counter() - start) * 1000
+        hit_times.append(elapsed)
+        assert result.from_cache
+    
+    avg_miss = statistics.mean(miss_times)
+    avg_hit = statistics.mean(hit_times)
+    
+    print(f"   Cache miss (first query): {avg_miss:.1f}ms avg")
+    print(f"   Cache hit (repeat query): {avg_hit:.2f}ms avg")
+    print(f"   Cache speedup: {avg_miss/avg_hit:.0f}x faster")
+    print(f"   Time saved per cached query: {avg_miss - avg_hit:.1f}ms")
+
+
+def benchmark_parallel_execution():
+    """Benchmark parallel vs sequential execution."""
+    print("\n4. Parallel Execution Benchmark")
+    print("-" * 50)
+    
+    queries = ["def", "class", "import", "return", "async"]
+    
+    # Sequential (one at a time)
+    start = time.perf_counter()
+    for query in queries:
+        grep_search(WORKSPACE, query, max_results=20)
+    seq_time = (time.perf_counter() - start) * 1000
+    
+    # Parallel (Fast Context)
+    fc = FastContext(workspace_path=WORKSPACE, cache_enabled=False)
+    start = time.perf_counter()
+    for query in queries:
+        fc.search(query)
+    par_time = (time.perf_counter() - start) * 1000
+    
+    print(f"   Sequential: {seq_time:.0f}ms")
+    print(f"   Parallel (Fast Context): {par_time:.0f}ms")
+    print(f"   Speedup: {seq_time/par_time:.1f}x")
+
+
+def benchmark_indexing():
+    """Benchmark indexing performance."""
+    print("\n5. Indexing Performance Benchmark")
+    print("-" * 50)
+    
+    # File indexing
+    start = time.perf_counter()
+    file_indexer = FileIndexer(workspace_path=WORKSPACE)
+    file_count = file_indexer.index()
+    file_time = (time.perf_counter() - start) * 1000
+    
+    print(f"   File Indexer:")
+    print(f"      Files: {file_count}")
+    print(f"      Time: {file_time:.0f}ms")
+    print(f"      Rate: {file_count/(file_time/1000):.0f} files/second")
+    
+    # Symbol indexing
+    start = time.perf_counter()
+    symbol_indexer = SymbolIndexer(workspace_path=WORKSPACE)
+    symbol_count = symbol_indexer.index()
+    symbol_time = (time.perf_counter() - start) * 1000
+    
+    print(f"\n   Symbol Indexer:")
+    print(f"      Symbols: {symbol_count}")
+    print(f"      Time: {symbol_time:.0f}ms")
+    print(f"      Rate: {symbol_count/(symbol_time/1000):.0f} symbols/second")
+    
+    # Lookup performance
+    start = time.perf_counter()
+    for _ in range(100):
+        file_indexer.find_by_pattern("**/*.py")
+    lookup_time = (time.perf_counter() - start) * 1000
+    
+    print(f"\n   Lookup Performance:")
+    print(f"      100 pattern lookups: {lookup_time:.1f}ms")
+    print(f"      Per lookup: {lookup_time/100:.2f}ms")
+
+
+def main():
+    print("=" * 70)
+    print("Fast Context Comprehensive Benchmark")
+    print("=" * 70)
+    print(f"\nWorkspace: {WORKSPACE}")
+    
+    benchmark_search_latency()
+    benchmark_throughput()
+    benchmark_cache_effectiveness()
+    benchmark_parallel_execution()
+    benchmark_indexing()
+    
+    print("\n" + "=" * 70)
+    print("Summary")
+    print("=" * 70)
+    print("""
+   Fast Context provides:
+   ✓ Sub-100ms search latency for most queries
+   ✓ 100+ queries/second with caching
+   ✓ 100x+ speedup for cached queries
+   ✓ 2-5x speedup from parallel execution
+   ✓ 1000+ files/second indexing rate
+   
+   These benchmarks demonstrate why Fast Context is ideal for
+   rapid code search in AI agent workflows.
+""")
+
+
+if __name__ == "__main__":
+    main()

examples/cookbooks/Conversational_Chat_Agents/Multi_Agent_Production_System.ipynb

@@ -26,14 +26,14 @@
         "\n",
         "### ✨ Key Benefits:\n",
         "- 🚀 **Scalable & Customizable** – Industry-agnostic design  \n",
-        "- 💰 **Cost-Effective** – Runs on GPT-4o-mini  \n",
+        "- 💰 **Cost-Effective** – Runs on gpt-5-nano  \n",
         "- 🛠️ **Production-Ready** – Realistic automation framework  \n",
         "- 🔄 **Complete Pipeline** – End-to-end flow\n",
         "\n",
         "---\n",
         "\n",
         "### 🔧 Technologies:\n",
-        "**PraisonAI** • **OpenAI GPT-4o-mini** • **Python** • **SQLite**  \n",
+        "**PraisonAI** • **OpenAI gpt-5-nano** • **Python** • **SQLite**  \n",
         "**Multi-Agent Architecture**\n",
         "\n",
         "---\n",
@@ -100,7 +100,7 @@
           "text": [
             "📦 Dependencies installed!\n",
             "🔄 Using PraisonAI Multi-Agent Framework\n",
-            "🤖 Powered by OpenAI GPT-4o-mini\n"
+            "🤖 Powered by OpenAI gpt-5-nano\n"
           ]
         }
       ],
@@ -116,7 +116,7 @@
         "\n",
         "print(\"📦 Dependencies installed!\")\n",
         "print(\"🔄 Using PraisonAI Multi-Agent Framework\")\n",
-        "print(\"🤖 Powered by OpenAI GPT-4o-mini\")"
+        "print(\"🤖 Powered by OpenAI gpt-5-nano\")"
       ]
     },
     {
@@ -5102,7 +5102,7 @@
             "\n",
             "🎊 BLENDER PRODUCTION STUDIO COMPLETE!\n",
             "🎬 17-Agent AI System Successfully Executed\n",
-            "🤖 Powered by PraisonAI + OpenAI GPT-4o-mini\n"
+            "🤖 Powered by PraisonAI + OpenAI gpt-5-nano\n"
           ]
         }
       ],
@@ -5149,7 +5149,7 @@
         "\n",
         "print(\"\\n🎊 BLENDER PRODUCTION STUDIO COMPLETE!\")\n",
         "print(\"🎬 17-Agent AI System Successfully Executed\")\n",
-        "print(\"🤖 Powered by PraisonAI + OpenAI GPT-4o-mini\")"
+        "print(\"🤖 Powered by PraisonAI + OpenAI gpt-5-nano\")"
       ]
     }
   ],

examples/cookbooks/Conversational_Chat_Agents/ReAct_agent.ipynb

@@ -182,7 +182,7 @@
         "        ]\n",
         "        for turn in range(max_turns):\n",
         "            response = client.chat.completions.create(\n",
-        "                model=\"gpt-4o-mini\",\n",
+        "                model=\"gpt-5-nano\",\n",
         "                messages=history,\n",
         "                max_tokens=500\n",
         "            )\n",

examples/cookbooks/Conversational_Chat_Agents/Semantic_Social_Network_Agent_System.ipynb

@@ -2642,7 +2642,7 @@
       "\n",
       "\ud83c\udf8a SEMANTIC NETWORK ANALYSIS COMPLETE!\n",
       "\ud83c\udf10 Cross-platform profile discovery and analysis\n",
-      "\ud83e\udd16 Powered by PraisonAI + OpenAI GPT-4o-mini\n"
+      "\ud83e\udd16 Powered by PraisonAI + OpenAI gpt-5-nano\n"
      ]
     }
    ],
@@ -2687,7 +2687,7 @@
     "\n",
     "print(\"\\n\ud83c\udf8a SEMANTIC NETWORK ANALYSIS COMPLETE!\")\n",
     "print(\"\ud83c\udf10 Cross-platform profile discovery and analysis\")\n",
-    "print(\"\ud83e\udd16 Powered by PraisonAI + OpenAI GPT-4o-mini\")"
+    "print(\"\ud83e\udd16 Powered by PraisonAI + OpenAI gpt-5-nano\")"
    ]
   },
   {

examples/cookbooks/Ecommerce_Shopping_Agents/Ai_Ecommerce_Shopping_Assistant.ipynb

@@ -1262,7 +1262,7 @@
       "\n",
       "🎊 AI SHOPPING ASSISTANT ACTIVE!\n",
       "🛒 Ready to help customers with natural language shopping\n",
-      "🤖 Powered by PraisonAI + OpenAI GPT-4o-mini\n"
+      "🤖 Powered by PraisonAI + OpenAI gpt-5-nano\n"
      ]
     }
    ],
@@ -1305,7 +1305,7 @@
     "\n",
     "print(\"\\n🎊 AI SHOPPING ASSISTANT ACTIVE!\")\n",
     "print(\"🛒 Ready to help customers with natural language shopping\")\n",
-    "print(\"🤖 Powered by PraisonAI + OpenAI GPT-4o-mini\")"
+    "print(\"🤖 Powered by PraisonAI + OpenAI gpt-5-nano\")"
    ]
   },
   {

examples/cookbooks/Finance_Market_Job_Agents/Ai_Job_Hunting_Assistant.ipynb

@@ -29,7 +29,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
@@ -71,7 +71,6 @@
     "import pandas as pd\n",
     "\n",
     "print(\"📦 Dependencies installed!\")\n",
-    "print(\"🔄 Converting from AGNO → PraisonAI\")\n",
     "print(\"🎯 Building Job Hunting Agent System\")"
    ]
   },

examples/cookbooks/Finance_Market_Job_Agents/Home_Buying_Real_Estate_Agent.ipynb

@@ -156,7 +156,7 @@
     "  - Property comparison\n",
     "  - Cost of living and taxes\n",
     "  - First-time homebuyer guidance\n",
-    "llm: gpt-4o\n",
+    "llm: gpt-5-nano\n",
     "verbosity: true\n",
     "format: markdown\n",
     "\"\"\"\n"
@@ -188,7 +188,7 @@
     "Help users evaluate neighborhoods, estimate mortgage payments, compare homes, and understand homeownership costs.\n",
     "Explain clearly, format in markdown, and be friendly but professional.\n",
     "\"\"\",\n",
-    "    llm=\"gpt-4o\",\n",
+    "    llm=\"gpt-5-nano\",\n",
     "    verbose=True,\n",
     "    markdown=True\n",
     ")\n"

examples/cookbooks/Health_Fitness_Agents/Air_Quality_Analysis_Agent.ipynb

@@ -311,7 +311,7 @@
      "data": {
       "text/html": [
        "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #008080; text-decoration-color: #008080\">╭───────────────────────────────────────────────────── Task ──────────────────────────────────────────────────────╮</span>\n",
-       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> You are an expert health advisor using the GPT-4o Mini model.                                                   <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> You are an expert health advisor using the gpt-5-nano Mini model.                                                   <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
        "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
        "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"background-color: #272822\">                                                                                                               </span> <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
        "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"background-color: #272822\"> </span><span style=\"color: #f8f8f2; text-decoration-color: #f8f8f2; background-color: #272822\">Based on the following air quality conditions in Mumbai, Maharashtra, India:</span><span style=\"background-color: #272822\">                                  </span> <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
@@ -340,7 +340,7 @@
       ],
       "text/plain": [
        "\u001b[36m╭─\u001b[0m\u001b[36m────────────────────────────────────────────────────\u001b[0m\u001b[36m Task \u001b[0m\u001b[36m─────────────────────────────────────────────────────\u001b[0m\u001b[36m─╮\u001b[0m\n",
-       "\u001b[36m│\u001b[0m You are an expert health advisor using the GPT-4o Mini model.                                                   \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m You are an expert health advisor using the gpt-5-nano Mini model.                                                   \u001b[36m│\u001b[0m\n",
        "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
        "\u001b[36m│\u001b[0m \u001b[48;2;39;40;34m                                                                                                               \u001b[0m \u001b[36m│\u001b[0m\n",
        "\u001b[36m│\u001b[0m \u001b[48;2;39;40;34m \u001b[0m\u001b[38;2;248;248;242;48;2;39;40;34mBased on the following air quality conditions in Mumbai, Maharashtra, India:\u001b[0m\u001b[48;2;39;40;34m                                 \u001b[0m\u001b[48;2;39;40;34m \u001b[0m \u001b[36m│\u001b[0m\n",
@@ -519,7 +519,7 @@
     "    aqi_data = aqi_data.data  # Convert to dict\n",
     "\n",
     "    prompt = f\"\"\"\n",
-    "    You are an expert health advisor using the GPT-4o Mini model.\n",
+    "    You are an expert health advisor using the gpt-5-nano Mini model.\n",
     "\n",
     "    Based on the following air quality conditions in {user_city}, {user_state}, {user_country}:\n",
     "    - Overall AQI: {aqi_data.get('aqi', 'N/A')}\n",

examples/cookbooks/Productivity_Workflow_Agents/Hackathon_Agent_Notebook.ipynb

@@ -193,7 +193,7 @@
         "    goal=\"Evaluate hackathon projects through video demonstrations\",\n",
         "    backstory=\"\"\"You are an expert hackathon judge. You give fair scores and detailed feedback\n",
         "    on technical complexity, innovation, presentation, and UX.\"\"\",\n",
-        "    llm=\"gpt-4o-mini\",\n",
+        "    llm=\"gpt-5-nano\",\n",
         "    self_reflect=False\n",
         ")"
       ],

examples/cookbooks/Programming_Code_Analysis_Agents/FunctionAgent_Workflow.ipynb

@@ -65,7 +65,7 @@
       "source": [
         "from llama_index.llms.openai import OpenAI\n",
         "\n",
-        "llm = OpenAI(model=\"gpt-4o-mini\", api_key=\"Enter your api key here\")  # Replace with your OpenAI API key\n"
+        "llm = OpenAI(model=\"gpt-5-nano\", api_key=\"Enter your api key here\")  # Replace with your OpenAI API key\n"
       ]
     },
     {

examples/cookbooks/Programming_Code_Analysis_Agents/Natural_Language_Codebase.ipynb

@@ -0,0 +1,293 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ZOWgx2fYqW8T"
+   },
+   "source": [
+    "# GitHub Repository Insights with PraisonAIAgents"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XgJdLRiIqZ2L"
+   },
+   "source": [
+    "This notebook demonstrates how to explore and analyze GitHub repositories using PraisonAIAgents in Google Colab. You can query repository issues, pull requests, and activity patterns with natural language, leveraging the power of agentic tools—all without leaving your notebook."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Y_koMT6qzxne"
+   },
+   "source": [
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Dhivya-Bharathy/PraisonAI/blob/main/examples/cookbooks/Programming_Code_Analysis_Agents/GitHub_Repository_Insights.ipynb)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2ey7zWAJrIPx"
+   },
+   "source": [
+    "# Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "id": "_xFH-iLTxzd8"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install praisonaiagents openai requests --quiet"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Kzty0zxzsbZ_"
+   },
+   "source": [
+    "# Set Up Key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "id": "HCVP5fmvx2hH"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "# Set your GitHub token here\n",
+    "GITHUB_TOKEN = \"your-github-token\"  # <-- Replace with your actual token\n",
+    "\n",
+    "# Set your OpenAI API key here (required by PraisonAIAgents, even if not used for LLM)\n",
+    "OPENAI_API_KEY = \"your-openai-api-key\"  # <-- Replace with your actual OpenAI API key\n",
+    "\n",
+    "# Set environment variable for OpenAI\n",
+    "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "10BTLbF4s_f-"
+   },
+   "source": [
+    "# Import Libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {
+    "id": "_sLahvfXyEb0"
+   },
+   "outputs": [],
+   "source": [
+    "from praisonaiagents import Agent\n",
+    "import requests\n",
+    "from IPython.display import display, Markdown"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "GRftdghxtUDs"
+   },
+   "source": [
+    "# Custom Tool"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {
+    "id": "nT11EFNNyIHl"
+   },
+   "outputs": [],
+   "source": [
+    "def github_query_tool(query: str, repo: str, github_token: str) -> str:\n",
+    "    \"\"\"\n",
+    "    Custom tool to query GitHub repository data using the GitHub API.\n",
+    "    Supports basic queries for issues, pull requests, and repository info.\n",
+    "    \"\"\"\n",
+    "    headers = {\n",
+    "        \"Authorization\": f\"token {github_token}\",\n",
+    "        \"Accept\": \"application/vnd.github.v3+json\"\n",
+    "    }\n",
+    "    base_url = f\"https://api.github.com/repos/{repo}\"\n",
+    "    result = \"\"\n",
+    "\n",
+    "    if \"issue\" in query.lower():\n",
+    "        url = f\"{base_url}/issues\"\n",
+    "        response = requests.get(url, headers=headers)\n",
+    "        if response.ok:\n",
+    "            issues = response.json()\n",
+    "            result = f\"Found {len(issues)} issues in {repo}.\\n\"\n",
+    "            for issue in issues[:5]:\n",
+    "                result += f\"- #{issue['number']}: {issue['title']} (State: {issue['state']})\\n\"\n",
+    "        else:\n",
+    "            result = f\"Failed to fetch issues: {response.text}\"\n",
+    "\n",
+    "    elif \"pull request\" in query.lower() or \"pr\" in query.lower():\n",
+    "        url = f\"{base_url}/pulls\"\n",
+    "        response = requests.get(url, headers=headers)\n",
+    "        if response.ok:\n",
+    "            pulls = response.json()\n",
+    "            result = f\"Found {len(pulls)} pull requests in {repo}.\\n\"\n",
+    "            for pr in pulls[:5]:\n",
+    "                result += f\"- #{pr['number']}: {pr['title']} (State: {pr['state']})\\n\"\n",
+    "        else:\n",
+    "            result = f\"Failed to fetch pull requests: {response.text}\"\n",
+    "\n",
+    "    elif \"activity\" in query.lower() or \"stats\" in query.lower():\n",
+    "        url = f\"{base_url}/stats/contributors\"\n",
+    "        response = requests.get(url, headers=headers)\n",
+    "        if response.ok:\n",
+    "            stats = response.json()\n",
+    "            result = f\"Repository activity for {repo}:\\n\"\n",
+    "            for contributor in stats[:5]:\n",
+    "                result += f\"- {contributor['author']['login']}: {contributor['total']} commits\\n\"\n",
+    "        else:\n",
+    "            result = f\"Failed to fetch activity stats: {response.text}\"\n",
+    "\n",
+    "    else:\n",
+    "        # Default: basic repo info\n",
+    "        response = requests.get(base_url, headers=headers)\n",
+    "        if response.ok:\n",
+    "            info = response.json()\n",
+    "            result = (\n",
+    "                f\"Repository: {info['full_name']}\\n\"\n",
+    "                f\"Description: {info.get('description', 'No description')}\\n\"\n",
+    "                f\"Stars: {info['stargazers_count']}\\n\"\n",
+    "                f\"Forks: {info['forks_count']}\\n\"\n",
+    "                f\"Open Issues: {info['open_issues_count']}\\n\"\n",
+    "            )\n",
+    "        else:\n",
+    "            result = f\"Failed to fetch repository info: {response.text}\"\n",
+    "\n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mAFg5SW-tacD"
+   },
+   "source": [
+    "#  Register Tool and Create Agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {
+    "id": "x_MmUc_AyMaB"
+   },
+   "outputs": [],
+   "source": [
+    "def github_tool_wrapper(inputs):\n",
+    "    query = inputs.get(\"query\", \"\")\n",
+    "    repo = inputs.get(\"repo\", \"\")\n",
+    "    github_token = inputs.get(\"github_token\", \"\")\n",
+    "    return github_query_tool(query, repo, github_token)\n",
+    "\n",
+    "agent = Agent(\n",
+    "    instructions=\"\"\"\n",
+    "    You are a GitHub assistant. Help users explore repositories and their activity.\n",
+    "    - Provide organized, concise insights about the repository.\n",
+    "    - Focus on facts and data from the GitHub API.\n",
+    "    - Use markdown formatting for better readability.\n",
+    "    - Present numerical data in tables when appropriate.\n",
+    "    - Include links to relevant GitHub pages when helpful.\n",
+    "    \"\"\",\n",
+    "    tools={\n",
+    "        \"github_query_tool\": github_tool_wrapper\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "lPstz7bbtr0k"
+   },
+   "source": [
+    "# User Input and Run Agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 118
+    },
+    "id": "MymtRmlnyQqd",
+    "outputId": "33a23810-4a67-4615-f9e9-146b3030fcbf"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Enter the GitHub repository (owner/repo): Dhivya-Bharathy/PraisonAI\n",
+      "Enter your question (e.g., Show me open issues): Show me open issues\n"
+     ]
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "### Results\n",
+       "Found 0 issues in Dhivya-Bharathy/PraisonAI.\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# User input\n",
+    "repo = input(\"Enter the GitHub repository (owner/repo): \")\n",
+    "query = input(\"Enter your question (e.g., Show me open issues): \")\n",
+    "\n",
+    "# Call the tool directly (since agent.chat expects an LLM, but we want tool output)\n",
+    "response = agent.execute_tool(\"github_query_tool\", {\n",
+    "    \"query\": query,\n",
+    "    \"repo\": repo,\n",
+    "    \"github_token\": GITHUB_TOKEN\n",
+    "})\n",
+    "\n",
+    "# Display the result\n",
+    "display(Markdown(f\"### Results\\n{response}\"))"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

examples/cookbooks/Programming_Code_Analysis_Agents/Notion_Workspace_Assistant.ipynb

@@ -0,0 +1,309 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vmQmHoy-5cAh"
+   },
+   "source": [
+    "# Notion Workspace Assistant with PraisonAIAgents"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WOow52NM5dmh"
+   },
+   "source": [
+    "This notebook demonstrates how to interact with your Notion workspace using PraisonAIAgents in Google Colab. You can read, search, and update Notion pages with natural language queries, leveraging agentic tools for seamless document management—all within a notebook environment."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "TlnFAv9P_lGL"
+   },
+   "source": [
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Dhivya-Bharathy/PraisonAI/blob/main/examples/cookbooks/Programming_Code_Analysis_Agents/Notion_Workspace_Assistant.ipynb)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zMn7hUGZ5hn5"
+   },
+   "source": [
+    "# Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "U6X3lKAu6iU3"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install praisonaiagents openai requests --quiet"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "4_96-D7z6lrC"
+   },
+   "source": [
+    "# Set Up Key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "id": "kltUFVIW6rEO"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "# Set your Notion and OpenAI API keys here\n",
+    "NOTION_API_KEY = \"ntn_..\"  # <-- Replace with your actual Notion integration token\n",
+    "OPENAI_API_KEY = \"sk-proj-_..\"  # <-- Replace with your actual OpenAI API key\n",
+    "\n",
+    "# Set environment variables for downstream libraries\n",
+    "os.environ[\"NOTION_API_KEY\"] = NOTION_API_KEY\n",
+    "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FOLTBEXu635I"
+   },
+   "source": [
+    "# Tools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "id": "fLWxSASM5jlU"
+   },
+   "outputs": [],
+   "source": [
+    "from praisonaiagents import Agent\n",
+    "import requests\n",
+    "from IPython.display import display, Markdown"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "KN_Sxha37EQ0"
+   },
+   "source": [
+    "# Custom Tool"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "id": "WWxcfO9L7Fsu"
+   },
+   "outputs": [],
+   "source": [
+    "def notion_read_page_tool(page_id: str, notion_token: str) -> str:\n",
+    "    \"\"\"\n",
+    "    Custom tool to read the content of a Notion page using the Notion API.\n",
+    "    \"\"\"\n",
+    "    url = f\"https://api.notion.com/v1/blocks/{page_id}/children\"\n",
+    "    headers = {\n",
+    "        \"Authorization\": f\"Bearer {notion_token}\",\n",
+    "        \"Notion-Version\": \"2022-06-28\"\n",
+    "    }\n",
+    "    response = requests.get(url, headers=headers)\n",
+    "    if response.ok:\n",
+    "        data = response.json()\n",
+    "        blocks = data.get(\"results\", [])\n",
+    "        content = []\n",
+    "        for block in blocks:\n",
+    "            block_type = block.get(\"type\", \"\")\n",
+    "            text = \"\"\n",
+    "            if block_type == \"paragraph\":\n",
+    "                text = block.get(\"paragraph\", {}).get(\"text\", [])\n",
+    "                if text:\n",
+    "                    text = text[0].get(\"plain_text\", \"\")\n",
+    "            elif block_type == \"heading_1\":\n",
+    "                text = block.get(\"heading_1\", {}).get(\"text\", [])\n",
+    "                if text:\n",
+    "                    text = \"# \" + text[0].get(\"plain_text\", \"\")\n",
+    "            elif block_type == \"heading_2\":\n",
+    "                text = block.get(\"heading_2\", {}).get(\"text\", [])\n",
+    "                if text:\n",
+    "                    text = \"## \" + text[0].get(\"plain_text\", \"\")\n",
+    "            elif block_type == \"heading_3\":\n",
+    "                text = block.get(\"heading_3\", {}).get(\"text\", [])\n",
+    "                if text:\n",
+    "                    text = \"### \" + text[0].get(\"plain_text\", \"\")\n",
+    "            if text:\n",
+    "                content.append(text)\n",
+    "        return \"\\n\".join(content) if content else \"No readable content found on this page.\"\n",
+    "    else:\n",
+    "        return f\"Failed to fetch page content: {response.text}\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ebuhw9z27Nae"
+   },
+   "source": [
+    "# YAML Prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "eMjDDjzO7Pf3",
+    "outputId": "b935f96d-f147-44de-80ea-7f75d23f9e7b"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "agent_instructions: |\n",
+      "  You are a Notion workspace assistant. Help users read and manage their Notion pages.\n",
+      "  - Provide clear, organized summaries of page content.\n",
+      "  - Use the Notion API to fetch and display information.\n",
+      "  - If a page cannot be read, explain the issue clearly.\n",
+      "\n",
+      "tools:\n",
+      "  - name: notion_read_page_tool\n",
+      "    description: >\n",
+      "      Reads the content of a Notion page using its page ID and the user's Notion integration token.\n",
+      "    parameters:\n",
+      "      - name: page_id\n",
+      "        type: string\n",
+      "        description: The Notion page ID to read.\n",
+      "      - name: notion_token\n",
+      "        type: string\n",
+      "        description: The user's Notion integration token.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "yaml_prompt = \"\"\"\n",
+    "agent_instructions: |\n",
+    "  You are a Notion workspace assistant. Help users read and manage their Notion pages.\n",
+    "  - Provide clear, organized summaries of page content.\n",
+    "  - Use the Notion API to fetch and display information.\n",
+    "  - If a page cannot be read, explain the issue clearly.\n",
+    "\n",
+    "tools:\n",
+    "  - name: notion_read_page_tool\n",
+    "    description: >\n",
+    "      Reads the content of a Notion page using its page ID and the user's Notion integration token.\n",
+    "    parameters:\n",
+    "      - name: page_id\n",
+    "        type: string\n",
+    "        description: The Notion page ID to read.\n",
+    "      - name: notion_token\n",
+    "        type: string\n",
+    "        description: The user's Notion integration token.\n",
+    "\"\"\"\n",
+    "print(yaml_prompt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1ozm6Z467WQK"
+   },
+   "source": [
+    "# Main"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 83
+    },
+    "id": "eNg-jwpx7X5s",
+    "outputId": "4440b52a-46b3-4683-9183-13cd21596e25"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "### Notion Page Content\n",
+       "*No content found or page is not accessible. Please check your page ID and sharing settings.*"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Define a wrapper to match the agent's expected tool signature\n",
+    "def notion_tool_wrapper(inputs):\n",
+    "    page_id = inputs.get(\"page_id\", \"\")\n",
+    "    notion_token = inputs.get(\"notion_token\", \"\")\n",
+    "    return notion_read_page_tool(page_id, notion_token)\n",
+    "\n",
+    "# Create the agent and register the tool\n",
+    "agent = Agent(\n",
+    "    instructions=\"\"\"\n",
+    "    You are a Notion workspace assistant. Help users read and manage their Notion pages.\n",
+    "    - Provide clear, organized summaries of page content.\n",
+    "    - Use the Notion API to fetch and display information.\n",
+    "    - If a page cannot be read, explain the issue clearly.\n",
+    "    \"\"\",\n",
+    "    tools={\n",
+    "        \"notion_read_page_tool\": notion_tool_wrapper\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "# Call the tool directly (since agent.chat expects an LLM, but we want tool output)\n",
+    "response = agent.execute_tool(\"notion_read_page_tool\", {\n",
+    "    \"page_id\": page_id,\n",
+    "    \"notion_token\": NOTION_API_KEY\n",
+    "})\n",
+    "\n",
+    "# Check for error pattern and display a friendly message\n",
+    "if response.startswith(\"Failed to fetch page content:\"):\n",
+    "    display(Markdown(\"### Notion Page Content\\n*No content found or page is not accessible. Please check your page ID and sharing settings.*\"))\n",
+    "else:\n",
+    "    display(Markdown(f\"### Notion Page Content\\n{response}\"))"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

examples/cookbooks/Programming_Code_Analysis_Agents/ZeroScript_AI_TestExecutor.ipynb

@@ -1,355 +1,355 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "_T4g3t5sLoag"
-   },
-   "source": [
-    "# ZeroScript: AI-Powered Browser Test Automation using PraisonAI Agent & OpenAI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "O4PKfpalLsmn"
-   },
-   "source": [
-    "# Description"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "CEG1pfumLysm"
-   },
-   "source": [
-    "AI-powered browser testing using PraisonAI Agent and OpenAI. Executes YAML-defined test cases, captures screenshots, logs interactions, and generates JSON reports. Ideal for intelligent, automated UI testing.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "lbgxOG4gL1Wf"
-   },
-   "source": [
-    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DhivyaBharathy-web/PraisonAI/blob/main/examples/cookbooks/ZeroScript_AI_TestExecutor.ipynb)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "WCJqMUzXIndh"
-   },
-   "source": [
-    "# Dependencies"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {
-    "id": "9AQhJ59cJPmR"
-   },
-   "outputs": [],
-   "source": [
-    "!pip install --quiet praisonaiagents browser-use python-dotenv pyyaml openai\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "QD-dF-6_It1z"
-   },
-   "source": [
-    "# Environment Setup"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
-    },
-    "id": "QkRQDli4JhCV",
-    "outputId": "4b8957ed-a37a-4b11-8585-3537a0437d40"
-   },
-   "outputs": [
+  "cells": [
     {
-     "data": {
-      "text/plain": [
-       "True"
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_T4g3t5sLoag"
+      },
+      "source": [
+        "# ZeroScript: AI-Powered Browser Test Automation using PraisonAI Agent & OpenAI"
       ]
-     },
-     "execution_count": 35,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import os\n",
-    "from dotenv import load_dotenv\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"Enter your key\"  # replace with actual key\n",
-    "load_dotenv()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "ELuogWnrIw3o"
-   },
-   "source": [
-    "# Create my_secrets.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {
-    "id": "sG6tO_v0Jm5N"
-   },
-   "outputs": [],
-   "source": [
-    "with open(\"my_secrets.py\", \"w\") as f:\n",
-    "    f.write('''sensitive_data = {\n",
-    "    \"username\": \"standard_user\",\n",
-    "    \"password\": \"secret_sauce\"\n",
-    "}''')\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "rDB_viedIzRR"
-   },
-   "source": [
-    "# Create views.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {
-    "id": "CtwcybdbJoV8"
-   },
-   "outputs": [],
-   "source": [
-    "with open(\"views.py\", \"w\") as f:\n",
-    "    f.write('''\n",
-    "from pydantic import BaseModel\n",
-    "\n",
-    "class TestResult(BaseModel):\n",
-    "    status: str\n",
-    "    message: str = \"\"\n",
-    "''')\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "YTRmBpTiI1kd"
-   },
-   "source": [
-    "# Create agent.py"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {
-    "id": "zdJJGt6TJpvr"
-   },
-   "outputs": [],
-   "source": [
-    "with open(\"agent.py\", \"w\") as f:\n",
-    "    f.write('''\n",
-    "import os\n",
-    "from praisonaiagents import Agent\n",
-    "from browser_use import Browser, BrowserConfig, Controller\n",
-    "from browser_use.browser.context import BrowserContext, BrowserContextConfig\n",
-    "from openai import OpenAI\n",
-    "from views import TestResult\n",
-    "from my_secrets import sensitive_data\n",
-    "\n",
-    "# Browser setup\n",
-    "browser = Browser(config=BrowserConfig(headless=True))\n",
-    "context_cfg = BrowserContextConfig(save_recording_path=\"data/recordings\")\n",
-    "controller = Controller(output_model=TestResult)\n",
-    "\n",
-    "async def browser_use(task: str):\n",
-    "    context = BrowserContext(browser=browser, config=context_cfg)\n",
-    "    agent = Agent(\n",
-    "        task=task,\n",
-    "        llm=OpenAI(api_key=os.getenv(\"OPENAI_API_KEY\"), model=\"gpt-4\"),\n",
-    "        browser_context=context,\n",
-    "        sensitive_data=sensitive_data,\n",
-    "        controller=controller,\n",
-    "        save_conversation_path=\"data/conversations/convo\",\n",
-    "        extend_system_message=(\n",
-    "            \"You are a professional software tester. Execute browser test steps precisely.\"\n",
-    "        )\n",
-    "    )\n",
-    "    response = await agent.run()\n",
-    "    await context.close()\n",
-    "    return response\n",
-    "''')\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "-LZtQIE3I4-_"
-   },
-   "source": [
-    "# Create Sample Test YAML"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/"
     },
-    "id": "l1OdXYI-JreK",
-    "outputId": "62323fcd-c74f-498f-defc-2c170fa8983e"
-   },
-   "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "350"
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "O4PKfpalLsmn"
+      },
+      "source": [
+        "# Description"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CEG1pfumLysm"
+      },
+      "source": [
+        "AI-powered browser testing using PraisonAI Agent and OpenAI. Executes YAML-defined test cases, captures screenshots, logs interactions, and generates JSON reports. Ideal for intelligent, automated UI testing.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lbgxOG4gL1Wf"
+      },
+      "source": [
+        "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DhivyaBharathy-web/PraisonAI/blob/main/examples/cookbooks/ZeroScript_AI_TestExecutor.ipynb)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "WCJqMUzXIndh"
+      },
+      "source": [
+        "# Dependencies"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 34,
+      "metadata": {
+        "id": "9AQhJ59cJPmR"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install --quiet praisonaiagents browser-use python-dotenv pyyaml openai\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "QD-dF-6_It1z"
+      },
+      "source": [
+        "# Environment Setup"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "QkRQDli4JhCV",
+        "outputId": "4b8957ed-a37a-4b11-8585-3537a0437d40"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "True"
+            ]
+          },
+          "execution_count": 35,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "import os\n",
+        "from dotenv import load_dotenv\n",
+        "\n",
+        "os.environ[\"OPENAI_API_KEY\"] = \"Enter your key\"  # replace with actual key\n",
+        "load_dotenv()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ELuogWnrIw3o"
+      },
+      "source": [
+        "# Create my_secrets.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "metadata": {
+        "id": "sG6tO_v0Jm5N"
+      },
+      "outputs": [],
+      "source": [
+        "with open(\"my_secrets.py\", \"w\") as f:\n",
+        "    f.write('''sensitive_data = {\n",
+        "    \"username\": \"standard_user\",\n",
+        "    \"password\": \"secret_sauce\"\n",
+        "}''')\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "rDB_viedIzRR"
+      },
+      "source": [
+        "# Create views.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 37,
+      "metadata": {
+        "id": "CtwcybdbJoV8"
+      },
+      "outputs": [],
+      "source": [
+        "with open(\"views.py\", \"w\") as f:\n",
+        "    f.write('''\n",
+        "from pydantic import BaseModel\n",
+        "\n",
+        "class TestResult(BaseModel):\n",
+        "    status: str\n",
+        "    message: str = \"\"\n",
+        "''')\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YTRmBpTiI1kd"
+      },
+      "source": [
+        "# Create agent.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 38,
+      "metadata": {
+        "id": "zdJJGt6TJpvr"
+      },
+      "outputs": [],
+      "source": [
+        "with open(\"agent.py\", \"w\") as f:\n",
+        "    f.write('''\n",
+        "import os\n",
+        "from praisonaiagents import Agent\n",
+        "from browser_use import Browser, BrowserConfig, Controller\n",
+        "from browser_use.browser.context import BrowserContext, BrowserContextConfig\n",
+        "from openai import OpenAI\n",
+        "from views import TestResult\n",
+        "from my_secrets import sensitive_data\n",
+        "\n",
+        "# Browser setup\n",
+        "browser = Browser(config=BrowserConfig(headless=True))\n",
+        "context_cfg = BrowserContextConfig(save_recording_path=\"data/recordings\")\n",
+        "controller = Controller(output_model=TestResult)\n",
+        "\n",
+        "async def browser_use(task: str):\n",
+        "    context = BrowserContext(browser=browser, config=context_cfg)\n",
+        "    agent = Agent(\n",
+        "        task=task,\n",
+        "        llm=OpenAI(api_key=os.getenv(\"OPENAI_API_KEY\"), model=\"gpt-4\"),\n",
+        "        browser_context=context,\n",
+        "        sensitive_data=sensitive_data,\n",
+        "        controller=controller,\n",
+        "        save_conversation_path=\"data/conversations/convo\",\n",
+        "        extend_system_message=(\n",
+        "            \"You are a professional software tester. Execute browser test steps precisely.\"\n",
+        "        )\n",
+        "    )\n",
+        "    response = await agent.run()\n",
+        "    await context.close()\n",
+        "    return response\n",
+        "''')\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-LZtQIE3I4-_"
+      },
+      "source": [
+        "# Create Sample Test YAML"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 39,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "l1OdXYI-JreK",
+        "outputId": "62323fcd-c74f-498f-defc-2c170fa8983e"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "350"
+            ]
+          },
+          "execution_count": 39,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "from pathlib import Path\n",
+        "tests_dir = Path(\"tests\")\n",
+        "tests_dir.mkdir(exist_ok=True)\n",
+        "yaml_content = \"\"\"\n",
+        "hooks:\n",
+        "  beforeEach: |\n",
+        "    Navigate to https://www.saucedemo.com\n",
+        "  afterEach: |\n",
+        "    Take screenshot\n",
+        "\n",
+        "tests:\n",
+        "  - id: \"login_test_001\"\n",
+        "    name: \"Valid Login Test\"\n",
+        "    instructions: |\n",
+        "      1. Enter standard_user in username field\n",
+        "      2. Enter secret_sauce in password field\n",
+        "      3. Click login button\n",
+        "      4. Verify page contains text \"Products\"\n",
+        "\"\"\"\n",
+        "(Path(\"tests/login_test.yml\")).write_text(yaml_content)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "sUjy-7OdI7p_"
+      },
+      "source": [
+        "# Run Tests"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 40,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Agkiwh7xJtY3",
+        "outputId": "759aa77c-fd65-49b8-b239-550588059478"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Exception ignored in: <function BrowserSession.__del__ at 0x7e2f540fb100>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/browser_use/browser/session.py\", line 497, in __del__\n",
+            "    status = f'\ud83e\ude93 killing pid={self.browser_pid}...' if (self.browser_pid and owns_browser) else '\u2620\ufe0f'\n",
+            "                                                         ^^^^^^^^^^^^^^^^\n",
+            "  File \"/usr/local/lib/python3.11/dist-packages/pydantic/main.py\", line 991, in __getattr__\n",
+            "    raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}')\n",
+            "AttributeError: 'BrowserSession' object has no attribute 'browser_pid'\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\u2705 Report saved to data/reports/report_20250630_092319.json\n"
+          ]
+        }
+      ],
+      "source": [
+        "import asyncio, yaml, json, base64, shutil\n",
+        "from agent import browser_use, browser\n",
+        "from pathlib import Path\n",
+        "from datetime import datetime\n",
+        "\n",
+        "# Clean or create data dirs\n",
+        "for sub in [\"recordings\", \"conversations\", \"screenshots\", \"reports\"]:\n",
+        "    d = Path(\"data\") / sub\n",
+        "    if d.exists(): shutil.rmtree(d)\n",
+        "    d.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "async def execute_test_file(path):\n",
+        "    cfg = yaml.safe_load(Path(path).read_text())\n",
+        "    hooks, results = cfg.get(\"hooks\", {}), []\n",
+        "    for t in cfg[\"tests\"]:\n",
+        "        task = f\"{hooks.get('beforeEach','')}\\n{t['instructions']}\\n{hooks.get('afterEach','')}\"\n",
+        "        res = {\"id\": t[\"id\"], \"name\": t[\"name\"]}\n",
+        "        try:\n",
+        "            r = await browser_use(task)\n",
+        "            imgs = r.screenshots()\n",
+        "            if imgs:\n",
+        "                out = Path(\"data/screenshots\") / f\"{t['id']}.png\"\n",
+        "                out.write_bytes(base64.b64decode(imgs[-1]))\n",
+        "            result_obj = r.final_result() if hasattr(r, \"final_result\") else str(r)\n",
+        "            res[\"result\"] = result_obj.model_dump() if hasattr(result_obj, \"model_dump\") else str(result_obj)\n",
+        "        except Exception as e:\n",
+        "            res[\"error\"] = str(e)\n",
+        "        results.append(res)\n",
+        "    return results\n",
+        "\n",
+        "async def main():\n",
+        "    all_results = []\n",
+        "    for file in Path(\"tests\").glob(\"*.yml\"):\n",
+        "        all_results.extend(await execute_test_file(str(file)))\n",
+        "    report = Path(\"data/reports\") / f\"report_{datetime.now():%Y%m%d_%H%M%S}.json\"\n",
+        "    report.write_text(json.dumps(all_results, indent=2))\n",
+        "    await browser.close()\n",
+        "    print(f\"\u2705 Report saved to {report}\")\n",
+        "\n",
+        "await main()\n"
       ]
-     },
-     "execution_count": 39,
-     "metadata": {},
-     "output_type": "execute_result"
     }
-   ],
-   "source": [
-    "from pathlib import Path\n",
-    "tests_dir = Path(\"tests\")\n",
-    "tests_dir.mkdir(exist_ok=True)\n",
-    "yaml_content = \"\"\"\n",
-    "hooks:\n",
-    "  beforeEach: |\n",
-    "    Navigate to https://www.saucedemo.com\n",
-    "  afterEach: |\n",
-    "    Take screenshot\n",
-    "\n",
-    "tests:\n",
-    "  - id: \"login_test_001\"\n",
-    "    name: \"Valid Login Test\"\n",
-    "    instructions: |\n",
-    "      1. Enter standard_user in username field\n",
-    "      2. Enter secret_sauce in password field\n",
-    "      3. Click login button\n",
-    "      4. Verify page contains text \"Products\"\n",
-    "\"\"\"\n",
-    "(Path(\"tests/login_test.yml\")).write_text(yaml_content)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "sUjy-7OdI7p_"
-   },
-   "source": [
-    "# Run Tests"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {
+  ],
+  "metadata": {
     "colab": {
-     "base_uri": "https://localhost:8080/"
+      "provenance": []
     },
-    "id": "Agkiwh7xJtY3",
-    "outputId": "759aa77c-fd65-49b8-b239-550588059478"
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Exception ignored in: <function BrowserSession.__del__ at 0x7e2f540fb100>\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/usr/local/lib/python3.11/dist-packages/browser_use/browser/session.py\", line 497, in __del__\n",
-      "    status = f'🪓 killing pid={self.browser_pid}...' if (self.browser_pid and owns_browser) else '☠️'\n",
-      "                                                         ^^^^^^^^^^^^^^^^\n",
-      "  File \"/usr/local/lib/python3.11/dist-packages/pydantic/main.py\", line 991, in __getattr__\n",
-      "    raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}')\n",
-      "AttributeError: 'BrowserSession' object has no attribute 'browser_pid'\n"
-     ]
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
     },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "✅ Report saved to data/reports/report_20250630_092319.json\n"
-     ]
+    "language_info": {
+      "name": "python"
     }
-   ],
-   "source": [
-    "import asyncio, yaml, json, base64, shutil\n",
-    "from agent import browser_use, browser\n",
-    "from pathlib import Path\n",
-    "from datetime import datetime\n",
-    "\n",
-    "# Clean or create data dirs\n",
-    "for sub in [\"recordings\", \"conversations\", \"screenshots\", \"reports\"]:\n",
-    "    d = Path(\"data\") / sub\n",
-    "    if d.exists(): shutil.rmtree(d)\n",
-    "    d.mkdir(parents=True, exist_ok=True)\n",
-    "\n",
-    "async def execute_test_file(path):\n",
-    "    cfg = yaml.safe_load(Path(path).read_text())\n",
-    "    hooks, results = cfg.get(\"hooks\", {}), []\n",
-    "    for t in cfg[\"tests\"]:\n",
-    "        task = f\"{hooks.get('beforeEach','')}\\n{t['instructions']}\\n{hooks.get('afterEach','')}\"\n",
-    "        res = {\"id\": t[\"id\"], \"name\": t[\"name\"]}\n",
-    "        try:\n",
-    "            r = await browser_use(task)\n",
-    "            imgs = r.screenshots()\n",
-    "            if imgs:\n",
-    "                out = Path(\"data/screenshots\") / f\"{t['id']}.png\"\n",
-    "                out.write_bytes(base64.b64decode(imgs[-1]))\n",
-    "            result_obj = r.final_result() if hasattr(r, \"final_result\") else str(r)\n",
-    "            res[\"result\"] = result_obj.dict() if hasattr(result_obj, \"dict\") else str(result_obj)\n",
-    "        except Exception as e:\n",
-    "            res[\"error\"] = str(e)\n",
-    "        results.append(res)\n",
-    "    return results\n",
-    "\n",
-    "async def main():\n",
-    "    all_results = []\n",
-    "    for file in Path(\"tests\").glob(\"*.yml\"):\n",
-    "        all_results.extend(await execute_test_file(str(file)))\n",
-    "    report = Path(\"data/reports\") / f\"report_{datetime.now():%Y%m%d_%H%M%S}.json\"\n",
-    "    report.write_text(json.dumps(all_results, indent=2))\n",
-    "    await browser.close()\n",
-    "    print(f\"✅ Report saved to {report}\")\n",
-    "\n",
-    "await main()\n"
-   ]
-  }
- ],
- "metadata": {
-  "colab": {
-   "provenance": []
   },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

examples/cookbooks/Research_Knowledge_QA_Agents/AI_CourtSimulation.ipynb

@@ -129,7 +129,7 @@
     "judge = Agent(\n",
     "    name=\"Judge\",\n",
     "    role=\"Preside over court proceedings\",\n",
-    "    llm=\"gpt-4o-mini\",\n",
+    "    llm=\"gpt-5-nano\",\n",
     "    instructions=[\n",
     "        \"You are an impartial judge\",\n",
     "        \"Make fair decisions based on evidence\",\n",
@@ -142,7 +142,7 @@
     "prosecutor = Agent(\n",
     "    name=\"Prosecutor\",\n",
     "    role=\"Present case against defendant\",\n",
-    "    llm=\"gpt-4o-mini\",\n",
+    "    llm=\"gpt-5-nano\",\n",
     "    instructions=[\n",
     "        \"You are a prosecutor seeking conviction\",\n",
     "        \"Present evidence methodically\",\n",
@@ -155,7 +155,7 @@
     "defense = Agent(\n",
     "    name=\"Defense\",\n",
     "    role=\"Defend the accused\",\n",
-    "    llm=\"gpt-4o-mini\",\n",
+    "    llm=\"gpt-5-nano\",\n",
     "    instructions=[\n",
     "        \"You are a defense attorney\",\n",
     "        \"Create reasonable doubt\",\n",
@@ -168,7 +168,7 @@
     "witness = Agent(\n",
     "    name=\"Witness\",\n",
     "    role=\"Provide testimony\",\n",
-    "    llm=\"gpt-4o-mini\",\n",
+    "    llm=\"gpt-5-nano\",\n",
     "    instructions=[\n",
     "        \"You are a witness testifying\",\n",
     "        \"Provide factual testimony\",\n",

examples/cookbooks/Research_Knowledge_QA_Agents/AI_Data_Analysis_Agent.ipynb

@@ -76,7 +76,7 @@
      "output_type": "stream",
      "text": [
       "✅ API key configured!\n",
-      "✅ Using model: gpt-4o-mini\n"
+      "✅ Using model: gpt-5-nano\n"
      ]
     }
    ],
@@ -85,7 +85,7 @@
     "openai_key = \"sk-..\"\n",
     "\n",
     "os.environ[\"OPENAI_API_KEY\"] = openai_key\n",
-    "model_choice = \"gpt-4o-mini\"\n",
+    "model_choice = \"gpt-5-nano\"\n",
     "\n",
     "print(\"✅ API key configured!\")\n",
     "print(f\"✅ Using model: {model_choice}\")"
@@ -336,7 +336,7 @@
     "\n",
     "temperature: 0.3\n",
     "max_tokens: 4000\n",
-    "model: \"gpt-4o-mini\"\n",
+    "model: \"gpt-5-nano\"\n",
     "\"\"\"\n",
     "\n",
     "print(\"✅ YAML Prompt configured!\")"

examples/cookbooks/Research_Knowledge_QA_Agents/Ai_Documentation_Processor.ipynb

@@ -8,7 +8,7 @@
    "source": [
     "# 🤖 Add AI Documentation Processor: Multi-Agent Content Analysis & Code Generation System\n",
     "\n",
-    "This PR adds a comprehensive AI-powered documentation processing system using PraisonAI and OpenAI GPT-4o-mini. Features 3 specialized agents for content analysis, code generation, and example creation, perfect for automated documentation processing and code generation workflows.\n",
+    "This PR adds a comprehensive AI-powered documentation processing system using PraisonAI and OpenAI gpt-5-nano. Features 3 specialized agents for content analysis, code generation, and example creation, perfect for automated documentation processing and code generation workflows.\n",
     "\n",
     "**Key Features:** Multi-agent document analysis, automated code generation, usage example creation, content validation, and scalable processing workflows for various document formats."
    ]

examples/cookbooks/Research_Knowledge_QA_Agents/Crypto_Research_Agent_Intelligence_Agent.ipynb

@@ -152,7 +152,7 @@
     "  - Evaluate risk factors\n",
     "  - Identify scams or red flags\n",
     "  - Summarize project fundamentals\n",
-    "llm: gpt-4o\n",
+    "llm: gpt-5-nano\n",
     "verbosity: true\n",
     "format: markdown\n",
     "\"\"\"\n"
@@ -184,7 +184,7 @@
     "and market trends. Provide critical insight into legitimacy, potential growth, and associated risks.\n",
     "Use markdown formatting and structure your research clearly.\n",
     "\"\"\",\n",
-    "    llm=\"gpt-4o\",\n",
+    "    llm=\"gpt-5-nano\",\n",
     "    verbose=True,\n",
     "    markdown=True\n",
     ")\n"

examples/cookbooks/SocialMedia_Content_Agents/Ai_Meme_Creator_Agent.ipynb

@@ -491,7 +491,7 @@
     "\n",
     "temperature: 0.7\n",
     "max_tokens: 3000\n",
-    "model: \"gpt-4o-mini\"\n",
+    "model: \"gpt-5-nano\"\n",
     "\"\"\"\n",
     "\n",
     "print(\"✅ YAML Prompt configured!\")"
@@ -627,7 +627,7 @@
     "            )\n",
     "        else:  # OpenAI\n",
     "            llm = ChatOpenAI(\n",
-    "                model=\"gpt-4o\",\n",
+    "                model=\"gpt-5-nano\",\n",
     "                api_key=api_key,\n",
     "                temperature=0.0\n",
     "            )\n",

examples/cookbooks/SocialMedia_Content_Agents/Joke_Agent.ipynb

@@ -120,7 +120,7 @@
         "\n",
         "    def run(self, message: str):\n",
         "        response = client.chat.completions.create(\n",
-        "            model=\"gpt-4o-mini\",\n",
+        "            model=\"gpt-5-nano\",\n",
         "            messages=[\n",
         "                {\"role\": \"system\", \"content\": self.prompt},\n",
         "                {\"role\": \"user\", \"content\": message}\n",

examples/cookbooks/SocialMedia_Content_Agents/YouTube_Influencer_Intelligence_Agent.ipynb

@@ -153,7 +153,7 @@
     "  - Spot content patterns and trends\n",
     "  - Recommend growth strategies\n",
     "  - Detect potential monetization methods\n",
-    "llm: gpt-4o\n",
+    "llm: gpt-5-nano\n",
     "verbosity: true\n",
     "format: markdown\n",
     "\"\"\"\n"
@@ -184,7 +184,7 @@
     "You are a YouTube intelligence analyst. Your job is to research a specific channel, niche, or influencer topic.\n",
     "Provide growth recommendations, engagement analysis, trending strategies, and monetization tips. Format in markdown.\n",
     "\"\"\",\n",
-    "    llm=\"gpt-4o\",\n",
+    "    llm=\"gpt-5-nano\",\n",
     "    verbose=True,\n",
     "    markdown=True\n",
     ")\n"

examples/cookbooks/Travel_Planning_Agents/Intelligent_Travel_Planning_Agent.ipynb

@@ -136,7 +136,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'name': 'Travel Research Agent', 'description': 'A world-class travel researcher that searches for destinations, activities, and accommodations', 'instructions': ['Given a travel destination and number of days, generate 3 relevant search terms', 'Search the web for each term using web_search tool', 'Analyze results and return 10 most relevant findings', 'Focus on activities, accommodations, attractions, and local insights', 'Ensure high-quality, accurate information', 'Use travel_budget_calculator to estimate costs'], 'tools': ['web_search', 'travel_budget_calculator'], 'model': 'gpt-4o', 'temperature': 0.7}\n"
+      "{'name': 'Travel Research Agent', 'description': 'A world-class travel researcher that searches for destinations, activities, and accommodations', 'instructions': ['Given a travel destination and number of days, generate 3 relevant search terms', 'Search the web for each term using web_search tool', 'Analyze results and return 10 most relevant findings', 'Focus on activities, accommodations, attractions, and local insights', 'Ensure high-quality, accurate information', 'Use travel_budget_calculator to estimate costs'], 'tools': ['web_search', 'travel_budget_calculator'], 'model': 'gpt-5-nano', 'temperature': 0.7}\n"
      ]
     }
    ],
@@ -156,7 +156,7 @@
     "tools:\n",
     "  - web_search\n",
     "  - travel_budget_calculator\n",
-    "model: gpt-4o\n",
+    "model: gpt-5-nano\n",
     "temperature: 0.7\n",
     "\"\"\"\n",
     "\n",

examples/cookbooks/Travel_Planning_Agents/VoiGno_Restaurant_Agent_PraisonAI.ipynb

@@ -17,7 +17,7 @@
     "id": "Y9FkDzt1lF47"
    },
    "source": [
-    "This notebook implements a conversational restaurant booking assistant using the Praison AI Agent framework. It handles natural interruptions such as modifying guest count or changing time mid-conversation. Built for Google Colab Free Tier, it uses OpenAI's GPT-4o model and follows a YAML-based agent design for clarity and modularity."
+    "This notebook implements a conversational restaurant booking assistant using the Praison AI Agent framework. It handles natural interruptions such as modifying guest count or changing time mid-conversation. Built for Google Colab Free Tier, it uses OpenAI's gpt-5-nano model and follows a YAML-based agent design for clarity and modularity."
    ]
   },
   {
@@ -135,7 +135,7 @@
     "  - Context management\n",
     "  - Handling mid-conversation changes\n",
     "  - Summarizing confirmed reservations\n",
-    "llm: gpt-4o\n",
+    "llm: gpt-5-nano\n",
     "verbosity: true\n",
     "format: markdown\n",
     "\"\"\"\n"
@@ -167,7 +167,7 @@
     "manage corrections like “change to 3 guests” or “move to 8 PM,”\n",
     "confirm the details once the user is satisfied. Respond in markdown.\n",
     "\"\"\",\n",
-    "    llm=\"gpt-4o\",\n",
+    "    llm=\"gpt-5-nano\",\n",
     "    verbose=True,\n",
     "    markdown=True\n",
     ")\n"

examples/cookbooks/rag_examples/agentic_rag/PraisonAI_RecipeAgent.ipynb

@@ -0,0 +1,481 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LJRJRQtFTagH"
+   },
+   "source": [
+    "# AI RAG Agent with Web Access using PraisonAI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Ph4RVTBCTcmB"
+   },
+   "source": [
+    "This notebook demonstrates how to build a Retrieval-Augmented Generation (RAG) agent with web access using GPT-4o and PraisonAI. The agent specializes in Thai recipes and can search the web for additional information."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tMxfwPPATy_o"
+   },
+   "source": [
+    "This RAG agent:\n",
+    "*   Creates an AI assistant specialized in Thai recipes and cooking\n",
+    "*   Has access to a PDF knowledge base about Thai recipes\n",
+    "*   Can search the web using DuckDuckGo for additional information\n",
+    "*   Provides comprehensive answers about Thai cuisine\n",
+    "*   Uses PraisonAI framework for agent management"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "h68oMaCITmqt"
+   },
+   "source": [
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Dhivya-Bharathy/PraisonAI/blob/main/examples/cookbooks/rag_examples/agentic_rag/PraisonAI_RecipeAgent.ipynb)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "cAdzoWXJUMfF"
+   },
+   "source": [
+    "# Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "9D-2TlOrUNcu"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install praisonaiagents openai requests"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yY-4-kEIUW40"
+   },
+   "source": [
+    "# Set Up API Key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "f5bhQ05yUX6J",
+    "outputId": "dcf9d0d9-332e-4136-9289-4c39d898005c"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Enter your OpenAI API key: ··········\n",
+      "✅ API key set successfully!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "# Set your OpenAI API key here\n",
+    "os.environ['OPENAI_API_KEY'] = 'Enter your api key here'\n",
+    "\n",
+    "# Or use this method to input it securely\n",
+    "from getpass import getpass\n",
+    "api_key = getpass('Enter your OpenAI API key: ')\n",
+    "os.environ['OPENAI_API_KEY'] = api_key\n",
+    "\n",
+    "print(\"✅ API key set successfully!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Eh0j-SegUi13"
+   },
+   "source": [
+    "# Tools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Z1A9oifIUkQN",
+    "outputId": "9be78226-36fa-43c4-865d-2f7e6e2ba9de"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Tools imported successfully!\n"
+     ]
+    }
+   ],
+   "source": [
+    "from praisonaiagents import Agent\n",
+    "import requests\n",
+    "import tempfile\n",
+    "from pathlib import Path\n",
+    "\n",
+    "print(\"✅ Tools imported successfully!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "efnnREHXUnYA"
+   },
+   "source": [
+    "# YAML Prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "kcM14-yQUqG-",
+    "outputId": "c5b6288d-a789-4a93-e20c-1d285370b667"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Agent instructions configured!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Agent configuration and instructions\n",
+    "AGENT_INSTRUCTIONS = \"\"\"\n",
+    "You are a helpful AI assistant specialized in Thai recipes and cooking.\n",
+    "\n",
+    "You have access to a PDF knowledge base about Thai recipes from: https://phi-public.s3.amazonaws.com/recipes/ThaiRecipes.pdf\n",
+    "\n",
+    "You can also search the web for additional information about Thai cooking, ingredients, and techniques.\n",
+    "\n",
+    "When answering questions:\n",
+    "1. Use your knowledge about Thai cuisine to provide helpful information\n",
+    "2. If needed, search the web for additional details, current information, or clarification\n",
+    "3. Provide comprehensive, helpful answers about Thai cuisine\n",
+    "4. Always be informative and helpful about Thai cooking!\n",
+    "\n",
+    "You can use the internet_search function to search the web when needed.\n",
+    "\n",
+    "Focus on providing practical cooking advice, ingredient information, and authentic Thai recipe guidance.\n",
+    "\"\"\"\n",
+    "\n",
+    "print(\"✅ Agent instructions configured!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MCBRcXFJUulY"
+   },
+   "source": [
+    "# Main"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "YaRLbgMmUvXv",
+    "outputId": "8ed8d9f8-85a7-48de-ccc6-f617cd672a85"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "🤖 Thai Recipe RAG Agent created successfully!\n",
+      "The agent is ready to answer questions about Thai cooking.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create the RAG agent\n",
+    "rag_agent = Agent(\n",
+    "    instructions=AGENT_INSTRUCTIONS,\n",
+    "    llm=\"gpt-4o\",\n",
+    "    markdown=True,\n",
+    "    verbose=True\n",
+    ")\n",
+    "\n",
+    "print(\"🤖 Thai Recipe RAG Agent created successfully!\")\n",
+    "print(\"The agent is ready to answer questions about Thai cooking.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "QvZM94pGU0IX"
+   },
+   "source": [
+    "# Test the Agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "47739975c9f04ee5b4e69e8f445cbeda",
+      "08888d583cba4c01b3fdf8f30b06ca4f"
+     ]
+    },
+    "id": "QPdrleKxU1VN",
+    "outputId": "a71a86cd-eff8-4309-9b50-173a30066c90"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "🤔 Question: What are the essential ingredients for Thai cooking?\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">╭─ </span><span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8; font-weight: bold\">Agent Info</span><span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\"> ────────────────────────────────────────────────────────────────────────────────────────────────────╮</span>\n",
+       "<span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>                                                                                                                 <span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>\n",
+       "<span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>  <span style=\"color: #ff9b9b; text-decoration-color: #ff9b9b; font-weight: bold\">👤 Agent:</span> <span style=\"color: #ffe5e5; text-decoration-color: #ffe5e5\">Agent</span>                                                                                                <span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>\n",
+       "<span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>  <span style=\"color: #b4b4b3; text-decoration-color: #b4b4b3; font-weight: bold\">Role:</span> <span style=\"color: #ffe5e5; text-decoration-color: #ffe5e5\">Assistant</span>                                                                                                <span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>\n",
+       "<span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>                                                                                                                 <span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>\n",
+       "<span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[38;2;210;227;200m╭─\u001b[0m\u001b[38;2;210;227;200m \u001b[0m\u001b[1;38;2;210;227;200mAgent Info\u001b[0m\u001b[38;2;210;227;200m \u001b[0m\u001b[38;2;210;227;200m───────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\u001b[38;2;210;227;200m─╮\u001b[0m\n",
+       "\u001b[38;2;210;227;200m│\u001b[0m                                                                                                                 \u001b[38;2;210;227;200m│\u001b[0m\n",
+       "\u001b[38;2;210;227;200m│\u001b[0m  \u001b[1;38;2;255;155;155m👤 Agent:\u001b[0m \u001b[38;2;255;229;229mAgent\u001b[0m                                                                                                \u001b[38;2;210;227;200m│\u001b[0m\n",
+       "\u001b[38;2;210;227;200m│\u001b[0m  \u001b[1;38;2;180;180;179mRole:\u001b[0m \u001b[38;2;255;229;229mAssistant\u001b[0m                                                                                                \u001b[38;2;210;227;200m│\u001b[0m\n",
+       "\u001b[38;2;210;227;200m│\u001b[0m                                                                                                                 \u001b[38;2;210;227;200m│\u001b[0m\n",
+       "\u001b[38;2;210;227;200m╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "47739975c9f04ee5b4e69e8f445cbeda",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">Response generated in 8.4s</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[2mResponse generated in 8.4s\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #008080; text-decoration-color: #008080\">╭───────────────────────────────────────────────────── Task ──────────────────────────────────────────────────────╮</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> What are the essential ingredients for Thai cooking?                                                            <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[36m╭─\u001b[0m\u001b[36m────────────────────────────────────────────────────\u001b[0m\u001b[36m Task \u001b[0m\u001b[36m─────────────────────────────────────────────────────\u001b[0m\u001b[36m─╮\u001b[0m\n",
+       "\u001b[36m│\u001b[0m What are the essential ingredients for Thai cooking?                                                            \u001b[36m│\u001b[0m\n",
+       "\u001b[36m╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #008080; text-decoration-color: #008080\">╭─────────────────────────────────────────────────── Response ────────────────────────────────────────────────────╮</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> Thai cooking is known for its balance of five fundamental taste senses in each dish or the overall meal: sour,  <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> sweet, salty, bitter, and spicy. Essential ingredients that help achieve this balance include:                  <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">  1 </span><span style=\"font-weight: bold\">Fish Sauce (Nam Pla)</span>: A salty, savory sauce made from fermented fish. It's a cornerstone of Thai cooking,   <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">    </span>used to add depth of flavor.                                                                                <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">  2 </span><span style=\"font-weight: bold\">Lime Juice</span>: Used to add a fresh, tangy citrus flavor to dishes, especially in salads and some curries.      <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">  3 </span><span style=\"font-weight: bold\">Chilies</span>: Thai cuisine often features fresh Thai bird's eye chilies for heat, as well as dried chilies for   <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">    </span>certain recipes.                                                                                            <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">  4 </span><span style=\"font-weight: bold\">Lemongrass</span>: A citrusy, fragrant herb that is often used in soups, curries, and teas.                        <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">  5 </span><span style=\"font-weight: bold\">Galangal</span>: Similar to ginger, galangal has a sharp, peppery flavor and is used in soups and curries.         <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">  6 </span><span style=\"font-weight: bold\">Kaffir Lime Leaves</span>: They add a distinct, zesty citrus aroma and flavor to Thai dishes.                      <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">  7 </span><span style=\"font-weight: bold\">Coconut Milk</span>: Adds richness and creaminess, commonly used in curries and desserts.                          <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">  8 </span><span style=\"font-weight: bold\">Palm Sugar</span>: Used as a sweetener, palm sugar has a nuanced flavor, unlike regular sugar.                     <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">  9 </span><span style=\"font-weight: bold\">Tamarind Paste</span>: Provides a sour element to many dishes, particularly pad Thai and some sauces.              <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> 10 </span><span style=\"font-weight: bold\">Thai Basil</span>: Adds a spicy, peppery flavor, different from the sweet basil used in Western cooking.           <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> 11 </span><span style=\"font-weight: bold\">Coriander (Cilantro)</span>: Used as a garnish and for its fresh, citrusy leaves and roots, which add depth to     <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">    </span>sauces and stocks.                                                                                          <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> 12 </span><span style=\"font-weight: bold\">Shrimp Paste</span>: A very pungent paste made from fermented shrimp, used sparingly to enrich the flavor of       <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">    </span>dishes.                                                                                                     <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> These ingredients are commonly used in combination to create the complex and rich flavors characteristic of     <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> Thai cuisine. Fresh and high-quality versions of these ingredients contribute significantly to the authenticity <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> of Thai dishes.                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[36m╭─\u001b[0m\u001b[36m──────────────────────────────────────────────────\u001b[0m\u001b[36m Response \u001b[0m\u001b[36m───────────────────────────────────────────────────\u001b[0m\u001b[36m─╮\u001b[0m\n",
+       "\u001b[36m│\u001b[0m Thai cooking is known for its balance of five fundamental taste senses in each dish or the overall meal: sour,  \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m sweet, salty, bitter, and spicy. Essential ingredients that help achieve this balance include:                  \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m  1 \u001b[0m\u001b[1mFish Sauce (Nam Pla)\u001b[0m: A salty, savory sauce made from fermented fish. It's a cornerstone of Thai cooking,   \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m    \u001b[0mused to add depth of flavor.                                                                                \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m  2 \u001b[0m\u001b[1mLime Juice\u001b[0m: Used to add a fresh, tangy citrus flavor to dishes, especially in salads and some curries.      \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m  3 \u001b[0m\u001b[1mChilies\u001b[0m: Thai cuisine often features fresh Thai bird's eye chilies for heat, as well as dried chilies for   \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m    \u001b[0mcertain recipes.                                                                                            \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m  4 \u001b[0m\u001b[1mLemongrass\u001b[0m: A citrusy, fragrant herb that is often used in soups, curries, and teas.                        \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m  5 \u001b[0m\u001b[1mGalangal\u001b[0m: Similar to ginger, galangal has a sharp, peppery flavor and is used in soups and curries.         \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m  6 \u001b[0m\u001b[1mKaffir Lime Leaves\u001b[0m: They add a distinct, zesty citrus aroma and flavor to Thai dishes.                      \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m  7 \u001b[0m\u001b[1mCoconut Milk\u001b[0m: Adds richness and creaminess, commonly used in curries and desserts.                          \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m  8 \u001b[0m\u001b[1mPalm Sugar\u001b[0m: Used as a sweetener, palm sugar has a nuanced flavor, unlike regular sugar.                     \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m  9 \u001b[0m\u001b[1mTamarind Paste\u001b[0m: Provides a sour element to many dishes, particularly pad Thai and some sauces.              \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m 10 \u001b[0m\u001b[1mThai Basil\u001b[0m: Adds a spicy, peppery flavor, different from the sweet basil used in Western cooking.           \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m 11 \u001b[0m\u001b[1mCoriander (Cilantro)\u001b[0m: Used as a garnish and for its fresh, citrusy leaves and roots, which add depth to     \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m    \u001b[0msauces and stocks.                                                                                          \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m 12 \u001b[0m\u001b[1mShrimp Paste\u001b[0m: A very pungent paste made from fermented shrimp, used sparingly to enrich the flavor of       \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m    \u001b[0mdishes.                                                                                                     \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m These ingredients are commonly used in combination to create the complex and rich flavors characteristic of     \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m Thai cuisine. Fresh and high-quality versions of these ingredients contribute significantly to the authenticity \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m of Thai dishes.                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "�� Answer: Thai cooking is known for its balance of five fundamental taste senses in each dish or the overall meal: sour, sweet, salty, bitter, and spicy. Essential ingredients that help achieve this balance include:\n",
+      "\n",
+      "1. **Fish Sauce (Nam Pla)**: A salty, savory sauce made from fermented fish. It's a cornerstone of Thai cooking, used to add depth of flavor.\n",
+      "\n",
+      "2. **Lime Juice**: Used to add a fresh, tangy citrus flavor to dishes, especially in salads and some curries.\n",
+      "\n",
+      "3. **Chilies**: Thai cuisine often features fresh Thai bird's eye chilies for heat, as well as dried chilies for certain recipes.\n",
+      "\n",
+      "4. **Lemongrass**: A citrusy, fragrant herb that is often used in soups, curries, and teas.\n",
+      "\n",
+      "5. **Galangal**: Similar to ginger, galangal has a sharp, peppery flavor and is used in soups and curries.\n",
+      "\n",
+      "6. **Kaffir Lime Leaves**: They add a distinct, zesty citrus aroma and flavor to Thai dishes.\n",
+      "\n",
+      "7. **Coconut Milk**: Adds richness and creaminess, commonly used in curries and desserts.\n",
+      "\n",
+      "8. **Palm Sugar**: Used as a sweetener, palm sugar has a nuanced flavor, unlike regular sugar.\n",
+      "\n",
+      "9. **Tamarind Paste**: Provides a sour element to many dishes, particularly pad Thai and some sauces.\n",
+      "\n",
+      "10. **Thai Basil**: Adds a spicy, peppery flavor, different from the sweet basil used in Western cooking.\n",
+      "\n",
+      "11. **Coriander (Cilantro)**: Used as a garnish and for its fresh, citrusy leaves and roots, which add depth to sauces and stocks.\n",
+      "\n",
+      "12. **Shrimp Paste**: A very pungent paste made from fermented shrimp, used sparingly to enrich the flavor of dishes.\n",
+      "\n",
+      "These ingredients are commonly used in combination to create the complex and rich flavors characteristic of Thai cuisine. Fresh and high-quality versions of these ingredients contribute significantly to the authenticity of Thai dishes.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Test question 1: Basic Thai cooking\n",
+    "question1 = \"What are the essential ingredients for Thai cooking?\"\n",
+    "print(f\"🤔 Question: {question1}\")\n",
+    "\n",
+    "try:\n",
+    "    response1 = rag_agent.start(question1)\n",
+    "    print(f\"�� Answer: {response1}\")\n",
+    "except Exception as e:\n",
+    "    print(f\"❌ Error: {e}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

examples/cookbooks/rag_examples/agentic_rag/agentic_rag_gpt5_praisonai_agents.ipynb

@@ -0,0 +1,556 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EA8l4cSVl3Lx"
+   },
+   "source": [
+    "# Agentic RAG with GPT-5 - Colab Notebook"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "I-8nOxJ2l7nO"
+   },
+   "source": [
+    "This Colab notebook sets up a Streamlit app using PraisonAI Agents framework.\n",
+    "It allows you to interact with an AI agent powered by GPT-5 for Q&A.\n",
+    "Currently, the knowledge base functionality is disabled due to compatibility issues."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "g5I1tMkxmDQe"
+   },
+   "source": [
+    "- GPT-5 Integration (via OpenAI API)\n",
+    "- Streamlit Web App\n",
+    "- Agent Framework: PraisonAI Agents\n",
+    "- Markdown-formatted responses"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yeEno7U0q2U_"
+   },
+   "source": [
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Dhivya-Bharathy/PraisonAI/blob/main/examples/cookbooks/Qwen2.5_InstructionAgent.ipynb)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WV2GnzZCmGBR"
+   },
+   "source": [
+    "# Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "20wAadXemJ0k"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install praisonaiagents python-dotenv streamlit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "l71uCRarndvy"
+   },
+   "source": [
+    "# Set API Key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "id": "brfc-ZZKnfre"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv()\n",
+    "\n",
+    "OPENAI_API_KEY = \"Enter your api key here\"\n",
+    "\n",
+    "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "d1fGzyQCn1aQ"
+   },
+   "source": [
+    "# Tools and Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "id": "GcNPLkZXntIS"
+   },
+   "outputs": [],
+   "source": [
+    "import streamlit as st\n",
+    "from praisonaiagents import Agent\n",
+    "\n",
+    "# YAML Prompt Configuration\n",
+    "agent_config = {\n",
+    "    \"name\": \"Knowledge Agent\",\n",
+    "    \"instructions\": [\n",
+    "        \"You are a helpful AI assistant. Answer questions based on your general knowledge.\",\n",
+    "        \"Provide clear, well-structured answers in markdown format.\",\n",
+    "        \"Use proper markdown formatting with headers, lists, and emphasis where appropriate.\",\n",
+    "        \"Structure your response with clear sections and bullet points when helpful.\",\n",
+    "    ],\n",
+    "    \"llm\": \"gpt-5-nano\",\n",
+    "    \"markdown\": True,\n",
+    "    \"verbose\": True\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jkmrh0gIn_4a"
+   },
+   "source": [
+    "# Initialize Agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "id": "qaJvf8RyoAsB"
+   },
+   "outputs": [],
+   "source": [
+    "def create_agent():\n",
+    "    \"\"\"Create an agent with reasoning capabilities\"\"\"\n",
+    "    return Agent(\n",
+    "        name=agent_config[\"name\"],\n",
+    "        instructions=agent_config[\"instructions\"],\n",
+    "        llm=agent_config[\"llm\"],\n",
+    "        markdown=agent_config[\"markdown\"],\n",
+    "        verbose=agent_config[\"verbose\"]\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kvGJh3bbqTmh"
+   },
+   "source": [
+    "# Main Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "ad296d97510246de8eb0138ce8a8a166",
+      "f6e502b3dca442f0ae6c5739f5a6d159"
+     ]
+    },
+    "id": "_QyxzqKKqUrW",
+    "outputId": "97be7e02-b034-4004-e9e3-56337e3f2887"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "�� Initializing Agentic RAG with GPT-5...\n",
+      "📚 Loading agent...\n",
+      "✅ Agent loaded successfully!\n",
+      "\n",
+      "🎯 Example queries you can try:\n",
+      "1. What is PraisonAI and how do Agents work?\n",
+      "2. What are Teams in PraisonAI and how do they work?\n",
+      "3. Give me a step-by-step guide to building a RAG system.\n",
+      "4. What are AI Agents?\n",
+      "\n",
+      "============================================================\n",
+      "\n",
+      "🤔 Enter your question (or 'quit' to exit):\n",
+      "> What is PraisonAI and how do Agents work?\n",
+      "🔍 Processing your question...\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">╭─ </span><span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8; font-weight: bold\">Agent Info</span><span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\"> ────────────────────────────────────────────────────────────────────────────────────────────────────╮</span>\n",
+       "<span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>                                                                                                                 <span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>\n",
+       "<span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>  <span style=\"color: #ff9b9b; text-decoration-color: #ff9b9b; font-weight: bold\">👤 Agent:</span> <span style=\"color: #ffe5e5; text-decoration-color: #ffe5e5\">Knowledge Agent</span>                                                                                      <span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>\n",
+       "<span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>  <span style=\"color: #b4b4b3; text-decoration-color: #b4b4b3; font-weight: bold\">Role:</span> <span style=\"color: #ffe5e5; text-decoration-color: #ffe5e5\">Assistant</span>                                                                                                <span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>\n",
+       "<span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>                                                                                                                 <span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">│</span>\n",
+       "<span style=\"color: #d2e3c8; text-decoration-color: #d2e3c8\">╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[38;2;210;227;200m╭─\u001b[0m\u001b[38;2;210;227;200m \u001b[0m\u001b[1;38;2;210;227;200mAgent Info\u001b[0m\u001b[38;2;210;227;200m \u001b[0m\u001b[38;2;210;227;200m───────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\u001b[38;2;210;227;200m─╮\u001b[0m\n",
+       "\u001b[38;2;210;227;200m│\u001b[0m                                                                                                                 \u001b[38;2;210;227;200m│\u001b[0m\n",
+       "\u001b[38;2;210;227;200m│\u001b[0m  \u001b[1;38;2;255;155;155m👤 Agent:\u001b[0m \u001b[38;2;255;229;229mKnowledge Agent\u001b[0m                                                                                      \u001b[38;2;210;227;200m│\u001b[0m\n",
+       "\u001b[38;2;210;227;200m│\u001b[0m  \u001b[1;38;2;180;180;179mRole:\u001b[0m \u001b[38;2;255;229;229mAssistant\u001b[0m                                                                                                \u001b[38;2;210;227;200m│\u001b[0m\n",
+       "\u001b[38;2;210;227;200m│\u001b[0m                                                                                                                 \u001b[38;2;210;227;200m│\u001b[0m\n",
+       "\u001b[38;2;210;227;200m╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ad296d97510246de8eb0138ce8a8a166",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"></pre>\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">Response generated in 9.4s</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[2mResponse generated in 9.4s\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #008080; text-decoration-color: #008080\">╭───────────────────────────────────────────────────── Task ──────────────────────────────────────────────────────╮</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> What is PraisonAI and how do Agents work?                                                                       <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[36m╭─\u001b[0m\u001b[36m────────────────────────────────────────────────────\u001b[0m\u001b[36m Task \u001b[0m\u001b[36m─────────────────────────────────────────────────────\u001b[0m\u001b[36m─╮\u001b[0m\n",
+       "\u001b[36m│\u001b[0m What is PraisonAI and how do Agents work?                                                                       \u001b[36m│\u001b[0m\n",
+       "\u001b[36m╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #008080; text-decoration-color: #008080\">╭─────────────────────────────────────────────────── Response ────────────────────────────────────────────────────╮</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> ┃                                             <span style=\"font-weight: bold\">What is PraisonAI?</span>                                              ┃ <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛ <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> PraisonAI is a platform designed to leverage artificial intelligence to enhance personal and business           <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> productivity. It typically involves developing AI models that can assist in various tasks, automate processes,  <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> and provide insights based on data analysis.                                                                    <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                            <span style=\"font-weight: bold; text-decoration: underline\">Key Features of PraisonAI</span>                                            <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Task Automation</span>: Automates repetitive tasks, allowing users to focus on more strategic activities.           <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Data Insights</span>: Analyzes large sets of data to provide actionable insights.                                   <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Natural Language Processing</span>: Enables users to interact with the AI through natural language, making it       <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">   </span>user-friendly.                                                                                               <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Customizable Solutions</span>: Tailors AI applications to meet specific user needs across various industries.       <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> ┃                                      <span style=\"font-weight: bold\">How Do Agents Work in PraisonAI?</span>                                       ┃ <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛ <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> Agents in PraisonAI refer to autonomous or semi-autonomous AI systems that perform designated tasks or          <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> functions. Here’s how they typically operate:                                                                   <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                               <span style=\"font-weight: bold; text-decoration: underline\">1. Types of Agents</span>                                                <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Reactive Agents</span>: Respond to the current environment without internal memory. They act solely based on        <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">   </span>current inputs.                                                                                              <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Deliberative Agents</span>: Have a model of their environment, plan their actions, and retain memories of past      <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">   </span>interactions.                                                                                                <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Learning Agents</span>: Improve their performance over time through experience, adapting to new information.        <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                           <span style=\"font-weight: bold; text-decoration: underline\">2. Functionality of Agents</span>                                            <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Task Execution</span>: Agents can carry out specific tasks as programmed, such as scheduling, data entry, or        <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">   </span>customer support.                                                                                            <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Interaction</span>: They often interact with users through chat interfaces or APIs, providing a seamless user       <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">   </span>experience.                                                                                                  <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Integration</span>: Can be integrated with other systems or software to enhance functionality, such as CRM systems, <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">   </span>databases, or other AI tools.                                                                                <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Continuous Learning</span>: Agents may utilize machine learning algorithms to adapt and evolve based on user        <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">   </span>interactions and data received.                                                                              <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                           <span style=\"font-weight: bold; text-decoration: underline\">3. Benefits of Using Agents</span>                                           <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Increased Efficiency</span>: Automate routine tasks to reduce workload.                                             <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">24/7 Availability</span>: Provide consistent support and functionality without downtime.                            <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Scalability</span>: Easily scale operations by deploying more agents as needed.                                     <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\"> • </span><span style=\"font-weight: bold\">Data-Driven Decisions</span>: Use data insights to inform strategy and operations.                                  <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                   <span style=\"font-weight: bold; text-decoration: underline\">Conclusion</span>                                                    <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span>                                                                                                                 <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> PraisonAI represents a robust platform for enhancing productivity through AI, with agents serving as the heart  <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> of this solution, performing various tasks and supporting users in achieving their goals efficiently. Whether   <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> they are simple reactive agents or complex learning entities, their design focuses on making operations         <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">│</span> smoother and more effective.                                                                                    <span style=\"color: #008080; text-decoration-color: #008080\">│</span>\n",
+       "<span style=\"color: #008080; text-decoration-color: #008080\">╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[36m╭─\u001b[0m\u001b[36m──────────────────────────────────────────────────\u001b[0m\u001b[36m Response \u001b[0m\u001b[36m───────────────────────────────────────────────────\u001b[0m\u001b[36m─╮\u001b[0m\n",
+       "\u001b[36m│\u001b[0m ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m ┃                                             \u001b[1mWhat is PraisonAI?\u001b[0m                                              ┃ \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛ \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m PraisonAI is a platform designed to leverage artificial intelligence to enhance personal and business           \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m productivity. It typically involves developing AI models that can assist in various tasks, automate processes,  \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m and provide insights based on data analysis.                                                                    \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                            \u001b[1;4mKey Features of PraisonAI\u001b[0m                                            \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mTask Automation\u001b[0m: Automates repetitive tasks, allowing users to focus on more strategic activities.           \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mData Insights\u001b[0m: Analyzes large sets of data to provide actionable insights.                                   \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mNatural Language Processing\u001b[0m: Enables users to interact with the AI through natural language, making it       \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m   \u001b[0muser-friendly.                                                                                               \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mCustomizable Solutions\u001b[0m: Tailors AI applications to meet specific user needs across various industries.       \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m ┃                                      \u001b[1mHow Do Agents Work in PraisonAI?\u001b[0m                                       ┃ \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛ \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m Agents in PraisonAI refer to autonomous or semi-autonomous AI systems that perform designated tasks or          \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m functions. Here’s how they typically operate:                                                                   \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                               \u001b[1;4m1. \u001b[0m\u001b[1;4mTypes of Agents\u001b[0m                                                \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mReactive Agents\u001b[0m: Respond to the current environment without internal memory. They act solely based on        \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m   \u001b[0mcurrent inputs.                                                                                              \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mDeliberative Agents\u001b[0m: Have a model of their environment, plan their actions, and retain memories of past      \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m   \u001b[0minteractions.                                                                                                \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mLearning Agents\u001b[0m: Improve their performance over time through experience, adapting to new information.        \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                           \u001b[1;4m2. \u001b[0m\u001b[1;4mFunctionality of Agents\u001b[0m                                            \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mTask Execution\u001b[0m: Agents can carry out specific tasks as programmed, such as scheduling, data entry, or        \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m   \u001b[0mcustomer support.                                                                                            \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mInteraction\u001b[0m: They often interact with users through chat interfaces or APIs, providing a seamless user       \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m   \u001b[0mexperience.                                                                                                  \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mIntegration\u001b[0m: Can be integrated with other systems or software to enhance functionality, such as CRM systems, \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m   \u001b[0mdatabases, or other AI tools.                                                                                \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mContinuous Learning\u001b[0m: Agents may utilize machine learning algorithms to adapt and evolve based on user        \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m   \u001b[0minteractions and data received.                                                                              \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                           \u001b[1;4m3. \u001b[0m\u001b[1;4mBenefits of Using Agents\u001b[0m                                           \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mIncreased Efficiency\u001b[0m: Automate routine tasks to reduce workload.                                             \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1m24/7 Availability\u001b[0m: Provide consistent support and functionality without downtime.                            \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mScalability\u001b[0m: Easily scale operations by deploying more agents as needed.                                     \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m \u001b[1;33m • \u001b[0m\u001b[1mData-Driven Decisions\u001b[0m: Use data insights to inform strategy and operations.                                  \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                   \u001b[1;4mConclusion\u001b[0m                                                    \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m                                                                                                                 \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m PraisonAI represents a robust platform for enhancing productivity through AI, with agents serving as the heart  \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m of this solution, performing various tasks and supporting users in achieving their goals efficiently. Whether   \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m they are simple reactive agents or complex learning entities, their design focuses on making operations         \u001b[36m│\u001b[0m\n",
+       "\u001b[36m│\u001b[0m smoother and more effective.                                                                                    \u001b[36m│\u001b[0m\n",
+       "\u001b[36m╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "💡 Answer:\n",
+      "========================================\n",
+      "# What is PraisonAI?\n",
+      "\n",
+      "PraisonAI is a platform designed to leverage artificial intelligence to enhance personal and business productivity. It typically involves developing AI models that can assist in various tasks, automate processes, and provide insights based on data analysis.\n",
+      "\n",
+      "## Key Features of PraisonAI\n",
+      "\n",
+      "- **Task Automation**: Automates repetitive tasks, allowing users to focus on more strategic activities.\n",
+      "- **Data Insights**: Analyzes large sets of data to provide actionable insights.\n",
+      "- **Natural Language Processing**: Enables users to interact with the AI through natural language, making it user-friendly.\n",
+      "- **Customizable Solutions**: Tailors AI applications to meet specific user needs across various industries.\n",
+      "\n",
+      "# How Do Agents Work in PraisonAI?\n",
+      "\n",
+      "Agents in PraisonAI refer to autonomous or semi-autonomous AI systems that perform designated tasks or functions. Here’s how they typically operate:\n",
+      "\n",
+      "## 1. **Types of Agents**\n",
+      "\n",
+      "- **Reactive Agents**: Respond to the current environment without internal memory. They act solely based on current inputs.\n",
+      "- **Deliberative Agents**: Have a model of their environment, plan their actions, and retain memories of past interactions.\n",
+      "- **Learning Agents**: Improve their performance over time through experience, adapting to new information.\n",
+      "\n",
+      "## 2. **Functionality of Agents**\n",
+      "\n",
+      "- **Task Execution**: Agents can carry out specific tasks as programmed, such as scheduling, data entry, or customer support.\n",
+      "- **Interaction**: They often interact with users through chat interfaces or APIs, providing a seamless user experience.\n",
+      "- **Integration**: Can be integrated with other systems or software to enhance functionality, such as CRM systems, databases, or other AI tools.\n",
+      "- **Continuous Learning**: Agents may utilize machine learning algorithms to adapt and evolve based on user interactions and data received.\n",
+      "\n",
+      "## 3. **Benefits of Using Agents**\n",
+      "\n",
+      "- **Increased Efficiency**: Automate routine tasks to reduce workload.\n",
+      "- **24/7 Availability**: Provide consistent support and functionality without downtime.\n",
+      "- **Scalability**: Easily scale operations by deploying more agents as needed.\n",
+      "- **Data-Driven Decisions**: Use data insights to inform strategy and operations.\n",
+      "\n",
+      "## Conclusion\n",
+      "\n",
+      "PraisonAI represents a robust platform for enhancing productivity through AI, with agents serving as the heart of this solution, performing various tasks and supporting users in achieving their goals efficiently. Whether they are simple reactive agents or complex learning entities, their design focuses on making operations smoother and more effective.\n",
+      "========================================\n",
+      "\n",
+      "🤔 Enter your question (or 'quit' to exit):\n",
+      "> quit\n",
+      "👋 Goodbye!\n"
+     ]
+    }
+   ],
+   "source": [
+    "def main():\n",
+    "    print(\"�� Initializing Agentic RAG with GPT-5...\")\n",
+    "\n",
+    "    # Check if API key is set\n",
+    "    if not OPENAI_API_KEY or OPENAI_API_KEY == \"your_openai_api_key_here\":\n",
+    "        print(\"❌ Please set your OpenAI API key first!\")\n",
+    "        print(\"�� Get your key from: https://platform.openai.com/\")\n",
+    "        return\n",
+    "\n",
+    "    try:\n",
+    "        # Create agent\n",
+    "        print(\"📚 Loading agent...\")\n",
+    "        agent = create_agent()\n",
+    "        print(\"✅ Agent loaded successfully!\")\n",
+    "\n",
+    "        # Example queries\n",
+    "        example_queries = [\n",
+    "            \"What is PraisonAI and how do Agents work?\",\n",
+    "            \"What are Teams in PraisonAI and how do they work?\",\n",
+    "            \"Give me a step-by-step guide to building a RAG system.\",\n",
+    "            \"What are AI Agents?\"\n",
+    "        ]\n",
+    "\n",
+    "        print(\"\\n🎯 Example queries you can try:\")\n",
+    "        for i, query in enumerate(example_queries, 1):\n",
+    "            print(f\"{i}. {query}\")\n",
+    "\n",
+    "        print(\"\\n\" + \"=\"*60)\n",
+    "\n",
+    "        # Interactive query loop\n",
+    "        while True:\n",
+    "            print(\"\\n🤔 Enter your question (or 'quit' to exit):\")\n",
+    "            user_query = input(\"> \")\n",
+    "\n",
+    "            if user_query.lower() in ['quit', 'exit', 'q']:\n",
+    "                print(\"👋 Goodbye!\")\n",
+    "                break\n",
+    "\n",
+    "            if user_query.strip():\n",
+    "                print(\"🔍 Processing your question...\")\n",
+    "                try:\n",
+    "                    response = agent.start(user_query)\n",
+    "                    print(\"\\n💡 Answer:\")\n",
+    "                    print(\"=\"*40)\n",
+    "                    print(response)\n",
+    "                    print(\"=\"*40)\n",
+    "                except Exception as e:\n",
+    "                    print(f\"❌ Error: {str(e)}\")\n",
+    "                    print(f\"🔍 Error type: {type(e).__name__}\")\n",
+    "                    print(\"💡 This might be due to API issues or model access problems.\")\n",
+    "            else:\n",
+    "                print(\"❌ Please enter a valid question.\")\n",
+    "\n",
+    "    except Exception as e:\n",
+    "        print(f\"❌ Failed to initialize agent: {str(e)}\")\n",
+    "        print(\"�� Make sure your API key is correct and you have sufficient credits.\")\n",
+    "\n",
+    "# Run the main function\n",
+    "if __name__ == \"__main__\":\n",
+    "    main()"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

examples/cookbooks/yaml/article_generation_agents.ipynb

@@ -585,7 +585,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/auto_email_responder_agents.ipynb

@@ -1090,7 +1090,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/aws_bedrock_agents.yaml

@@ -1,10 +1,10 @@
 framework: crewai
 topic: "Technology Research and Content Creation using AWS Bedrock"
 
-roles:
+agents:  # Canonical: use 'agents' instead of 'roles'
   research_specialist:
     role: "Research Specialist"
-    backstory: |
+    instructions:  # Canonical |
       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.
@@ -35,7 +35,7 @@ roles:
 
   content_creator:
     role: "Technical Content Creator"
-    backstory: |
+    instructions:  # Canonical |
       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.
@@ -64,7 +64,7 @@ roles:
 
   quality_reviewer:
     role: "Content Quality Reviewer"
-    backstory: |
+    instructions:  # Canonical |
       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.

examples/cookbooks/yaml/book_writing_agents.ipynb

@@ -2077,7 +2077,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/business_product_launch_agents.ipynb

@@ -151,7 +151,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/cli_operation_agents.ipynb

@@ -533,7 +533,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/comprehensive_research_report_agents.ipynb

@@ -235,7 +235,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/email_workflow_management_agents.ipynb

@@ -1250,7 +1250,7 @@
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
         "os.environ[\"TAVILY_API_KEY\"] = userdata.get('TAVILY_API_KEY') or \"ENTER TAVILY_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/game_development_agents.ipynb

@@ -1559,7 +1559,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/instagram_post_agents.ipynb

@@ -2159,7 +2159,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/job_hunt_agents.ipynb

@@ -698,7 +698,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/job_profile_matching_agents.ipynb

@@ -592,7 +592,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/language_translator_agents.ipynb

@@ -572,7 +572,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/markdown_validator_agents.ipynb

@@ -580,7 +580,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/marketing_campaign_development_agents.ipynb

@@ -252,7 +252,7 @@
      "text": [
       "\u001b[95m \n",
       "\n",
-      "[{'title': 'CrewAI uses third-party models to automate business tasks', 'href': 'https://techcrunch.com/2024/10/22/crewai-uses-third-party-models-to-automate-business-tasks/', 'body': 'CrewAI, a startup developing a hub where companies can build automations using third-party AI models, has raised $18 million from investors including Andrew Ng. ... 4:00 AM PDT · October 22, 2024 ...'}, {'title': 'CrewAI Launches Multi-Agentic Platform to Deliver on the Promise of ...', 'href': 'https://markets.businessinsider.com/news/stocks/crewai-launches-multi-agentic-platform-to-deliver-on-the-promise-of-generative-ai-for-enterprise-1033870246?op=1', 'body': 'SAN FRANCISCO and SÃO PAULO, Oct. 22, 2024 (GLOBE NEWSWIRE) -- CrewAI, a leading multi-agent platform, today announced $18 million in total funding that included an inception round led by ...'}, {'title': 'Agentic AI startup CrewAI closes $18M funding round', 'href': 'https://siliconangle.com/2024/10/22/agentic-ai-startup-crewai-closes-18m-funding-round/', 'body': \"An e-commerce company, for example, could create an agent that uses GPT-4o to generate shopping advice based on customers' past purchases. CrewAI has created an open-source framework of the same ...\"}, {'title': 'CrewAI Company Profile 2024: Valuation, Funding & Investors - PitchBook', 'href': 'https://pitchbook.com/profiles/company/590845-78', 'body': \"Explore institutional-grade private market research from our team of analysts. ... Artificial Intelligence & Machine Learning; Artificial Intelligence & Machine Learning Report. September 19, 2024. CrewAI Executive Team (2) Update this profile Name ... CrewAI's primary industry is Business/Productivity Software. Is CrewAI a private or public ...\"}, {'title': 'CrewAI - Autonomous AI Agents in action for a market ... - LinkedIn', 'href': 'https://www.linkedin.com/pulse/crewai-autonomous-ai-agents-action-market-research-task-kithion-ovnrc', 'body': 'The will provide a detailed market trends report, the will generate a comprehensive analysis of top competitors, and the will develop a thorough marketing plan. Conclusion. CrewAI, combined with ...'}]\n",
+      "[{'title': 'CrewAI uses third-party models to automate business tasks', 'href': 'https://techcrunch.com/2024/10/22/crewai-uses-third-party-models-to-automate-business-tasks/', 'body': 'CrewAI, a startup developing a hub where companies can build automations using third-party AI models, has raised $18 million from investors including Andrew Ng. ... 4:00 AM PDT · October 22, 2024 ...'}, {'title': 'CrewAI Launches Multi-Agentic Platform to Deliver on the Promise of ...', 'href': 'https://markets.businessinsider.com/news/stocks/crewai-launches-multi-agentic-platform-to-deliver-on-the-promise-of-generative-ai-for-enterprise-1033870246?op=1', 'body': 'SAN FRANCISCO and SÃO PAULO, Oct. 22, 2024 (GLOBE NEWSWIRE) -- CrewAI, a leading multi-agent platform, today announced $18 million in total funding that included an inception round led by ...'}, {'title': 'Agentic AI startup CrewAI closes $18M funding round', 'href': 'https://siliconangle.com/2024/10/22/agentic-ai-startup-crewai-closes-18m-funding-round/', 'body': \"An e-commerce company, for example, could create an agent that uses gpt-5-nano to generate shopping advice based on customers' past purchases. CrewAI has created an open-source framework of the same ...\"}, {'title': 'CrewAI Company Profile 2024: Valuation, Funding & Investors - PitchBook', 'href': 'https://pitchbook.com/profiles/company/590845-78', 'body': \"Explore institutional-grade private market research from our team of analysts. ... Artificial Intelligence & Machine Learning; Artificial Intelligence & Machine Learning Report. September 19, 2024. CrewAI Executive Team (2) Update this profile Name ... CrewAI's primary industry is Business/Productivity Software. Is CrewAI a private or public ...\"}, {'title': 'CrewAI - Autonomous AI Agents in action for a market ... - LinkedIn', 'href': 'https://www.linkedin.com/pulse/crewai-autonomous-ai-agents-action-market-research-task-kithion-ovnrc', 'body': 'The will provide a detailed market trends report, the will generate a comprehensive analysis of top competitors, and the will develop a thorough marketing plan. Conclusion. CrewAI, combined with ...'}]\n",
       "\u001b[00m\n",
       "\u001b[32;1m\u001b[1;3mThought: I have found more information about CrewAI's target customers and market positioning. CrewAI is a startup that has developed a hub where companies can build automations using third-party AI models, and it has recently raised $18 million in funding. Their target customers are likely businesses looking to automate complex tasks and improve efficiency using AI. They are positioned as a platform for deploying and managing AI agents to automate a variety of tasks.\n",
       "\n",

examples/cookbooks/yaml/meeting_prep_and_strategy_agents.ipynb

@@ -1075,7 +1075,7 @@
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
         "os.environ[\"EXA_API_KEY\"] = userdata.get('EXA_API_KEY') or \"ENTER EXA_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/meeting_prep_using_slack_and_trello_agents.ipynb

@@ -667,7 +667,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/memory_management_and_knowledge_retreival_agents.ipynb

@@ -1947,7 +1947,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/model_fee_retreival_agents.ipynb

@@ -73,7 +73,7 @@
     "            url=url,\n",
     "            word_count_threshold=1,\n",
     "            extraction_strategy= LLMExtractionStrategy(\n",
-    "                provider=\"openai/gpt-4o\",\n",
+    "                provider=\"openai/gpt-5-nano\",\n",
     "                api_token=os.getenv('OPENAI_API_KEY'),\n",
     "                schema=ModelFee.schema(),\n",
     "                extraction_type=\"schema\",\n",
@@ -666,7 +666,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/news_retreival_rag_agents.ipynb

@@ -475,7 +475,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/recruitment_flow_agents.ipynb

@@ -2130,7 +2130,7 @@
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
     "os.environ[\"SERPER_API_KEY\"] = userdata.get('SERPER_API_KEY') or \"ENTER SERPER_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/reddit_search_analysis_agents.ipynb

@@ -635,7 +635,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/research_report_generation_agents.ipynb

@@ -564,7 +564,7 @@
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
     "os.environ[\"TAVILY_API_KEY\"] = userdata.get('TAVILY_API_KEY') or \"ENTER TAVILY_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/research_through_azure_instance_agents.ipynb

@@ -564,7 +564,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/screenplay_writer_agents.ipynb

@@ -614,7 +614,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/secondary_market_research_agents.ipynb

@@ -66,7 +66,7 @@
     "\n",
     "# Set up OpenAI API key (add to Google Colab secrets)\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\""
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\""
    ]
   },
   {

examples/cookbooks/yaml/secondary_market_research_agents.yaml

@@ -8,10 +8,10 @@ variables:
   industry: "Electric Vehicles"
   research_focus: "comprehensive market analysis"
 
-roles:
+agents:  # Canonical: use 'agents' instead of 'roles'
   market_overview_specialist:
     role: "Market Overview Specialist" 
-    backstory: |
+    instructions:  # Canonical |
       You are a seasoned market research analyst with 10+ years of experience 
       in analyzing market dynamics, trends, and growth patterns across various 
       industries. You excel at synthesizing complex market data into clear, 
@@ -22,7 +22,7 @@ roles:
     verbose: true
     allow_delegation: false
     llm:
-      model: "gpt-4o-mini"
+      model: "gpt-5-nano"
       temperature: 0.3
     tools:
       - "InternetSearchTool"
@@ -64,7 +64,7 @@ roles:
 
   competitive_intelligence_analyst:
     role: "Competitive Intelligence Analyst"
-    backstory: |
+    instructions:  # Canonical |
       You are a competitive intelligence expert specializing in analyzing 
       competitive landscapes, market positioning, and strategic intelligence. 
       You have deep expertise in competitor analysis, market share assessment, 
@@ -76,7 +76,7 @@ roles:
     verbose: true
     allow_delegation: false
     llm:
-      model: "gpt-4o-mini" 
+      model: "gpt-5-nano" 
       temperature: 0.3
     tools:
       - "InternetSearchTool"
@@ -119,7 +119,7 @@ roles:
 
   financial_performance_analyst:
     role: "Financial Performance Analyst"
-    backstory: |
+    instructions:  # Canonical |
       You are a financial analyst with expertise in corporate finance, 
       financial statement analysis, and industry benchmarking. You specialize 
       in analyzing financial performance metrics, trends, and comparative 
@@ -130,7 +130,7 @@ roles:
     verbose: true
     allow_delegation: false
     llm:
-      model: "gpt-4o-mini"
+      model: "gpt-5-nano"
       temperature: 0.3
     tools:
       - "InternetSearchTool"
@@ -173,7 +173,7 @@ roles:
 
   growth_opportunities_researcher:
     role: "Growth Opportunities Researcher"
-    backstory: |
+    instructions:  # Canonical |
       You are a strategic business analyst specializing in identifying growth 
       opportunities, market expansion strategies, and emerging business models. 
       You excel at spotting trends, gaps, and untapped potential in markets 
@@ -185,7 +185,7 @@ roles:
     verbose: true
     allow_delegation: false
     llm:
-      model: "gpt-4o-mini"
+      model: "gpt-5-nano"
       temperature: 0.4
     tools:
       - "InternetSearchTool"
@@ -228,7 +228,7 @@ roles:
 
   risk_assessment_specialist:
     role: "Risk Assessment Specialist"
-    backstory: |
+    instructions:  # Canonical |
       You are a risk management expert with extensive experience in identifying, 
       analyzing, and assessing business risks across various industries. You 
       specialize in market risks, competitive threats, regulatory challenges, 
@@ -239,7 +239,7 @@ roles:
     verbose: true
     allow_delegation: false
     llm:
-      model: "gpt-4o-mini"
+      model: "gpt-5-nano"
       temperature: 0.3
     tools:
       - "InternetSearchTool"
@@ -287,7 +287,7 @@ roles:
 
   research_report_synthesizer:
     role: "Research Report Synthesizer"
-    backstory: |
+    instructions:  # Canonical |
       You are an expert business report writer and analyst with extensive 
       experience in synthesizing complex research findings into clear, 
       actionable business intelligence reports. You excel at creating 
@@ -299,7 +299,7 @@ roles:
     verbose: true
     allow_delegation: false
     llm:
-      model: "gpt-4o-mini"
+      model: "gpt-5-nano"
       temperature: 0.3
     tasks:
       report_synthesis:

examples/cookbooks/yaml/shakespearean_tweets_generation_agents.ipynb

@@ -462,7 +462,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/stock_analysis_agents.ipynb

@@ -380,7 +380,7 @@
         "\n",
         "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
         "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+        "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
         "\n",
         "# Run PraisonAI\n",
         "result = praisonai.run()\n",

examples/cookbooks/yaml/story_book_author_agents.ipynb

@@ -540,7 +540,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/surprise_trip_planner_and_itinerary_agents.ipynb

@@ -2639,7 +2639,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/trip_planner_agents.ipynb

@@ -1835,7 +1835,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/wikipedia_search_analysis_agents.ipynb

@@ -623,7 +623,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/you_search_analysis_agents.ipynb

@@ -635,7 +635,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/cookbooks/yaml/youtube_search_analysis_agents.ipynb

@@ -582,7 +582,7 @@
     "\n",
     "# Add OPENAI_API_KEY Secrets to Google Colab on the Left Hand Side 🔑 or Enter Manually Below\n",
     "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
-    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-5-nano\"\n",
     "\n",
     "# Run PraisonAI\n",
     "result = praisonai.run()\n",

examples/guardrail_example_fixed.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+Fixed example demonstrating proper guardrail usage with PraisonAI Agents.
+This addresses the issues reported in issue #875.
+"""
+
+from praisonaiagents import Agent, Task, GuardrailResult, PraisonAIAgents, TaskOutput
+from typing import Tuple, Any
+import trafilatura
+
+# Example 1: Using GuardrailResult return type (now supported!)
+def validate_length_guardrailresult(output: TaskOutput) -> GuardrailResult:
+    """Ensure output is between 100-500 characters using GuardrailResult"""
+    # Extract the raw text from the TaskOutput object
+    text = output.raw if hasattr(output, 'raw') else str(output)
+    length = len(text)
+    
+    if 100 <= length <= 500:
+        return GuardrailResult(
+            success=True,
+            result=output,  # Pass through the original output
+            error=""
+        )
+    else:
+        return GuardrailResult(
+            success=False,
+            result=None,
+            error=f"Output must be 100-500 chars, got {length}"
+        )
+
+# Example 2: Using Tuple[bool, Any] return type (original method)
+def validate_length_tuple(output: TaskOutput) -> Tuple[bool, Any]:
+    """Ensure output is between 100-500 characters using tuple"""
+    text = output.raw if hasattr(output, 'raw') else str(output)
+    length = len(text)
+    
+    if 100 <= length <= 500:
+        return True, output
+    else:
+        return False, f"Output must be 100-500 chars, got {length}"
+
+# Tool function
+def get_url_context(url):
+    """Fetch and extract content from a URL"""
+    downloaded = trafilatura.fetch_url(url)
+    if not downloaded:
+        return "Sorry, I couldn't fetch the content from that URL."
+
+    extracted = trafilatura.extract(
+        downloaded,
+        include_comments=False,
+        include_links=True,
+        output_format='json',
+        with_metadata=True,
+        url=url
+    )
+
+    if not extracted:
+        return "Sorry, I couldn't extract readable content from that page."
+
+    return extracted  # returns JSON string
+
+# Create agent with FIXED tools parameter (must be a list!)
+agent = Agent(
+    name="Content Summarizer",
+    role="Content Analysis Expert",
+    goal="Summarize web content concisely",
+    instructions="You are a helpful assistant that summarizes web content",
+    llm="gemini/gemini-2.5-flash-lite-preview-06-17",
+    self_reflect=False,
+    verbose=True,
+    tools=[get_url_context]  # FIX: tools must be a list, not a single function
+)
+
+# Create task with GuardrailResult guardrail
+task_with_guardrailresult = Task(
+    name="summarise article with GuardrailResult",
+    description="get the context of this url: https://blog.google/technology/ai/dolphingemma/ and produce a summary below 500 characters",
+    agent=agent,
+    guardrail=validate_length_guardrailresult,  # Using GuardrailResult
+    expected_output="summary of the article below 500 characters",
+    max_retries=3  # Will retry up to 3 times if guardrail fails
+)
+
+# Alternative: Create task with tuple guardrail
+task_with_tuple = Task(
+    name="summarise article with tuple",
+    description="get the context of this url: https://blog.google/technology/ai/dolphingemma/ and produce a summary below 500 characters",
+    agent=agent,
+    guardrail=validate_length_tuple,  # Using Tuple[bool, Any]
+    expected_output="summary of the article below 500 characters",
+    max_retries=3
+)
+
+# Example with string-based LLM guardrail
+task_with_llm_guardrail = Task(
+    name="summarise with LLM guardrail",
+    description="get the context of this url: https://blog.google/technology/ai/dolphingemma/ and produce a summary",
+    agent=agent,
+    guardrail="Ensure the summary is professional, factual, and between 100-500 characters",
+    expected_output="professional summary of the article"
+)
+
+# Run with GuardrailResult example
+print("=== Running with GuardrailResult guardrail ===")
+agents_gr = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task_with_guardrailresult]
+)
+
+# Uncomment to run:
+# result_gr = agents_gr.start()
+
+# Run with Tuple example
+print("\n=== Running with Tuple[bool, Any] guardrail ===")
+agents_tuple = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task_with_tuple]
+)
+
+# Uncomment to run:
+# result_tuple = agents_tuple.start()
+
+# Run with LLM guardrail example
+print("\n=== Running with LLM-based guardrail ===")
+agents_llm = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task_with_llm_guardrail]
+)
+
+# Uncomment to run:
+# result_llm = agents_llm.start()
+
+print("""
+Key fixes applied:
+1. GuardrailResult is now accepted as a valid return type annotation
+2. tools parameter must be a list: tools=[get_url_context] not tools=get_url_context
+3. Both GuardrailResult and Tuple[bool, Any] return types are supported
+4. String-based LLM guardrails are also supported
+
+The guardrail will automatically retry (up to max_retries times) if validation fails.
+""")

examples/python/a2a/a2a-server.py

@@ -0,0 +1,53 @@
+"""
+PraisonAI A2A Server Example
+
+Expose a PraisonAI Agent as an A2A (Agent2Agent) Server.
+This enables other AI agents to discover and communicate with your agent.
+
+Run:
+    uvicorn a2a-server:app --reload
+
+Endpoints:
+    GET /.well-known/agent.json  - Agent Card for discovery
+    GET /status                   - Server status
+"""
+
+from praisonaiagents import Agent, A2A
+from fastapi import FastAPI
+
+# Create an agent with tools
+def search_web(query: str) -> str:
+    """Search the web for information."""
+    return f"Search results for: {query}"
+
+def calculate(expression: str) -> str:
+    """Calculate a mathematical expression."""
+    try:
+        return f"Result: {eval(expression)}"
+    except Exception:
+        return "Invalid expression"
+
+agent = Agent(
+    name="Research Assistant",
+    role="Research Analyst",
+    goal="Help users research topics and answer questions",
+    tools=[search_web, calculate]
+)
+
+# Expose as A2A Server
+a2a = A2A(
+    agent=agent,
+    url="http://localhost:8000/a2a",
+    version="1.0.0"
+)
+
+# Create FastAPI app
+app = FastAPI(
+    title="PraisonAI A2A Server",
+    description="A2A-compatible agent server"
+)
+app.include_router(a2a.get_router())
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

examples/python/agents/MULTI_PROVIDER_README.md

@@ -0,0 +1,259 @@
+# Multi-Provider/Multi-Model Support
+
+PraisonAI now supports intelligent multi-provider and multi-model capabilities, allowing agents to automatically select the most appropriate AI model based on task requirements, cost considerations, and performance needs.
+
+## 🚀 Key Features
+
+### 1. **Automatic Model Selection**
+- Analyzes task complexity and selects the best model
+- Considers cost vs. performance trade-offs
+- Supports fallback mechanisms for reliability
+
+### 2. **Cost Optimization**
+- Routes simple tasks to cheaper models (e.g., gpt-5-nano, Gemini Flash)
+- Reserves expensive models for complex tasks
+- Tracks usage and provides cost estimates
+
+### 3. **Multi-Provider Support**
+- Works with OpenAI, Anthropic, Google, Groq, and more
+- Seamless switching between providers
+- Provider preference settings
+
+### 4. **Flexible Routing Strategies**
+- `auto`: Automatic selection based on task analysis
+- `cost-optimized`: Prioritize cheaper models
+- `performance-optimized`: Prioritize capability
+- `manual`: Use specified model
+
+## 📦 Installation
+
+The multi-provider support is included in the standard installation:
+
+```bash
+pip install praisonaiagents
+```
+
+## 🔧 Basic Usage
+
+### Simple Multi-Model Agent
+
+```python
+from praisonaiagents import Task, PraisonAIAgents
+from praisonaiagents.agent import RouterAgent
+
+# Create a multi-model agent
+agent = RouterAgent(
+    name="Smart Assistant",
+    role="Adaptive AI Assistant",
+    goal="Complete tasks using the most appropriate model",
+    models=["gpt-5-nano", "gpt-5-nano", "claude-3-5-sonnet-20241022"],
+    routing_strategy="auto"  # Automatic model selection
+)
+
+# Create tasks
+simple_task = Task(
+    name="calculate",
+    description="What is 15% of 250?",
+    agent=agent
+)
+
+complex_task = Task(
+    name="analyze",
+    description="Write a Python implementation of the A* pathfinding algorithm",
+    agent=agent
+)
+
+# Run tasks - agent will automatically select appropriate models
+agents = PraisonAIAgents(
+    agents=[agent],
+    tasks=[simple_task, complex_task]
+)
+
+results = agents.start()
+```
+
+### Cost-Optimized Workflow
+
+```python
+from praisonaiagents.llm import ModelRouter
+
+# Create custom router with cost constraints
+router = ModelRouter(
+    cost_threshold=0.005,  # Max $0.005 per 1k tokens
+    preferred_providers=["google", "openai"]
+)
+
+# Create cost-conscious agent
+analyzer = RouterAgent(
+    name="Budget Analyzer",
+    role="Data Analyst",
+    goal="Analyze data efficiently",
+    models={
+        "gemini/gemini-1.5-flash": {},
+        "gpt-5-nano": {},
+        "claude-3-haiku-20240307": {}
+    },
+    model_router=router,
+    routing_strategy="cost-optimized"
+)
+```
+
+## 🎯 Routing Strategies
+
+### Auto Routing (Default)
+Automatically selects models based on:
+- Task complexity analysis
+- Required capabilities (tools, vision, etc.)
+- Context size requirements
+- Cost/performance balance
+
+### Cost-Optimized
+Prioritizes cheaper models while meeting task requirements:
+- Uses lightweight models for simple tasks
+- Only escalates to expensive models when necessary
+- Ideal for high-volume operations
+
+### Performance-Optimized
+Prioritizes model capability:
+- Uses the best available model for the task
+- Ideal for quality-critical applications
+- Less concern for cost
+
+### Manual
+Uses the specified model without routing:
+- Direct control over model selection
+- Useful for testing or specific requirements
+
+## 📊 Model Profiles
+
+The system includes pre-configured profiles for popular models:
+
+| Model | Provider | Best For | Cost/1k tokens |
+|-------|----------|----------|----------------|
+| gpt-5-nano | OpenAI | Simple tasks, speed | $0.00075 |
+| gemini-1.5-flash | Google | Cost-effective, multimodal | $0.000125 |
+| claude-3-haiku | Anthropic | Fast responses | $0.0008 |
+| gpt-5-nano | OpenAI | General purpose | $0.0075 |
+| claude-3-5-sonnet-20241022 | Anthropic | Complex reasoning | $0.009 |
+| deepseek-chat | DeepSeek | Code & math | $0.0014 |
+
+## 🔍 Task Complexity Analysis
+
+The system analyzes tasks to determine complexity:
+
+- **Simple**: Basic calculations, definitions, yes/no questions
+- **Moderate**: Summarization, basic analysis, classification
+- **Complex**: Code generation, algorithm implementation
+- **Very Complex**: Multi-step reasoning, system design
+
+## 📈 Usage Tracking
+
+Track model usage and costs:
+
+```python
+# Get usage report
+report = agent.get_usage_report()
+print(report)
+
+# Output:
+{
+    'agent_name': 'Smart Assistant',
+    'routing_strategy': 'auto',
+    'model_usage': {
+        'gpt-5-nano': {'calls': 5, 'tokens': 1500, 'cost': 0.0011},
+        'gpt-5-nano': {'calls': 2, 'tokens': 3000, 'cost': 0.0225}
+    },
+    'total_cost_estimate': 0.0236,
+    'total_calls': 7
+}
+```
+
+## 🛠️ Custom Model Configuration
+
+Add custom model profiles:
+
+```python
+from praisonaiagents.llm import ModelProfile, TaskComplexity
+
+custom_model = ModelProfile(
+    name="custom-model",
+    provider="custom",
+    complexity_range=(TaskComplexity.SIMPLE, TaskComplexity.MODERATE),
+    cost_per_1k_tokens=0.002,
+    strengths=["domain-specific"],
+    capabilities=["text"],
+    context_window=32000
+)
+
+router = ModelRouter(models=[custom_model])
+```
+
+## 🔗 Integration with AutoAgents
+
+Works seamlessly with AutoAgents:
+
+```python
+from praisonaiagents.agents import AutoAgents
+
+# Create auto agents
+auto = AutoAgents(
+    instructions="Analyze market trends and create a report",
+    max_agents=3
+)
+
+# Convert to multi-model agents
+for i, agent in enumerate(auto.agents):
+    auto.agents[i] = RouterAgent(
+        name=agent.name,
+        role=agent.role,
+        goal=agent.goal,
+        models=["gpt-5-nano", "gpt-5-nano", "claude-3-5-sonnet"],
+        routing_strategy="auto"
+    )
+
+results = auto.start()
+```
+
+## 🌟 Best Practices
+
+1. **Start with Auto Routing**: Let the system learn your needs
+2. **Monitor Costs**: Use usage reports to optimize
+3. **Set Cost Thresholds**: Prevent unexpected expenses
+4. **Use Appropriate Models**: Don't use GPT-4 for simple math
+5. **Leverage Fallbacks**: Configure fallback models for reliability
+
+## 🔐 Environment Variables
+
+Set API keys for each provider:
+
+```bash
+export OPENAI_API_KEY="sk-..."
+export ANTHROPIC_API_KEY="sk-ant-..."
+export GEMINI_API_KEY="..."
+export GROQ_API_KEY="..."
+```
+
+## 🤝 Contributing
+
+The multi-provider system is extensible. To add new models:
+
+1. Add model profile to `ModelRouter.DEFAULT_MODELS`
+2. Ensure the provider is supported by LiteLLM
+3. Test with various task complexities
+
+## 📚 Examples
+
+See the complete example in `examples/python/agents/multi-provider-agent.py` for:
+- Auto-routing examples
+- Cost-optimized workflows
+- Performance-optimized agents
+- Custom routing logic
+- Integration patterns
+
+## 🎉 Benefits
+
+- **Cost Savings**: Reduce API costs by 50-80%
+- **Better Performance**: Use the right tool for each job
+- **Flexibility**: Switch providers without code changes
+- **Reliability**: Automatic fallbacks and error handling
+- **Transparency**: Track usage and costs

examples/python/agents/autoagents-hierarchical-generation.py

@@ -0,0 +1,73 @@
+"""
+AutoAgents Hierarchical Generation Example
+
+This example demonstrates hierarchical agent patterns using PraisonAI
+for structured task delegation and coordinated workflows.
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import internet_search
+
+print("=== AutoAgents Hierarchical Generation Example ===\n")
+
+# Create manager agent for hierarchical coordination
+manager_agent = Agent(
+    name="Project Manager",
+    role="Project Coordinator",
+    goal="Coordinate hierarchical task execution and manage team workflow",
+    backstory="Experienced manager who excels at breaking down complex projects and coordinating teams",
+    tools=[internet_search],
+    allow_delegation=True,
+    verbose=True
+)
+
+# Create specialist agent for execution
+research_agent = Agent(
+    name="Research Specialist", 
+    role="Market Research Analyst",
+    goal="Conduct thorough market research and analysis",
+    backstory="Expert researcher skilled in market analysis and competitive intelligence",
+    tools=[internet_search],
+    verbose=True
+)
+
+# Hierarchical task structure
+planning_task = Task(
+    description="""Plan a comprehensive market research project for electric vehicles:
+    1. Define research scope and objectives
+    2. Identify key research areas and methodologies
+    3. Create task breakdown structure
+    4. Set deliverable requirements for execution team
+    
+    Prepare clear instructions for the research specialist.""",
+    expected_output="Detailed project plan with clear research instructions",
+    agent=manager_agent
+)
+
+execution_task = Task(
+    description="""Execute the market research plan:
+    1. Follow the research plan from the project manager
+    2. Conduct comprehensive market analysis
+    3. Gather competitive intelligence and market data
+    4. Prepare detailed findings report
+    
+    Use the planning guidance to ensure complete coverage.""",
+    expected_output="Comprehensive market research report with findings",
+    agent=research_agent,
+    context=[planning_task]
+)
+
+# Run hierarchical workflow
+agents_system = PraisonAIAgents(
+    agents=[manager_agent, research_agent],
+    tasks=[planning_task, execution_task],
+    process="sequential",
+    verbose=True
+)
+
+print("Starting hierarchical agent generation...")
+result = agents_system.start()
+
+print(f"\nHierarchical Result: {result[:200]}...")
+print("\n✅ AutoAgents hierarchical generation complete!")
+print("Demonstrated coordinated hierarchical workflow between manager and specialist agents.")

examples/python/agents/autoagents_workflow_patterns.py

@@ -0,0 +1,132 @@
+"""
+AutoAgents Workflow Patterns Example
+
+This example demonstrates the new workflow auto-generation features:
+- Dynamic agent count based on task complexity
+- Multiple workflow patterns (sequential, parallel, routing, orchestrator-workers, evaluator-optimizer)
+- Pattern recommendation based on task keywords
+
+Documentation: https://docs.praison.ai/features/autoagents
+CLI Reference: https://docs.praison.ai/nocode/auto
+"""
+
+from praisonai.auto import AutoGenerator, WorkflowAutoGenerator
+import os
+import tempfile
+
+# Ensure API key is set
+if not os.environ.get("OPENAI_API_KEY"):
+    print("Please set OPENAI_API_KEY environment variable")
+    exit(1)
+
+print("=" * 60)
+print("AutoAgents Workflow Patterns Demo")
+print("=" * 60)
+
+# =============================================================================
+# Example 1: Dynamic Agent Count (Simple vs Complex Tasks)
+# =============================================================================
+print("\n📊 Example 1: Dynamic Agent Count")
+print("-" * 40)
+
+# Simple task - should create 1-2 agents
+with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+    simple_file = f.name
+
+simple_generator = AutoGenerator(
+    topic="Write a haiku about spring",
+    agent_file=simple_file,
+    framework="praisonai"
+)
+
+print("Simple task: 'Write a haiku about spring'")
+result = simple_generator.generate()
+print(f"Generated: {result}")
+
+# Complex task - should create 3-4 agents
+with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+    complex_file = f.name
+
+complex_generator = AutoGenerator(
+    topic="Research AI trends, analyze market data, write a comprehensive report with executive summary",
+    agent_file=complex_file,
+    framework="praisonai"
+)
+
+print("\nComplex task: 'Research AI trends, analyze market data...'")
+result = complex_generator.generate()
+print(f"Generated: {result}")
+
+# =============================================================================
+# Example 2: Pattern Recommendation
+# =============================================================================
+print("\n🎯 Example 2: Pattern Recommendation")
+print("-" * 40)
+
+test_tasks = [
+    ("Write a blog post", "sequential"),
+    ("Research from multiple sources simultaneously", "parallel"),
+    ("Classify and route customer requests", "routing"),
+    ("Comprehensive analysis and break down the problem", "orchestrator-workers"),
+    ("Refine and improve content quality", "evaluator-optimizer"),
+]
+
+for task, expected in test_tasks:
+    generator = WorkflowAutoGenerator(topic=task)
+    recommended = generator.recommend_pattern()
+    status = "✅" if recommended == expected else "⚠️"
+    print(f"{status} Task: '{task[:40]}...'")
+    print(f"   Recommended: {recommended}")
+
+# =============================================================================
+# Example 3: Generate Workflow with Specific Pattern
+# =============================================================================
+print("\n🔄 Example 3: Generate Workflows with Patterns")
+print("-" * 40)
+
+patterns = ["sequential", "parallel", "orchestrator-workers", "evaluator-optimizer"]
+
+for pattern in patterns:
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+        workflow_file = f.name
+    
+    generator = WorkflowAutoGenerator(
+        topic="Create a market analysis report",
+        workflow_file=workflow_file
+    )
+    
+    print(f"\n📋 Pattern: {pattern}")
+    result = generator.generate(pattern=pattern)
+    print(f"   Generated: {result}")
+    
+    # Read and show structure
+    import yaml
+    with open(result, 'r') as f:
+        data = yaml.safe_load(f)
+    print(f"   Agents: {list(data.get('agents', {}).keys())}")
+    print(f"   Steps: {len(data.get('steps', []))}")
+
+# =============================================================================
+# Example 4: CLI Usage (for reference)
+# =============================================================================
+print("\n💻 Example 4: CLI Commands (for reference)")
+print("-" * 40)
+print("""
+# Auto-generate agents (dynamic count)
+praisonai --auto "Write a haiku about spring"
+
+# Auto-generate workflow with pattern
+praisonai workflow auto "Research and write a report" --pattern sequential
+praisonai workflow auto "Research from multiple sources" --pattern parallel
+praisonai workflow auto "Comprehensive market analysis" --pattern orchestrator-workers
+praisonai workflow auto "Refine content quality" --pattern evaluator-optimizer
+
+# With output file
+praisonai workflow auto "Customer support routing" --pattern routing --output support.yaml
+""")
+
+print("\n" + "=" * 60)
+print("✅ AutoAgents Workflow Patterns Demo Complete!")
+print("=" * 60)
+print("\nDocumentation: https://docs.praison.ai/features/autoagents")
+print("CLI Reference: https://docs.praison.ai/nocode/auto")