feat: upgrade praisonaiagents to 0.0.144 and add MongoDB support

- Removed unnecessary force_shutdown_telemetry() call from basic-agents.py to enhance clarity.
- Updated llm parameter in gemini-sequential.py from "gemini-2.5-pro" to "gemini-2.5-flash" for improved performance.
- Simplified the for loop in realtime-streaming.py by removing the return_generator=True argument, maintaining functionality while improving readability.

These changes aim to enhance code efficiency and maintainability without altering existing functionality.

.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

@@ -72,7 +72,7 @@ jobs:
         with:
           github-token: ${{ secrets.GH_TOKEN }}
           script: |
-            const reviewText = '@claude review if the changes made are as per the requirements';
+            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;
             

.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

.github/workflows/test-comprehensive.yml

@@ -26,6 +26,7 @@ on:
 jobs:
   comprehensive-test:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     strategy:
       matrix:
         python-version: ["3.11"]

.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]

.github/workflows/test-extended.yml

@@ -13,6 +13,7 @@ on:
 jobs:
   test-examples:
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     
     steps:
     - name: Checkout code
@@ -43,6 +44,9 @@ jobs:
         echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
         echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
         echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
+        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]

.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

README.md

@@ -120,6 +120,10 @@ agent.start('Write a movie script about a robot in Mars');
 
 ![PraisonAI CLI Demo](docs/demo/praisonai-cli-demo.gif)
 
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=MervinPraison/PraisonAI&type=Date)](https://docs.praison.ai)
+
 ## AI Agents Flow
 
 ```mermaid
@@ -557,10 +561,6 @@ uv pip install -r pyproject.toml --extra "crewai,autogen"
 - 🖼️ Vision Language Model (VLM) Support
 - 🎙️ Real-time Voice Interaction
 
-## Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=MervinPraison/PraisonAI&type=Date)](https://docs.praison.ai)
-
 ## Video Tutorials
 
 | Topic | Video |

docker/Dockerfile

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     flask \
-    "praisonai>=2.2.60" \
+    "praisonai>=2.2.71" \
     "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.60" \
+    "praisonai>=2.2.71" \
     "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.60" \
+    "praisonai>=2.2.71" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

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.60" \
+    "praisonai>=2.2.71" \
     "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.60`
+- PraisonAI: `>=2.2.71`
 - 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.60" "praisonaiagents==0.0.92"
+RUN pip install "praisonai==2.2.71" "praisonaiagents==0.0.92"
 ```
 
 ## 🌐 Production Deployment

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/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/router-agent-cost-optimization.py

@@ -0,0 +1,82 @@
+"""
+RouterAgent Cost Optimization Example
+
+This example demonstrates how to use RouterAgent for intelligent model selection
+based on cost optimization. The router agent automatically selects the most
+cost-effective model for different types of tasks while maintaining quality.
+
+Features demonstrated:
+- Cost-optimized model routing
+- Automatic model selection based on task complexity
+- Usage tracking and cost monitoring
+- Fallback mechanisms for reliability
+"""
+
+from praisonaiagents import Agent
+from praisonaiagents.agent.router_agent import RouterAgent
+from praisonaiagents.tools import duckduckgo
+
+# Define model options with cost considerations
+# Using different models for different complexity levels
+cheap_model = "gpt-4o-mini"  # For simple tasks
+balanced_model = "gpt-4o"    # For moderate complexity  
+premium_model = "claude-3-5-sonnet-20241022"  # For complex tasks
+
+# Create RouterAgent with cost optimization strategy
+router = RouterAgent(
+    name="CostOptimizedRouter",
+    role="Cost-Efficient Task Router",
+    goal="Route tasks to the most cost-effective model while maintaining quality",
+    backstory="You are a smart router that optimizes for cost-efficiency by selecting appropriate models based on task complexity.",
+    
+    # Model routing strategy - simple tasks to cheap models, complex to premium
+    models=[cheap_model, balanced_model, premium_model],
+    
+    # Routing logic - this could be enhanced with more sophisticated rules
+    instructions="""You are a cost-optimization router. For simple tasks like basic questions, 
+    definitions, or simple calculations, use the cheapest model. For moderate complexity tasks 
+    like writing, analysis, or research, use the balanced model. For complex tasks requiring 
+    deep reasoning, creativity, or specialized knowledge, use the premium model.""",
+    
+    tools=[duckduckgo],
+    verbose=True
+)
+
+# Example tasks of varying complexity levels
+
+# Simple task - should route to cheap model
+print("="*60)
+print("TESTING SIMPLE TASK (should use cheap model)")
+print("="*60)
+simple_result = router.start("What is the capital of France?")
+print(f"Simple task result: {simple_result}")
+
+# Moderate complexity task - should route to balanced model  
+print("\n" + "="*60)
+print("TESTING MODERATE TASK (should use balanced model)")
+print("="*60)
+moderate_result = router.start("Write a brief analysis of renewable energy trends in 2024")
+print(f"Moderate task result: {moderate_result}")
+
+# Complex task - should route to premium model
+print("\n" + "="*60) 
+print("TESTING COMPLEX TASK (should use premium model)")
+print("="*60)
+complex_result = router.start("Conduct a comprehensive strategic analysis of the impact of quantum computing on cybersecurity, including potential vulnerabilities and mitigation strategies")
+print(f"Complex task result: {complex_result}")
+
+# Research task with tool usage - should route appropriately
+print("\n" + "="*60)
+print("TESTING RESEARCH TASK WITH TOOLS")
+print("="*60)
+research_result = router.start("Research and analyze the latest developments in artificial intelligence regulation globally")
+print(f"Research task result: {research_result}")
+
+print("\n" + "="*80)
+print("COST OPTIMIZATION ROUTER DEMONSTRATION COMPLETED")
+print("="*80)
+print("The RouterAgent automatically selected appropriate models based on task complexity:")
+print("- Simple factual questions → Cheaper model (gpt-4o-mini)")  
+print("- Moderate analysis tasks → Balanced model (gpt-4o)")
+print("- Complex strategic analysis → Premium model (claude-3-5-sonnet)")
+print("- This approach optimizes costs while maintaining quality for each task type")

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

@@ -440,7 +440,7 @@ async def generate_research(
         "message": "Report generation queued",
         "created_at": datetime.now().isoformat(),
         "updated_at": datetime.now().isoformat(),
-        "config": request.dict()
+        "config": request.model_dump()
     }
     
     # Create config object

examples/python/concepts/reasoning-extraction.py

@@ -31,7 +31,7 @@ def save_reasoning_chain(chain: ChainOfThought) -> str:
     """Save a chain of thought reasoning to analyze patterns."""
     filename = f"reasoning_{chain.problem[:20].replace(' ', '_')}.json"
     with open(filename, 'w') as f:
-        json.dump(chain.dict(), f, indent=2)
+        json.dump(chain.model_dump(), f, indent=2)
     return f"Reasoning chain saved to {filename}"
 
 # Example 1: Chain of Thought Agent

examples/python/concepts/self-reflection-optimization-patterns.py

@@ -0,0 +1,46 @@
+"""
+Self-Reflection Optimization Patterns Example
+
+This example demonstrates self-reflection capabilities using PraisonAI's
+built-in reflection features for iterative improvement and quality optimization.
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import internet_search
+
+print("=== Self-Reflection Optimization Patterns Example ===\n")
+
+# Create self-reflecting agent with built-in reflection capabilities
+reflection_agent = Agent(
+    name="Self-Reflecting Agent",
+    role="Self-Improving Researcher",
+    goal="Demonstrate self-reflection and iterative improvement patterns",
+    backstory="Expert researcher with strong self-reflection and continuous improvement capabilities",
+    tools=[internet_search],
+    self_reflect=True,
+    min_reflect=2,
+    max_reflect=4,
+    reflect_llm="gpt-4o-mini",
+    verbose=True
+)
+
+# Create task that benefits from self-reflection
+reflection_task = Task(
+    description="""Research and analyze the future of artificial intelligence:
+    1. Investigate current AI trends and breakthrough technologies
+    2. Analyze potential impacts on society and industry
+    3. Provide well-reasoned predictions for the next 5 years
+    4. Ensure analysis is comprehensive, accurate, and well-structured
+    
+    Use self-reflection to improve the quality and completeness of your analysis.""",
+    expected_output="Comprehensive AI future analysis with high quality through self-reflection",
+    agent=reflection_agent
+)
+
+# Run with self-reflection optimization
+print("Starting self-reflection optimization demonstration...")
+result = reflection_agent.execute_task(reflection_task)
+
+print(f"\nSelf-Reflection Result: {result[:200]}...")
+print("\n✅ Self-reflection optimization complete!")
+print("Agent demonstrated iterative improvement through built-in self-reflection capabilities.")

examples/python/custom_tools/example_latency_tracking.py

@@ -130,9 +130,11 @@ def example_mcp_tracking():
             )
             plan = agent.chat("Plan: Search for Python documentation")
         
-        # Track tool usage
+        # Track tool usage (this will now have actual timing)
         with tracker.track("tool_usage", request_id):
-            # Simulate tool execution
+            # Simulate tool execution with realistic timing
+            import time
+            time.sleep(0.1)  # Simulate some work
             tool_result = "Found 5 relevant documentation pages"
         
         # Track LLM generation

examples/python/general/advanced-callback-systems.py

@@ -0,0 +1,59 @@
+"""
+Advanced Callback Systems Example
+
+This example demonstrates callback systems using PraisonAI's built-in
+callback functionality for monitoring agent interactions and tool usage.
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.display_callback import register_display_callback
+from praisonaiagents.tools import internet_search
+
+print("=== Advanced Callback Systems Example ===\n")
+
+# Simple callback function to monitor interactions
+def interaction_callback(data):
+    """Monitor agent interactions"""
+    print(f"📋 Interaction: {data.get('agent_name', 'Unknown')} - {data.get('type', 'unknown')}")
+
+# Simple callback function to monitor tool usage
+def tool_callback(data):
+    """Monitor tool usage"""
+    print(f"🔧 Tool Used: {data.get('agent_name', 'Unknown')} used {data.get('tool_name', 'unknown')}")
+
+# Simple callback function to monitor generation
+def generation_callback(data):
+    """Monitor content generation"""
+    print(f"✍️  Generation: {data.get('agent_name', 'Unknown')} generating content")
+
+# Register callbacks with PraisonAI's callback system
+print("Registering callbacks...")
+register_display_callback('interaction', interaction_callback)
+register_display_callback('tool_call', tool_callback)
+register_display_callback('generating', generation_callback)
+print("✅ Callbacks registered\n")
+
+# Create a research agent with callback monitoring
+research_agent = Agent(
+    name="Research Agent",
+    role="Information Researcher",
+    goal="Research topics and demonstrate callback monitoring",
+    backstory="Expert researcher that demonstrates callback functionality",
+    tools=[internet_search],
+    verbose=True
+)
+
+# Create a simple task
+research_task = Task(
+    description="Research the latest developments in renewable energy technology",
+    expected_output="Brief summary of renewable energy developments",
+    agent=research_agent
+)
+
+# Execute with callback monitoring
+print("Starting research with callback monitoring...")
+result = research_agent.execute_task(research_task)
+
+print(f"\nResearch Result: {result[:200]}...")
+print("\n✅ Callback monitoring demonstration complete!")
+print("Callbacks successfully tracked agent interactions, tool usage, and content generation.")

examples/python/guardrails/comprehensive-guardrails-example.py

@@ -0,0 +1,204 @@
+"""
+Comprehensive Guardrails Example
+
+This example demonstrates both function-based and LLM-based guardrails for validating
+agent outputs and ensuring quality, safety, and compliance.
+
+Features demonstrated:
+- Function-based validation guardrails
+- LLM-based content validation
+- Multiple validation criteria
+- Retry mechanisms with feedback
+- Quality assurance workflows
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.task import TaskOutput
+from typing import Tuple, Any
+import re
+
+# Define function-based guardrails for different validation types
+
+def email_format_guardrail(task_output: TaskOutput) -> Tuple[bool, Any]:
+    """
+    Validates that the output contains properly formatted email addresses.
+    """
+    output_text = str(task_output.raw)
+    
+    # Email regex pattern
+    email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+    emails_found = re.findall(email_pattern, output_text)
+    
+    if emails_found:
+        return True, task_output
+    else:
+        return False, "No valid email addresses found in the output. Please include at least one properly formatted email address."
+
+def word_count_guardrail(task_output: TaskOutput) -> Tuple[bool, Any]:
+    """
+    Validates that the output meets minimum word count requirements.
+    """
+    output_text = str(task_output.raw)
+    word_count = len(output_text.split())
+    
+    min_words = 50  # Minimum required words
+    
+    if word_count >= min_words:
+        return True, task_output
+    else:
+        return False, f"Output too short. Found {word_count} words but need at least {min_words} words. Please provide a more detailed response."
+
+def professional_tone_guardrail(task_output: TaskOutput) -> Tuple[bool, Any]:
+    """
+    Validates that the output maintains a professional tone.
+    """
+    output_text = str(task_output.raw).lower()
+    
+    # Check for unprofessional words/phrases
+    unprofessional_terms = ['stupid', 'dumb', 'sucks', 'terrible', 'awful', 'hate']
+    
+    for term in unprofessional_terms:
+        if term in output_text:
+            return False, f"Output contains unprofessional language ('{term}'). Please revise to maintain a professional tone."
+    
+    return True, task_output
+
+def factual_accuracy_guardrail(task_output: TaskOutput) -> Tuple[bool, Any]:
+    """
+    Validates that the output includes specific factual elements.
+    """
+    output_text = str(task_output.raw).lower()
+    
+    # Check for presence of factual indicators
+    factual_indicators = ['according to', 'research shows', 'studies indicate', 'data suggests', 'evidence']
+    
+    has_factual_backing = any(indicator in output_text for indicator in factual_indicators)
+    
+    if has_factual_backing:
+        return True, task_output
+    else:
+        return False, "Output lacks factual backing. Please include references to research, studies, or data to support your claims."
+
+# Create agents with different guardrail configurations
+
+# Agent with email format validation
+email_agent = Agent(
+    name="EmailAgent",
+    role="Business Communication Specialist",
+    goal="Create professional business communications with proper email formatting",
+    backstory="You are a professional communication specialist who ensures all business correspondence includes proper contact information.",
+    instructions="Always include properly formatted email addresses in your responses."
+)
+
+# Agent with word count validation  
+content_agent = Agent(
+    name="ContentAgent",
+    role="Content Writer",
+    goal="Create detailed, comprehensive content that meets length requirements",
+    backstory="You are a professional content writer who creates detailed, well-researched articles.",
+    instructions="Provide comprehensive, detailed responses with sufficient depth and explanation."
+)
+
+# Agent with professional tone validation
+business_agent = Agent(
+    name="BusinessAgent", 
+    role="Professional Advisor",
+    goal="Provide professional business advice with appropriate tone",
+    backstory="You are a seasoned business advisor who maintains professionalism in all communications.",
+    instructions="Maintain a professional, respectful tone in all communications."
+)
+
+# Agent with factual accuracy validation
+research_agent = Agent(
+    name="ResearchAgent",
+    role="Research Analyst", 
+    goal="Provide well-researched, fact-based analysis",
+    backstory="You are a research analyst who backs all claims with evidence and citations.",
+    instructions="Support all statements with references to research, studies, or credible data sources."
+)
+
+# Create tasks with specific guardrails
+
+# Task with email format guardrail
+email_task = Task(
+    name="email_communication",
+    description="Write a business proposal for a new software project, including contact information",
+    expected_output="Professional business proposal with contact email addresses",
+    agent=email_agent,
+    guardrail=email_format_guardrail,
+    max_retries=3
+)
+
+# Task with word count guardrail
+content_task = Task(
+    name="detailed_analysis", 
+    description="Write an analysis of cloud computing benefits for small businesses",
+    expected_output="Comprehensive analysis of cloud computing benefits (minimum 50 words)",
+    agent=content_agent,
+    guardrail=word_count_guardrail,
+    max_retries=3
+)
+
+# Task with professional tone guardrail
+business_task = Task(
+    name="professional_advice",
+    description="Provide advice on handling difficult client relationships",
+    expected_output="Professional advice maintaining appropriate business tone",
+    agent=business_agent,
+    guardrail=professional_tone_guardrail,
+    max_retries=3
+)
+
+# Task with factual accuracy guardrail
+research_task = Task(
+    name="research_report",
+    description="Analyze the impact of artificial intelligence on job markets",
+    expected_output="Research-backed analysis with citations and evidence",
+    agent=research_agent,
+    guardrail=factual_accuracy_guardrail,
+    max_retries=3
+)
+
+# LLM-based guardrail example
+llm_guardrail_agent = Agent(
+    name="LLMGuardrailAgent",
+    role="Content Quality Validator",
+    goal="Validate content quality using LLM-based assessment",
+    backstory="You are a quality assurance specialist who uses AI to validate content quality.",
+    instructions="Create marketing content that is engaging, accurate, and compliant with advertising standards."
+)
+
+# Task with LLM-based guardrail
+llm_guardrail_task = Task(
+    name="marketing_content",
+    description="Create a marketing email for a new fitness app targeting busy professionals",
+    expected_output="Engaging marketing email that is accurate and compliant",
+    agent=llm_guardrail_agent,
+    
+    # LLM-based guardrail using natural language validation
+    guardrail="Validate that this marketing content is: 1) Factually accurate with no false claims, 2) Compliant with advertising standards (no misleading statements), 3) Engaging and professional in tone, 4) Includes a clear call-to-action. If any criteria are not met, explain what needs to be improved.",
+    max_retries=2
+)
+
+# Execute tasks with guardrails
+agents = PraisonAIAgents(
+    agents=[email_agent, content_agent, business_agent, research_agent, llm_guardrail_agent],
+    tasks=[email_task, content_task, business_task, research_task, llm_guardrail_task],
+    verbose=True
+)
+
+print("="*80)
+print("EXECUTING TASKS WITH COMPREHENSIVE GUARDRAILS")
+print("="*80)
+
+result = agents.start()
+
+print("\n" + "="*80)
+print("GUARDRAILS DEMONSTRATION COMPLETED")
+print("="*80)
+print("This example demonstrated:")
+print("- Function-based validation (email format, word count, tone, factual accuracy)")
+print("- LLM-based content validation using natural language criteria")
+print("- Automatic retry mechanisms with specific feedback")
+print("- Quality assurance workflows for different content types")
+print("- Professional validation standards for business communications")

examples/python/guardrails/production-guardrails-patterns.py

@@ -0,0 +1,65 @@
+"""
+Production Guardrails Patterns Example
+
+This example demonstrates production guardrail patterns using PraisonAI's
+built-in validation and safety mechanisms for secure agent operations.
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import internet_search
+
+print("=== Production Guardrails Patterns Example ===\n")
+
+# Simple guardrail function for content validation
+def content_guardrail(response, context):
+    """Simple content validation guardrail"""
+    if not response or len(response.strip()) < 50:
+        return {
+            "valid": False,
+            "reason": "Response too short for production use",
+            "action": "regenerate"
+        }
+    
+    # Check for sensitive patterns (simplified)
+    sensitive_keywords = ["password", "secret", "private_key", "api_key"]
+    if any(keyword in response.lower() for keyword in sensitive_keywords):
+        return {
+            "valid": False,
+            "reason": "Potential sensitive information detected",
+            "action": "review_and_redact"
+        }
+    
+    return {"valid": True}
+
+# Create production-ready agent with guardrails
+production_agent = Agent(
+    name="Production Agent",
+    role="Production Content Generator",
+    goal="Generate safe, compliant content for production use",
+    backstory="Production-ready agent with built-in safety and compliance checks",
+    tools=[internet_search],
+    guardrail=content_guardrail,
+    max_retries=3,
+    verbose=True
+)
+
+# Create secure task with validation
+secure_task = Task(
+    description="""Create a professional report about renewable energy trends:
+    1. Research current renewable energy market developments
+    2. Include factual data and reliable sources
+    3. Ensure content is production-ready and compliant
+    4. Avoid any sensitive or inappropriate information
+    
+    Focus on creating safe, accurate, professional content.""",
+    expected_output="Professional renewable energy report meeting production standards",
+    agent=production_agent
+)
+
+# Run with guardrail validation
+print("Starting production guardrails demonstration...")
+result = production_agent.execute_task(secure_task)
+
+print(f"\nProduction Result: {result[:200]}...")
+print("\n✅ Production guardrails validation complete!")
+print("Agent demonstrated safe content generation with built-in guardrail validation.")

examples/python/knowledge/advanced-knowledge-management.py

@@ -0,0 +1,194 @@
+"""
+Advanced Knowledge Management Example
+
+This example demonstrates sophisticated knowledge management capabilities including
+advanced chunking strategies, reranking, and intelligent knowledge retrieval.
+
+Features demonstrated:
+- Advanced document chunking strategies
+- Vector store integration with ChromaDB
+- Knowledge-based question answering
+- Intelligent context retrieval
+- Document processing and management
+"""
+
+from praisonaiagents import Agent
+import tempfile
+import os
+
+# Create a sample knowledge document for demonstration
+sample_document = """
+# Artificial Intelligence in Healthcare
+
+## Introduction
+Artificial intelligence (AI) is revolutionizing healthcare by enabling more accurate diagnoses, 
+personalized treatments, and efficient healthcare delivery. This document explores the current 
+applications and future potential of AI in healthcare.
+
+## Current Applications
+
+### Medical Imaging
+AI algorithms, particularly deep learning models, have shown remarkable success in medical imaging:
+- Radiology: AI can detect cancers in mammograms with accuracy matching or exceeding radiologists
+- Ophthalmology: AI systems can diagnose diabetic retinopathy from retinal photographs
+- Pathology: AI assists in analyzing tissue samples for cancer detection
+
+### Drug Discovery
+AI is accelerating drug discovery processes:
+- Molecular design: AI predicts molecular properties and drug-target interactions
+- Clinical trials: AI optimizes patient recruitment and trial design
+- Repurposing: AI identifies new uses for existing drugs
+
+### Predictive Analytics
+Healthcare providers use AI for:
+- Risk stratification: Identifying patients at risk of complications
+- Early warning systems: Detecting deteriorating patient conditions
+- Resource planning: Optimizing staff schedules and equipment allocation
+
+## Challenges and Considerations
+
+### Data Privacy and Security
+Healthcare AI faces significant challenges:
+- Patient data protection and HIPAA compliance
+- Secure data sharing between institutions
+- Consent management for AI applications
+
+### Regulatory Approval
+AI medical devices require:
+- FDA approval for diagnostic tools
+- Clinical validation studies
+- Post-market surveillance
+
+### Ethical Considerations
+Important ethical aspects include:
+- Algorithmic bias and fairness
+- Transparency and explainability
+- Patient autonomy and informed consent
+
+## Future Directions
+
+### Personalized Medicine
+AI will enable:
+- Genomic-based treatment selection
+- Individualized drug dosing
+- Precision diagnostics
+
+### Integrated Healthcare Systems
+Future developments include:
+- AI-powered electronic health records
+- Interoperable AI systems across healthcare networks
+- Real-time decision support systems
+
+## Conclusion
+AI has tremendous potential to transform healthcare, but successful implementation requires
+addressing technical, regulatory, and ethical challenges while maintaining focus on patient safety
+and improved outcomes.
+"""
+
+# Save the sample document to a temporary file
+temp_dir = tempfile.mkdtemp()
+doc_path = os.path.join(temp_dir, "ai_healthcare_guide.txt")
+with open(doc_path, "w") as f:
+    f.write(sample_document)
+
+# Create an agent with advanced knowledge management configuration
+knowledge_agent = Agent(
+    name="AdvancedKnowledgeAgent",
+    role="Healthcare AI Knowledge Expert", 
+    goal="Provide comprehensive answers about AI in healthcare using advanced knowledge retrieval",
+    backstory="You are an expert in healthcare AI with access to comprehensive knowledge bases and advanced retrieval capabilities.",
+    
+    # Advanced knowledge configuration
+    knowledge=[doc_path],
+    knowledge_config={
+        "vector_store": {
+            "provider": "chroma",
+            "collection_name": "healthcare_ai_knowledge"
+        },
+        "chunking": {
+            "strategy": "semantic",  # Advanced semantic chunking
+            "chunk_size": 500,       # Optimal chunk size for retrieval
+            "chunk_overlap": 50,     # Overlap for context preservation
+            "separators": ["\n\n", "\n", ".", "!", "?"]  # Smart separators
+        },
+        "retrieval": {
+            "search_type": "similarity",
+            "k": 5,  # Retrieve top 5 most relevant chunks
+            "score_threshold": 0.7,  # Minimum relevance score
+            "rerank": True  # Enable reranking for better results
+        },
+        "embedding": {
+            "provider": "openai",
+            "model": "text-embedding-3-small",  # Efficient embedding model
+            "dimensions": 1536
+        }
+    },
+    
+    instructions="""You are an expert in healthcare AI. Use the knowledge base to provide 
+    comprehensive, accurate answers. Always cite specific information from the documents 
+    when possible. If the knowledge base doesn't contain sufficient information, clearly 
+    state this and provide general guidance based on your training.""",
+    
+    verbose=True
+)
+
+# Test advanced knowledge retrieval with various question types
+
+# Factual question about specific applications
+print("="*70)
+print("TESTING: Specific factual question about AI applications")
+print("="*70)
+factual_result = knowledge_agent.start(
+    "What are the current applications of AI in medical imaging according to the knowledge base?"
+)
+print(f"Factual query result:\n{factual_result}\n")
+
+# Complex analytical question requiring synthesis
+print("="*70)
+print("TESTING: Complex analytical question requiring synthesis")  
+print("="*70)
+analytical_result = knowledge_agent.start(
+    "What are the main challenges facing AI implementation in healthcare and how do they relate to each other?"
+)
+print(f"Analytical query result:\n{analytical_result}\n")
+
+# Specific detail extraction
+print("="*70)
+print("TESTING: Specific detail extraction")
+print("="*70)
+detail_result = knowledge_agent.start(
+    "What specific regulatory requirements does the document mention for AI medical devices?"
+)
+print(f"Detail extraction result:\n{detail_result}\n")
+
+# Future-oriented question requiring inference
+print("="*70)
+print("TESTING: Future-oriented question requiring inference")
+print("="*70)
+future_result = knowledge_agent.start(
+    "Based on the knowledge base, what integration capabilities will future AI healthcare systems have?"
+)
+print(f"Future-oriented query result:\n{future_result}\n")
+
+# Question about relationships and connections
+print("="*70)
+print("TESTING: Relationship and connection analysis")
+print("="*70)
+relationship_result = knowledge_agent.start(
+    "How do the ethical considerations mentioned relate to the regulatory approval process for AI in healthcare?"
+)
+print(f"Relationship analysis result:\n{relationship_result}\n")
+
+# Clean up temporary files
+import shutil
+shutil.rmtree(temp_dir)
+
+print("="*80)
+print("ADVANCED KNOWLEDGE MANAGEMENT DEMONSTRATION COMPLETED")
+print("="*80)
+print("This example demonstrated:")
+print("- Semantic chunking for better context preservation")
+print("- Advanced retrieval with reranking capabilities")
+print("- Multiple query types with intelligent responses")
+print("- Knowledge base integration with vector search")
+print("- Configurable embedding and retrieval parameters")

examples/python/memory/advanced-graph-memory-integration.py

@@ -0,0 +1,75 @@
+"""
+Advanced Graph Memory Integration Example
+
+This example demonstrates graph memory capabilities with PraisonAI agents
+for knowledge graph construction and relationship-aware memory retrieval.
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import internet_search
+
+print("=== Advanced Graph Memory Integration Example ===\n")
+
+# Configure simple graph memory
+memory_config = {
+    "provider": "mem0",
+    "config": {
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "path": ".praison/graph_memory"
+            }
+        }
+    }
+}
+
+# Create knowledge builder agent with graph memory
+knowledge_agent = Agent(
+    name="Knowledge Agent",
+    role="Knowledge Graph Builder", 
+    goal="Build and retrieve from knowledge graphs",
+    backstory="Expert at creating structured knowledge and finding relationships",
+    tools=[internet_search],
+    memory=True,
+    verbose=True
+)
+
+# Task to build knowledge graph about AI companies
+build_task = Task(
+    description="""Research and store information about major AI companies and their relationships:
+    1. OpenAI - products like GPT-4, ChatGPT, leadership, partnerships
+    2. Anthropic - Claude AI, safety focus, team
+    3. Relationships between these companies and their technologies
+    
+    Focus on capturing connections and relationships between entities.""",
+    expected_output="Knowledge graph with AI company ecosystem relationships",
+    agent=knowledge_agent
+)
+
+# Task to query the knowledge graph
+query_task = Task(
+    description="""Using the stored knowledge graph, answer:
+    1. What are the main products of each company?
+    2. Who are the key leaders in these companies?
+    3. How do these companies relate to each other?
+    
+    Use relationship-aware memory retrieval.""",
+    expected_output="Analysis using graph memory relationships",
+    agent=knowledge_agent
+)
+
+# Run with graph memory integration
+agents_system = PraisonAIAgents(
+    agents=[knowledge_agent],
+    tasks=[build_task, query_task],
+    memory=True,
+    memory_config=memory_config,
+    verbose=True
+)
+
+print("Starting graph memory demonstration...")
+result = agents_system.start()
+
+print(f"\nGraph Memory Result: {result[:200]}...")
+print("\n✅ Graph memory integration complete!")
+print("Agent built knowledge graph and performed relationship-aware queries.")

examples/python/memory/advanced-memory-search-optimization.py

@@ -0,0 +1,76 @@
+"""
+Advanced Memory Search and Optimization Example
+
+This example demonstrates memory search optimization using PraisonAI's
+built-in memory capabilities with semantic search and quality filtering.
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import internet_search
+
+print("=== Advanced Memory Search and Optimization Example ===\n")
+
+# Configure optimized memory settings
+memory_config = {
+    "provider": "mem0",
+    "config": {
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "path": ".praison/optimized_memory"
+            }
+        }
+    }
+}
+
+# Create research agent with optimized memory
+research_agent = Agent(
+    name="Memory Research Agent",
+    role="Information Researcher with Memory Optimization",
+    goal="Research and demonstrate optimized memory search patterns",
+    backstory="Expert at storing and retrieving information efficiently with memory optimization",
+    tools=[internet_search],
+    memory=True,
+    verbose=True
+)
+
+# Task to build searchable memory
+build_memory_task = Task(
+    description="""Research and store information about these topics for later search:
+    1. Artificial intelligence market trends and growth data
+    2. Machine learning technologies and applications
+    3. Tech industry partnerships and investments
+    4. Cloud computing adoption statistics
+    
+    Store detailed information that can be searched later.""",
+    expected_output="Comprehensive research stored in optimized memory",
+    agent=research_agent
+)
+
+# Task to demonstrate memory search optimization
+search_task = Task(
+    description="""Using the stored memory, perform optimized searches for:
+    1. "AI market growth trends" - find relevant stored information
+    2. "technology partnerships" - retrieve partnership data
+    3. "cloud adoption statistics" - search for cloud computing info
+    
+    Demonstrate efficient memory retrieval and search optimization.""",
+    expected_output="Results from optimized memory searches",
+    agent=research_agent
+)
+
+# Run with memory optimization
+agents_system = PraisonAIAgents(
+    agents=[research_agent],
+    tasks=[build_memory_task, search_task],
+    memory=True,
+    memory_config=memory_config,
+    verbose=True
+)
+
+print("Starting memory search optimization demonstration...")
+result = agents_system.start()
+
+print(f"\nMemory Search Result: {result[:200]}...")
+print("\n✅ Memory search optimization complete!")
+print("Agent demonstrated efficient memory storage and optimized search retrieval.")

examples/python/models/claude/claude_creative_designer_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a creative designer AI agent. "
+                "Help users with graphic design concepts, branding strategies, "
+                "visual communication, and creative problem-solving. Provide guidance "
+                "on design principles, color theory, typography, and user experience.",
+    llm="anthropic/claude-3-5-sonnet-20241022"
+)
+
+response = agent.start("Hello! I'm your creative designer assistant. "
+                      "How can I help you with your design projects today?") 

examples/python/models/claude/claude_educational_tutor_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are an educational tutor AI agent. "
+                "Help students learn various subjects, explain complex concepts, "
+                "provide step-by-step solutions, and create personalized learning "
+                "materials for different educational levels.",
+    llm="anthropic/claude-3-5-sonnet-20241022"
+)
+
+response = agent.start("Hello! I'm your educational tutor assistant. "
+                      "How can I help you learn today?") 

examples/python/models/claude/claude_financial_advisor_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a financial advisor AI agent. "
+                "Help users understand financial concepts, analyze investment opportunities, "
+                "and provide guidance on personal finance, budgeting, and financial planning. "
+                "Note: This is for educational purposes only, not financial advice.",
+    llm="anthropic/claude-3-5-sonnet-20241022"
+)
+
+response = agent.start("Hello! I'm your financial advisor assistant. "
+                      "How can I help you understand financial concepts today?") 

examples/python/models/claude/claude_legal_advisor_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a legal advisor AI agent. "
+                "Help users understand legal concepts, review contracts, "
+                "analyze legal documents, and provide guidance on compliance "
+                "and regulatory requirements. Note: This is for educational purposes only.",
+    llm="anthropic/claude-3-5-sonnet-20241022"
+)
+
+response = agent.start("Hello! I'm your legal advisor assistant. "
+                      "How can I help you understand legal concepts today?") 

examples/python/models/claude/claude_medical_researcher_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a medical research AI agent. "
+                "Help users understand medical concepts, analyze research papers, "
+                "and provide insights on healthcare trends and developments. "
+                "Note: This is for educational purposes only, not medical advice.",
+    llm="anthropic/claude-3-5-sonnet-20241022"
+)
+
+response = agent.start("Hello! I'm your medical research assistant. "
+                      "How can I help you understand medical concepts today?") 

examples/python/models/googlegemini/any-llm-agents-async.py

@@ -1,18 +1,12 @@
 import asyncio
 from praisonaiagents import Agent
 
-async def main():
-    agent = Agent(
-        instructions="You are a helpful assistant",
-        llm="gemini/gemini-1.5-flash-8b",
-        self_reflect=True,
-        verbose=True
-    )
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="gemini/gemini-1.5-flash-8b",
+    self_reflect=True,
+    verbose=True
+)
 
-    # Use achat instead of start/chat for async operation
-    response = await agent.achat("Why sky is Blue in 1000 words?")
-    print(response)
-
-if __name__ == "__main__":
-    # Run the async main function
-    asyncio.run(main())
+# Use achat instead of start/chat for async operation
+response = asyncio.run(agent.achat("Why sky is Blue in 1000 words?"))

examples/python/models/gpt/gpt_cybersecurity_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a cybersecurity AI agent. "
+                "Help users understand security concepts, analyze security threats, "
+                "and provide guidance on security best practices, risk assessment, "
+                "and security architecture design.",
+    llm="openai/gpt-4o"
+)
+
+response = agent.start("Hello! I'm your cybersecurity assistant. "
+                      "How can I help you with security concepts today?") 

examples/python/models/gpt/gpt_data_engineer_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a data engineer AI agent. "
+                "Help users design data pipelines, optimize database performance, "
+                "create ETL processes, and provide guidance on data architecture, "
+                "data modeling, and big data technologies.",
+    llm="openai/gpt-4o"
+)
+
+response = agent.start("Hello! I'm your data engineer assistant. "
+                      "How can I help you with your data engineering projects today?") 

examples/python/models/gpt/gpt_marketing_strategist_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a marketing strategist AI agent. "
+                "Help users develop marketing strategies, analyze market trends, "
+                "create campaign plans, and provide guidance on digital marketing, "
+                "brand positioning, and customer acquisition strategies.",
+    llm="openai/gpt-4o"
+)
+
+response = agent.start("Hello! I'm your marketing strategist assistant. "
+                      "How can I help you with your marketing strategy today?") 

examples/python/models/gpt/gpt_product_manager_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a product manager AI agent. "
+                "Help users with product strategy, feature prioritization, "
+                "user research analysis, and product roadmap planning. Provide "
+                "guidance on market analysis, competitive positioning, and user experience.",
+    llm="openai/gpt-4o"
+)
+
+response = agent.start("Hello! I'm your product manager assistant. "
+                      "How can I help you with your product strategy today?") 

examples/python/models/gpt/gpt_software_architect_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a software architect AI agent. "
+                "Help users design software systems, create architecture diagrams, "
+                "plan system integrations, and provide guidance on scalability, "
+                "security, and best practices for software development.",
+    llm="openai/gpt-4o"
+)
+
+response = agent.start("Hello! I'm your software architect assistant. "
+                      "How can I help you design your software system today?") 

examples/python/models/grok/grok_basic_example.py

@@ -0,0 +1,30 @@
+"""
+Basic example of using Grok model in PraisonAI
+"""
+
+from praisonaiagents import Agent
+
+# Initialize Agent with Grok model
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="xai/grok-beta",
+)
+
+# Example conversation
+response = agent.start("Hello! Can you explain quantum computing in simple terms?")
+
+# Example with mathematical reasoning
+math_task = """
+Solve this problem step by step:
+If a train travels at 60 mph for 2.5 hours, how far does it travel?
+"""
+
+response = agent.start(math_task)
+
+# Example with creative writing
+creative_task = """
+Write a short story about a robot learning to paint.
+Make it engaging and about 100 words.
+"""
+
+response = agent.start(creative_task) 

examples/python/models/groq/groq_crisis_management_communication_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a crisis management and communication AI agent. "
+                "Help users develop crisis communication strategies, "
+                "manage reputation during difficult situations, and create effective messaging. "
+                "Provide guidance on crisis response planning, stakeholder communication, "
+                "media relations during crises, and reputation recovery strategies.",
+    llm="groq/llama3.1-8b-instant"
+)
+
+response = agent.start("Hello! I'm your crisis management and communication assistant. "
+                      "How can I help you develop effective crisis communication "
+                      "strategies and manage difficult situations today?") 

examples/python/models/groq/groq_digital_marketing_seo_optimization_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a digital marketing and SEO optimization AI agent. "
+                "Help users develop digital marketing strategies, optimize for search engines, "
+                "and improve online visibility. Provide guidance on SEO best practices, "
+                "content marketing, social media strategies, PPC campaigns, "
+                "and analytics interpretation for better ROI.",
+    llm="groq/llama3.1-8b-instant"
+)
+
+response = agent.start("Hello! I'm your digital marketing and SEO optimization assistant. "
+                      "How can I help you improve your online presence, "
+                      "optimize for search engines, or develop marketing strategies today?") 

examples/python/models/groq/groq_environmental_impact_assessment_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are an environmental impact assessment AI agent. "
+                "Help users evaluate environmental impacts of projects, "
+                "develop sustainability strategies, and ensure compliance with environmental regulations. "
+                "Provide guidance on environmental risk assessment, sustainability reporting, "
+                "carbon footprint analysis, and green technology implementation.",
+    llm="groq/llama3.1-8b-instant"
+)
+
+response = agent.start("Hello! I'm your environmental impact assessment assistant. "
+                      "How can I help you evaluate environmental impacts, "
+                      "develop sustainability strategies, or ensure compliance today?") 

examples/python/models/groq/groq_event_planning_management_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are an event planning and management AI agent. "
+                "Help users plan, organize, and manage successful events of all types. "
+                "Provide guidance on venue selection, budgeting, vendor coordination, "
+                "timeline management, marketing strategies, and post-event analysis. "
+                "Assist with both virtual and in-person event planning.",
+    llm="groq/llama3.1-8b-instant"
+)
+
+response = agent.start("Hello! I'm your event planning and management assistant. "
+                      "How can I help you plan and organize your next successful "
+                      "event today?") 

examples/python/models/groq/groq_healthcare_medical_research_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a healthcare and medical research AI agent. "
+                "Help users with medical research, healthcare insights, "
+                "and understanding complex medical information. Provide guidance on medical literature review, "
+                "healthcare trends analysis, patient care strategies, "
+                "and medical technology advancements for better healthcare outcomes.",
+    llm="groq/llama3.1-8b-instant"
+)
+
+response = agent.start("Hello! I'm your healthcare and medical research assistant. "
+                      "How can I help you with medical research, healthcare insights, "
+                      "or understanding complex medical information today?") 

examples/python/models/groq/groq_language_learning_translation_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a language learning and translation AI agent. "
+                "Help users learn new languages, translate content accurately, "
+                "and understand cultural nuances. Provide guidance on language learning strategies, "
+                "grammar explanations, vocabulary building, pronunciation, "
+                "and cultural context for effective communication.",
+    llm="groq/llama3.1-8b-instant"
+)
+
+response = agent.start("Hello! I'm your language learning and translation assistant. "
+                      "How can I help you learn new languages, translate content, "
+                      "or understand cultural nuances today?") 

examples/python/models/groq/groq_patent_research_innovation_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a patent research and innovation AI agent. "
+                "Help users conduct patent research, analyze intellectual property, "
+                "identify innovation opportunities, and navigate patent filing processes. "
+                "Provide guidance on patent searches, prior art analysis, "
+                "innovation strategy, IP protection, and technology landscape assessment.",
+    llm="groq/llama3.1-8b-instant"
+)
+
+response = agent.start("Hello! I'm your patent research and innovation assistant. "
+                      "How can I help you with patent research, innovation strategy, "
+                      "and intellectual property protection today?") 

examples/python/models/groq/groq_personal_branding_pr_agent.py

@@ -0,0 +1,19 @@
+"""
+Personal Branding & PR Agent using Groq
+Specialized agent for managing personal brand and public relations
+"""
+
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a personal branding and PR AI agent. "
+                "Help users build their personal brand, manage public relations, "
+                "create compelling content strategies, and enhance their online presence. "
+                "Provide guidance on social media management, content creation, "
+                "media relations, reputation management, and brand positioning.",
+    llm="groq/llama3.1-8b-instant"
+)
+
+response = agent.start("Hello! I'm your personal branding and PR assistant. "
+                      "How can I help you build your personal brand and "
+                      "manage your public relations today?") 

examples/python/models/groq/groq_product_development_innovation_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a product development and innovation AI agent. "
+                "Help users develop new products, improve existing ones, "
+                "and drive innovation in their business. Provide guidance on product strategy, "
+                "market research, user experience design, prototyping, "
+                "and innovation management for successful product launches.",
+    llm="groq/llama3.1-8b-instant"
+)
+
+response = agent.start("Hello! I'm your product development and innovation assistant. "
+                      "How can I help you develop new products, improve existing ones, "
+                      "or drive innovation in your business today?") 

examples/python/models/groq/groq_supply_chain_optimization_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a supply chain optimization AI agent. "
+                "Help users optimize their supply chain operations, "
+                "improve logistics efficiency, reduce costs, and enhance inventory management. "
+                "Provide guidance on demand forecasting, supplier management, "
+                "warehouse optimization, transportation planning, and risk mitigation.",
+    llm="groq/llama3.1-8b-instant"
+)
+
+response = agent.start("Hello! I'm your supply chain optimization assistant. "
+                      "How can I help you optimize your supply chain operations "
+                      "and improve your logistics efficiency today?") 

examples/python/models/kimi/kimi_aerospace_engineering_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are an aerospace engineering AI agent. "
+                "Help users understand aerospace engineering concepts, "
+                "aircraft design, and space technology. Provide guidance on "
+                "aerodynamics, propulsion systems, materials science, "
+                "and satellite technology.",
+    llm="openrouter/moonshotai/kimi-k2"
+)
+
+response = agent.start("Hello! I'm your aerospace engineering assistant. "
+                      "How can I help you with aerospace engineering "
+                      "and space technology today?") 

examples/python/models/kimi/kimi_bioinformatics_genomics_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a bioinformatics and genomics AI agent. "
+                "Help users understand bioinformatics, genomics, "
+                "and computational biology. Provide guidance on "
+                "DNA sequence analysis, protein structure prediction, "
+                "genetic algorithms, and biological data mining.",
+    llm="openrouter/moonshotai/kimi-k2"
+)
+
+response = agent.start("Hello! I'm your bioinformatics and genomics assistant. "
+                      "How can I help you with bioinformatics "
+                      "and genomics research today?") 

examples/python/models/kimi/kimi_blockchain_defi_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a blockchain and DeFi AI agent. "
+                "Help users understand blockchain technology, "
+                "decentralized finance, and cryptocurrency. Provide guidance on "
+                "smart contract development, DeFi protocols, "
+                "tokenomics, and blockchain security.",
+    llm="openrouter/moonshotai/kimi-k2"
+)
+
+response = agent.start("Hello! I'm your blockchain and DeFi assistant. "
+                      "How can I help you explore blockchain technology "
+                      "and decentralized finance today?") 

examples/python/models/kimi/kimi_energy_renewables_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are an energy and renewables AI agent. "
+                "Help users understand renewable energy technologies, "
+                "energy systems, and sustainability. Provide guidance on "
+                "solar power, wind energy, energy storage, "
+                "and green technology solutions.",
+    llm="openrouter/moonshotai/kimi-k2"
+)
+
+response = agent.start("Hello! I'm your energy and renewables assistant. "
+                      "How can I help you with renewable energy "
+                      "and sustainability today?") 

examples/python/models/kimi/kimi_iot_smart_cities_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are an IoT and smart cities AI agent. "
+                "Help users understand Internet of Things, smart city "
+                "technologies, and connected systems. Provide guidance on "
+                "IoT device integration, smart infrastructure, "
+                "sensor networks, and urban technology solutions.",
+    llm="openrouter/moonshotai/kimi-k2"
+)
+
+response = agent.start("Hello! I'm your IoT and smart cities assistant. "
+                      "How can I help you with IoT and smart city "
+                      "technologies today?") 

examples/python/models/kimi/kimi_metaverse_vr_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a metaverse and virtual reality AI agent. "
+                "Help users understand metaverse concepts, VR development, "
+                "and immersive technologies. Provide guidance on "
+                "3D modeling, VR programming, digital twins, "
+                "and virtual world design.",
+    llm="openrouter/moonshotai/kimi-k2"
+)
+
+response = agent.start("Hello! I'm your metaverse and VR assistant. "
+                      "How can I help you explore the metaverse "
+                      "and virtual reality today?") 

examples/python/models/kimi/kimi_nanotechnology_materials_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a nanotechnology and materials AI agent. "
+                "Help users understand nanotechnology, advanced materials, "
+                "and material science. Provide guidance on "
+                "nanomaterials, material properties, fabrication techniques, "
+                "and applications in various industries.",
+    llm="openrouter/moonshotai/kimi-k2"
+)
+
+response = agent.start("Hello! I'm your nanotechnology and materials assistant. "
+                      "How can I help you with nanotechnology "
+                      "and materials science today?") 

examples/python/models/kimi/kimi_quantum_ai_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a quantum AI agent. "
+                "Help users understand quantum artificial intelligence, "
+                "quantum machine learning, and quantum neural networks. "
+                "Provide guidance on quantum algorithms for AI, "
+                "quantum optimization, and hybrid quantum-classical systems.",
+    llm="openrouter/moonshotai/kimi-k2"
+)
+
+response = agent.start("Hello! I'm your quantum AI assistant. "
+                      "How can I help you explore quantum artificial "
+                      "intelligence today?") 

examples/python/models/kimi/kimi_quantum_computing_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a quantum computing AI agent. "
+                "Help users understand quantum computing concepts, "
+                "quantum algorithms, and quantum programming. Provide guidance on "
+                "quantum circuit design, quantum error correction, "
+                "quantum machine learning, and quantum cryptography.",
+    llm="openrouter/moonshotai/kimi-k2"
+)
+
+response = agent.start("Hello! I'm your quantum computing assistant. "
+                      "How can I help you explore quantum computing "
+                      "and quantum programming today?") 

examples/python/models/kimi/kimi_robotics_automation_agent.py

@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a robotics and automation AI agent. "
+                "Help users understand robotics, automation systems, "
+                "and industrial applications. Provide guidance on "
+                "robot programming, automation workflows, "
+                "sensor integration, and robotic process automation.",
+    llm="openrouter/moonshotai/kimi-k2"
+)
+
+response = agent.start("Hello! I'm your robotics and automation assistant. "
+                      "How can I help you with robotics and "
+                      "automation systems today?") 

examples/python/models/llama/llama_business_analyst_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a business analyst AI agent. "
+                "Help users analyze business performance, market trends, "
+                "competitive landscape, and strategic opportunities. Provide insights "
+                "on business metrics, financial analysis, and growth strategies.",
+    llm="meta-llama/Llama-3.1-8B-Instruct"
+)
+
+response = agent.start("Hello! I'm your business analyst assistant. "
+                      "How can I help you analyze your business data and strategies today?") 

examples/python/models/llama/llama_code_review_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a code review AI agent. "
+                "Help developers review code for best practices, security vulnerabilities, "
+                "performance issues, and maintainability. Provide constructive feedback "
+                "and suggest improvements for code quality and efficiency.",
+    llm="meta-llama/Llama-3.1-8B-Instruct"
+)
+
+response = agent.start("Hello! I'm your code review assistant. "
+                      "How can I help you improve your code quality today?") 

examples/python/models/llama/llama_content_writer_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a content writing AI agent. "
+                "Help users create engaging blog posts, articles, marketing copy, "
+                "and social media content. Provide guidance on SEO optimization, "
+                "content structure, tone adjustment, and audience targeting.",
+    llm="meta-llama/Llama-3.1-8B-Instruct"
+)
+
+response = agent.start("Hello! I'm your content writing assistant. "
+                      "How can I help you create compelling content today?") 

examples/python/models/llama/llama_data_science_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a data science AI agent. "
+                "Help users with data analysis, machine learning model development, "
+                "statistical analysis, and data visualization. Provide guidance on "
+                "data preprocessing, feature engineering, model selection, and evaluation.",
+    llm="meta-llama/Llama-3.1-8B-Instruct"
+)
+
+response = agent.start("Hello! I'm your data science assistant. "
+                      "How can I help you with your data analysis and machine learning projects today?") 

examples/python/models/llama/llama_research_assistant_agent.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a research assistant AI agent. "
+                "Help users conduct comprehensive research on various topics, "
+                "analyze academic papers, synthesize information, and provide "
+                "evidence-based insights and recommendations.",
+    llm="meta-llama/Llama-3.1-8B-Instruct"
+)
+
+response = agent.start("Hello! I'm your research assistant. "
+                      "How can I help you with your research project today?")