Merge branch 'main' of https://github.com/MervinPraison/PraisonAI

feat: Add Notion_Workspace_Assistant notebook

.github/workflows/claude.yml

@@ -88,9 +88,9 @@ jobs:
               core.setOutput('should-post', true); // If we can't check, proceed with posting
             }
 
-      - name: Wait 20 seconds before posting comment
+      - name: Wait 30 seconds before posting comment
         if: steps.check-comment.outputs.should-post == 'true'
-        run: sleep 20
+        run: sleep 30
 
       - name: Post review comment
         if: steps.check-comment.outputs.should-post == 'true'

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

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/python/memory/gemini-embedding-example.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""
+Example: Using Gemini Embedding Models with PraisonAI Memory
+
+This example demonstrates how to configure PraisonAI to use Google's Gemini
+embedding models for memory storage and retrieval, as requested in issue #870.
+
+Supported Gemini embedding models:
+- gemini-embedding-exp-03-07 (experimental)
+- text-embedding-004 (stable)
+
+Prerequisites:
+1. Install praisonaiagents with memory support:
+   pip install "praisonaiagents[memory]"
+
+2. Set your Google API key:
+   export GOOGLE_API_KEY='your-api-key'
+
+3. Ensure litellm is installed (comes with praisonaiagents)
+"""
+
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+def main():
+    """Demonstrate Gemini embedding usage"""
+    
+    # Verify Google API key
+    if not os.environ.get("GOOGLE_API_KEY"):
+        print("Error: GOOGLE_API_KEY environment variable not set")
+        print("Please set it with: export GOOGLE_API_KEY='your-api-key'")
+        return
+    
+    print("=== Gemini Embedding Example ===\n")
+    
+    # Create agents for different tasks
+    researcher = Agent(
+        name="Research Agent",
+        role="Information Researcher",
+        goal="Research and store important information about topics",
+        backstory="Expert at analyzing and documenting information with semantic understanding",
+        llm="gpt-4o-mini"  # Using GPT for chat, Gemini for embeddings
+    )
+    
+    retriever = Agent(
+        name="Retrieval Agent",
+        role="Information Retriever",
+        goal="Retrieve relevant information from memory using semantic search",
+        backstory="Specialist in finding and presenting stored information",
+        llm="gpt-4o-mini"
+    )
+    
+    # Task 1: Store information with semantic meaning
+    store_task = Task(
+        description="""
+        Research and store the following information:
+        1. Gemini is Google's family of multimodal AI models
+        2. Gemini models support text, image, video, and audio understanding
+        3. The embedding models provide semantic representations of text
+        4. Gemini Ultra is the largest and most capable model
+        5. Gemini was announced in December 2023
+        
+        Store each fact with its semantic meaning preserved.
+        """,
+        expected_output="Confirmation that all facts have been stored in memory",
+        agent=researcher
+    )
+    
+    # Task 2: Semantic retrieval test
+    retrieve_task = Task(
+        description="""
+        Using semantic search, find information about:
+        1. Google's AI capabilities
+        2. Multimodal understanding features
+        3. When was Google's latest AI announced
+        
+        Note: Use semantic similarity, not exact keyword matching.
+        """,
+        expected_output="Retrieved information based on semantic meaning",
+        agent=retriever
+    )
+    
+    # Configure with Gemini embeddings
+    # Option 1: Using stable text-embedding-004
+    agents = PraisonAIAgents(
+        agents=[researcher, retriever],
+        tasks=[store_task, retrieve_task],
+        verbose=True,
+        memory=True,
+        embedder={
+            "provider": "gemini",
+            "config": {
+                "model": "text-embedding-004",
+                # Optional: specify task type for better results
+                # "task_type": "RETRIEVAL_DOCUMENT"  
+            }
+        }
+    )
+    
+    # Alternative: Using experimental model with advanced features
+    # agents = PraisonAIAgents(
+    #     agents=[researcher, retriever],
+    #     tasks=[store_task, retrieve_task],
+    #     verbose=True,
+    #     memory=True,
+    #     embedder={
+    #         "provider": "gemini",
+    #         "config": {
+    #             "model": "gemini-embedding-exp-03-07",
+    #             # Task types: SEMANTIC_SIMILARITY, CLASSIFICATION, CLUSTERING,
+    #             #            RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY, QUESTION_ANSWERING,
+    #             #            FACT_VERIFICATION
+    #             "task_type": "RETRIEVAL_DOCUMENT"
+    #         }
+    #     }
+    # )
+    
+    # Execute the workflow
+    print("Starting agents with Gemini embeddings...\n")
+    result = agents.start()
+    
+    # Demonstrate direct memory access with Gemini embeddings
+    print("\n=== Direct Memory Search Example ===\n")
+    
+    if agents.shared_memory:
+        # Search queries that test semantic understanding
+        queries = [
+            "What are Google's latest AI innovations?",
+            "Explain multimodal AI capabilities",
+            "Large language model features"
+        ]
+        
+        for query in queries:
+            print(f"\nSearching for: '{query}'")
+            results = agents.shared_memory.search_long_term(query, limit=3)
+            
+            if results:
+                print(f"Found {len(results)} semantically similar results:")
+                for i, result in enumerate(results, 1):
+                    print(f"\n{i}. Relevance Score: {result.get('score', 0):.3f}")
+                    print(f"   Content: {result.get('text', '')[:150]}...")
+            else:
+                print("No results found")
+    
+    print("\n=== Example Complete ===")
+    print("\nKey Points:")
+    print("1. Gemini embeddings provide semantic understanding of text")
+    print("2. Results are based on meaning, not just keyword matching")
+    print("3. Different task types can optimize embedding quality")
+    print("4. Compatible with LiteLLM for easy integration")
+
+if __name__ == "__main__":
+    main()

examples/python/memory/gemini-embeddings.md

@@ -0,0 +1,165 @@
+# Gemini Embedding Support in PraisonAI
+
+This document describes how to use Google's Gemini embedding models with PraisonAI's memory system.
+
+## Overview
+
+PraisonAI now supports configurable embedding models through LiteLLM, including Google's Gemini embedding models. This allows you to use models like `text-embedding-004` or `gemini-embedding-exp-03-07` for semantic search and memory storage.
+
+## Configuration
+
+### Default Configuration (OpenAI)
+
+By default, PraisonAI uses OpenAI's `text-embedding-3-small` model:
+
+```python
+from praisonaiagents import PraisonAIAgents
+
+agents = PraisonAIAgents(
+    agents=[...],
+    tasks=[...],
+    memory=True  # Uses default OpenAI embeddings
+)
+```
+
+### Using Gemini Embeddings
+
+To use Gemini embeddings, configure the `embedder` parameter:
+
+```python
+from praisonaiagents import PraisonAIAgents
+
+agents = PraisonAIAgents(
+    agents=[...],
+    tasks=[...],
+    memory=True,
+    embedder={
+        "provider": "gemini",
+        "config": {
+            "model": "text-embedding-004"  # or "gemini-embedding-exp-03-07"
+        }
+    }
+)
+```
+
+## Prerequisites
+
+1. **API Key**: Set your Google API key:
+   ```bash
+   export GOOGLE_API_KEY='your-api-key'
+   ```
+
+2. **Dependencies**: Ensure you have the memory dependencies installed:
+   ```bash
+   pip install "praisonaiagents[memory]"
+   ```
+
+## Supported Models
+
+### Gemini Embedding Models
+
+- `text-embedding-004` - Stable embedding model
+- `gemini-embedding-exp-03-07` - Experimental model with advanced features
+
+### Task Types (Optional)
+
+Gemini models support task-specific optimizations:
+- `SEMANTIC_SIMILARITY`
+- `CLASSIFICATION`
+- `CLUSTERING`
+- `RETRIEVAL_DOCUMENT`
+- `RETRIEVAL_QUERY`
+- `QUESTION_ANSWERING`
+- `FACT_VERIFICATION`
+
+Example with task type:
+```python
+embedder={
+    "provider": "gemini",
+    "config": {
+        "model": "text-embedding-004",
+        "task_type": "RETRIEVAL_DOCUMENT"
+    }
+}
+```
+
+## Complete Example
+
+```python
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Ensure Google API key is set
+os.environ["GOOGLE_API_KEY"] = "your-api-key"
+
+# Create agents
+researcher = Agent(
+    name="Researcher",
+    role="Information Researcher",
+    goal="Store information with semantic understanding",
+    llm="gpt-4o-mini"
+)
+
+# Create task
+task = Task(
+    description="Research and store information about AI advancements",
+    expected_output="Confirmation of stored information",
+    agent=researcher
+)
+
+# Initialize with Gemini embeddings
+agents = PraisonAIAgents(
+    agents=[researcher],
+    tasks=[task],
+    memory=True,
+    embedder={
+        "provider": "gemini",
+        "config": {
+            "model": "text-embedding-004"
+        }
+    }
+)
+
+# Run the agents
+agents.start()
+```
+
+## Backward Compatibility
+
+The implementation maintains full backward compatibility:
+
+1. **No embedder config**: Uses default OpenAI `text-embedding-3-small`
+2. **Existing configs**: Continue to work without modification
+3. **Other providers**: Supports any embedding model available through LiteLLM
+
+## Memory Configuration with Mem0
+
+When using Mem0 as the memory provider, the embedder configuration is passed through:
+
+```python
+memory_config = {
+    "provider": "mem0",
+    "config": {
+        "api_key": "your-mem0-key",
+        "embedder": {
+            "provider": "gemini",
+            "config": {
+                "model": "text-embedding-004"
+            }
+        }
+    }
+}
+```
+
+## Troubleshooting
+
+1. **API Key Error**: Ensure `GOOGLE_API_KEY` is set in your environment
+2. **Model Not Found**: Verify the model name is correct
+3. **LiteLLM Error**: Ensure litellm is installed and up to date
+4. **Embedding Size Mismatch**: When switching models, you may need to clear the vector database as different models produce different embedding dimensions
+
+## See Also
+
+- [Gemini API Documentation](https://ai.google.dev/gemini-api/docs/embeddings)
+- [LiteLLM Embedding Models](https://docs.litellm.ai/docs/embedding/supported_embedding)
+- Example: `/examples/python/memory/gemini-embedding-example.py`

examples/python/tools/searxng/searxng-search.py

@@ -196,4 +196,4 @@ def main():
         print("Make sure SearxNG is running at http://localhost:32768")
 
 if __name__ == "__main__":
-    main()
+    main()

examples/python/tools/trafilatura/custom_trafilatura_tools.py

@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+"""
+Custom Trafilatura Tools for High-Quality URL Content Extraction
+
+This is an example of creating custom tools for PraisonAI agents.
+This tool is not part of the core package - it's a standalone custom tool
+that demonstrates how to implement web content extraction using Trafilatura.
+
+Install dependencies:
+pip install trafilatura newspaper3k
+
+Usage:
+from custom_trafilatura_tools import TrafilaturaTools
+
+tools = TrafilaturaTools()
+content = tools.extract_content("https://example.com/article")
+metadata = tools.extract_metadata("https://example.com/article")
+"""
+
+import logging
+from typing import Dict, Any, Optional, Union, List
+from importlib import util
+import json
+from urllib.parse import urlparse
+
+
+class TrafilaturaTools:
+    """Custom tools for extracting high-quality content from URLs using Trafilatura."""
+    
+    def __init__(self):
+        """Initialize TrafilaturaTools and check for required packages."""
+        self.trafilatura = self._check_and_import_trafilatura()
+        
+    def _check_and_import_trafilatura(self):
+        """Check if trafilatura package is installed and import it."""
+        if util.find_spec("trafilatura") is None:
+            raise ImportError(
+                "trafilatura package is not available. Please install it using: pip install trafilatura"
+            )
+        import trafilatura
+        return trafilatura
+        
+    def _validate_url(self, url: str) -> bool:
+        """
+        Validate URL to prevent SSRF attacks.
+        
+        Args:
+            url: URL to validate
+            
+        Returns:
+            bool: True if URL is safe, False otherwise
+        """
+        try:
+            parsed = urlparse(url)
+            
+            # Only allow http/https protocols
+            if parsed.scheme not in ['http', 'https']:
+                return False
+            
+            # Reject URLs with no hostname
+            if not parsed.hostname:
+                return False
+            
+            # Reject local/internal addresses
+            hostname = parsed.hostname.lower()
+            
+            # Block localhost and loopback
+            if hostname in ['localhost', '127.0.0.1', '0.0.0.0', '::1']:
+                return False
+            
+            # Block private IP ranges
+            import ipaddress
+            try:
+                ip = ipaddress.ip_address(hostname)
+                if ip.is_private or ip.is_reserved or ip.is_loopback or ip.is_link_local:
+                    return False
+            except ValueError:
+                # Not an IP address, continue with domain validation
+                pass
+            
+            # Block common internal domains
+            if any(hostname.endswith(domain) for domain in ['.local', '.internal', '.localdomain']):
+                return False
+            
+            # Block metadata service endpoints
+            return hostname not in ['169.254.169.254', 'metadata.google.internal']
+            
+        except Exception:
+            return False
+
+    def extract_content(
+        self,
+        url: str,
+        include_comments: bool = False,
+        include_links: bool = True,
+        output_format: str = 'json',
+        include_metadata: bool = True,
+        target_language: Optional[str] = None
+    ) -> Union[Dict[str, Any], str]:
+        """
+        Extract high-quality content from a URL using Trafilatura.
+        
+        Args:
+            url: URL to extract content from
+            include_comments: Include comments in extraction
+            include_links: Include links in extraction
+            output_format: Output format ('json', 'text', 'xml')
+            include_metadata: Include metadata in extraction
+            target_language: Target language for extraction (None for auto-detect)
+            
+        Returns:
+            Dict or str: Extracted content (dict for json format, str for text/xml)
+        """
+        # Validate URL
+        if not self._validate_url(url):
+            error_msg = f"Invalid or unsafe URL: {url}"
+            logging.error(error_msg)
+            return {"error": error_msg} if output_format == 'json' else error_msg
+        
+        try:
+            # Fetch the URL content
+            downloaded = self.trafilatura.fetch_url(url)
+            if not downloaded:
+                error_msg = f"Could not fetch content from URL: {url}"
+                logging.error(error_msg)
+                return {"error": error_msg} if output_format == 'json' else error_msg
+            
+            # Extract content
+            extracted = self.trafilatura.extract(
+                downloaded,
+                include_comments=include_comments,
+                include_links=include_links,
+                output_format=output_format,
+                with_metadata=include_metadata,
+                url=url,
+                target_language=target_language
+            )
+            
+            if not extracted:
+                error_msg = f"Could not extract readable content from: {url}"
+                logging.warning(error_msg)
+                return {"error": error_msg} if output_format == 'json' else error_msg
+            
+            # Parse JSON output if requested
+            if output_format == 'json':
+                return json.loads(extracted)
+            else:
+                return extracted
+                
+        except Exception as e:
+            error_msg = f"Error extracting content from {url}: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg} if output_format == 'json' else error_msg
+
+    def extract_metadata(self, url: str) -> Dict[str, Any]:
+        """
+        Extract metadata from a URL.
+        
+        Args:
+            url: URL to extract metadata from
+            
+        Returns:
+            Dict: Metadata including title, author, date, etc.
+        """
+        # Validate URL
+        if not self._validate_url(url):
+            error_msg = f"Invalid or unsafe URL: {url}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+        
+        try:
+            # Fetch the URL content
+            downloaded = self.trafilatura.fetch_url(url)
+            if not downloaded:
+                error_msg = f"Could not fetch content from URL: {url}"
+                logging.error(error_msg)
+                return {"error": error_msg}
+            
+            # Extract metadata
+            metadata = self.trafilatura.extract_metadata(downloaded, url=url)
+            
+            if not metadata:
+                return {
+                    "url": url,
+                    "error": "No metadata found"
+                }
+            
+            # Convert metadata object to dict
+            result = {
+                "url": url,
+                "title": metadata.title,
+                "author": metadata.author,
+                "date": metadata.date,
+                "description": metadata.description,
+                "categories": metadata.categories,
+                "tags": metadata.tags,
+                "language": metadata.language,
+                "image": metadata.image,
+                "pagetype": metadata.pagetype,
+                "license": metadata.license
+            }
+            
+            # Remove None values
+            result = {k: v for k, v in result.items() if v is not None}
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"Error extracting metadata from {url}: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def extract_text_only(
+        self,
+        url: str,
+        include_comments: bool = False
+    ) -> str:
+        """
+        Extract only the main text content from a URL.
+        
+        Args:
+            url: URL to extract text from
+            include_comments: Include comments in extraction
+            
+        Returns:
+            str: Extracted text content
+        """
+        result = self.extract_content(
+            url=url,
+            include_comments=include_comments,
+            include_links=False,
+            output_format='text',
+            include_metadata=False
+        )
+        return result
+
+    def compare_extraction(
+        self,
+        url: str,
+        include_newspaper: bool = True,
+        include_spider: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Compare Trafilatura extraction with other tools for the same URL.
+        
+        Args:
+            url: URL to extract content from
+            include_newspaper: Include newspaper3k comparison
+            include_spider: Include spider_tools comparison (if available)
+            
+        Returns:
+            Dict: Comparison of extraction results
+        """
+        comparison = {
+            "url": url,
+            "trafilatura": None,
+            "newspaper": None,
+            "spider": None
+        }
+        
+        # Get Trafilatura extraction
+        try:
+            comparison["trafilatura"] = self.extract_content(url)
+        except Exception as e:
+            comparison["trafilatura"] = {"error": str(e)}
+        
+        # Get Newspaper extraction if requested
+        if include_newspaper:
+            try:
+                # Try to import and use newspaper3k
+                if util.find_spec("newspaper") is not None:
+                    import newspaper
+                    article = newspaper.Article(url)
+                    article.download()
+                    article.parse()
+                    comparison["newspaper"] = {
+                        "title": article.title,
+                        "text": article.text,
+                        "authors": article.authors,
+                        "publish_date": str(article.publish_date) if article.publish_date else None,
+                        "top_image": article.top_image,
+                        "summary": article.summary if hasattr(article, 'summary') else None
+                    }
+                else:
+                    comparison["newspaper"] = {"error": "newspaper3k not installed"}
+            except Exception as e:
+                comparison["newspaper"] = {"error": str(e)}
+        
+        # Get Spider extraction if requested (placeholder for external spider tools)
+        if include_spider:
+            try:
+                # This is a placeholder - you could integrate with other scraping tools here
+                # For now, we'll use a simple requests + BeautifulSoup approach
+                if util.find_spec("requests") and util.find_spec("bs4"):
+                    import requests
+                    from bs4 import BeautifulSoup
+                    
+                    response = requests.get(url, timeout=10)
+                    soup = BeautifulSoup(response.content, 'html.parser')
+                    
+                    # Extract basic content
+                    title = soup.find('title')
+                    title_text = title.get_text().strip() if title else None
+                    
+                    # Remove script and style elements
+                    for script in soup(["script", "style"]):
+                        script.decompose()
+                    
+                    # Get text
+                    text = soup.get_text()
+                    # Clean up whitespace
+                    lines = (line.strip() for line in text.splitlines())
+                    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+                    text = ' '.join(chunk for chunk in chunks if chunk)
+                    
+                    comparison["spider"] = {
+                        "title": title_text,
+                        "text": text[:2000],  # Limit to first 2000 chars
+                        "method": "requests+beautifulsoup"
+                    }
+                else:
+                    comparison["spider"] = {"error": "requests or beautifulsoup4 not installed"}
+            except Exception as e:
+                comparison["spider"] = {"error": str(e)}
+        
+        return comparison
+
+    def get_available_methods(self) -> List[str]:
+        """
+        Get list of available methods in this tool.
+        
+        Returns:
+            List[str]: List of method names
+        """
+        return [
+            'extract_content',
+            'extract_metadata', 
+            'extract_text_only',
+            'compare_extraction'
+        ]
+
+
+# Convenience functions for easier usage
+def create_trafilatura_tools() -> TrafilaturaTools:
+    """Create and return a TrafilaturaTools instance."""
+    return TrafilaturaTools()
+
+
+# Test the tool
+if __name__ == "__main__":
+    # Test URL
+    test_url = "https://www.python.org/about/"
+    
+    print("Testing Custom Trafilatura Tools")
+    print("=" * 50)
+    
+    try:
+        # Create tools instance
+        tools = TrafilaturaTools()
+        
+        # Test 1: Extract content
+        print("\n1. Testing extract_content():")
+        print("-" * 50)
+        content = tools.extract_content(test_url)
+        if isinstance(content, dict) and 'error' not in content:
+            print(f"✓ Title: {content.get('title', 'N/A')}")
+            print(f"✓ Language: {content.get('language', 'N/A')}")
+            print(f"✓ Text length: {len(content.get('text', ''))} characters")
+            print(f"✓ Author: {content.get('author', 'N/A')}")
+            print(f"✓ Date: {content.get('date', 'N/A')}")
+        else:
+            print(f"✗ Error: {content}")
+        
+        # Test 2: Extract metadata
+        print("\n2. Testing extract_metadata():")
+        print("-" * 50)
+        metadata = tools.extract_metadata(test_url)
+        if isinstance(metadata, dict) and 'error' not in metadata:
+            print("✓ Metadata extracted successfully:")
+            for key, value in metadata.items():
+                if key != 'url':
+                    print(f"  - {key}: {value}")
+        else:
+            print(f"✗ Error: {metadata}")
+        
+        # Test 3: Extract text only
+        print("\n3. Testing extract_text_only():")
+        print("-" * 50)
+        text = tools.extract_text_only(test_url)
+        if isinstance(text, str) and text and "error" not in text.lower():
+            print(f"✓ Text extracted: {len(text)} characters")
+            print(f"✓ Preview: {text[:150]}...")
+        else:
+            print(f"✗ Error: {text}")
+        
+        # Test 4: Test URL validation
+        print("\n4. Testing URL validation (security):")
+        print("-" * 50)
+        unsafe_urls = ["http://localhost/test", "http://127.0.0.1/test"]
+        for unsafe_url in unsafe_urls:
+            result = tools.extract_content(unsafe_url)
+            if isinstance(result, dict) and 'error' in result and 'Invalid or unsafe URL' in result['error']:
+                print(f"✓ Correctly rejected: {unsafe_url}")
+            else:
+                print(f"✗ Failed to reject: {unsafe_url}")
+        
+        # Test 5: Available methods
+        print("\n5. Available methods:")
+        print("-" * 50)
+        methods = tools.get_available_methods()
+        for method in methods:
+            print(f"✓ {method}")
+        
+    except Exception as e:
+        print(f"✗ Failed to initialize tools: {e}")
+        print("\nMake sure to install dependencies:")
+        print("pip install trafilatura newspaper3k requests beautifulsoup4")
+    
+    print("\n" + "=" * 50)
+    print("Custom Trafilatura Tools testing complete!")

examples/python/tools/trafilatura/trafilatura_example.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+"""
+Example: Using Custom Trafilatura Tools for High-Quality URL Content Extraction
+
+This example demonstrates how to create and use custom Trafilatura tools in PraisonAI
+for extracting high-quality content from web pages.
+
+This shows how to create custom tools that are not part of the core package.
+
+Install dependencies:
+pip install trafilatura newspaper3k requests beautifulsoup4
+"""
+
+import asyncio
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from custom_trafilatura_tools import TrafilaturaTools, create_trafilatura_tools
+
+# Create tools instance (global for reuse across examples)
+tools = None
+
+def get_tools():
+    """Get or create tools instance"""
+    global tools
+    if tools is None:
+        tools = create_trafilatura_tools()
+    return tools
+
+# Example 1: Basic content extraction
+async def basic_extraction_example():
+    """Extract content from a URL using custom Trafilatura tools"""
+    tools_instance = get_tools()
+    
+    # Extract content from a URL
+    url = "https://www.python.org/about/"
+    content = await asyncio.to_thread(tools_instance.extract_content, url)
+    
+    if 'error' not in content:
+        print(f"Title: {content.get('title', 'N/A')}")
+        print(f"Author: {content.get('author', 'N/A')}")
+        print(f"Date: {content.get('date', 'N/A')}")
+        print(f"Text preview: {content.get('text', '')[:200]}...")
+    else:
+        print(f"Error: {content['error']}")
+
+# Example 2: Extract text only
+async def text_only_example():
+    """Extract only the main text content"""
+    tools_instance = get_tools()
+    
+    url = "https://www.python.org/about/"
+    text = await asyncio.to_thread(tools_instance.extract_text_only, url)
+    
+    print(f"Extracted text ({len(text)} characters):")
+    print(f"{text[:300]}...")
+
+# Example 3: Extract metadata
+async def metadata_example():
+    """Extract metadata from a web page"""
+    tools_instance = get_tools()
+    
+    url = "https://www.python.org/about/"
+    metadata = await asyncio.to_thread(tools_instance.extract_metadata, url)
+    
+    print("Page metadata:")
+    for key, value in metadata.items():
+        if key != 'url':
+            print(f"  {key}: {value}")
+
+# Example 4: Compare extraction methods
+async def comparison_example():
+    """Compare Trafilatura with other extraction tools"""
+    tools_instance = get_tools()
+    
+    url = "https://www.python.org/about/"
+    comparison = await asyncio.to_thread(
+        tools_instance.compare_extraction,
+        url, 
+        include_newspaper=True,  # Compare with newspaper3k
+        include_spider=True      # Compare with basic scraping
+    )
+    
+    print("Extraction comparison:")
+    for tool, result in comparison.items():
+        if tool != 'url' and result:
+            if isinstance(result, dict) and 'error' not in result:
+                print(f"\n{tool.upper()}:")
+                if 'title' in result:
+                    print(f"  Title: {result.get('title', 'N/A')}")
+                if 'text' in result:
+                    text_len = len(result.get('text', ''))
+                    print(f"  Text length: {text_len} characters")
+            else:
+                print(f"\n{tool.upper()}: {result}")
+
+# Example 5: Using Custom Trafilatura tools with an Agent
+async def agent_example():
+    """Use custom Trafilatura tools with an AI agent"""
+    tools_instance = get_tools()
+    
+    # Create wrapper functions for the agent to use
+    def extract_content_tool(url: str) -> dict:
+        """Extract content from URL using Trafilatura"""
+        return tools_instance.extract_content(url)
+    
+    def extract_metadata_tool(url: str) -> dict:
+        """Extract metadata from URL using Trafilatura"""
+        return tools_instance.extract_metadata(url)
+    
+    # Create a research agent with custom Trafilatura tools
+    research_agent = Agent(
+        name="Research Assistant",
+        role="Web Content Analyzer",
+        goal="Extract and analyze content from web pages using custom tools",
+        backstory="You are an expert at extracting and analyzing web content using custom Trafilatura tools",
+        tools=[extract_content_tool, extract_metadata_tool],
+        llm="gpt-4o-mini"
+    )
+    
+    # Create a task for content analysis
+    analysis_task = Task(
+        description="""
+        Extract content from this URL: https://www.python.org/about/
+        
+        Use the custom Trafilatura tools to provide a summary of:
+        1. The main content and purpose of the page
+        2. Key metadata (author, date, language)
+        3. The overall quality and structure of the content
+        """,
+        expected_output="A comprehensive analysis of the web page content using custom tools",
+        agent=research_agent
+    )
+    
+    # Run the analysis
+    agents = PraisonAIAgents(
+        agents=[research_agent],
+        tasks=[analysis_task]
+    )
+    
+    result = await agents.astart()
+    print("\nAgent Analysis Result:")
+    print(result)
+
+# Example 6: Content extraction with language specification
+async def language_example():
+    """Extract content with specific language targeting"""
+    tools_instance = get_tools()
+    
+    # Extract content targeting specific language
+    url = "https://www.python.org/about/"
+    content = await asyncio.to_thread(
+        tools_instance.extract_content,
+        url,
+        target_language="en",  # Target English content
+        include_links=True,    # Include links in extraction
+        include_comments=False # Exclude comments
+    )
+    
+    if 'error' not in content:
+        print(f"Language: {content.get('language', 'N/A')}")
+        print(f"Number of links: {len(content.get('links', []))}")
+
+# Example 7: Output format options
+async def format_example():
+    """Demonstrate different output formats"""
+    tools_instance = get_tools()
+    
+    url = "https://www.python.org/about/"
+    
+    # JSON format (default)
+    json_content = await asyncio.to_thread(tools_instance.extract_content, url, output_format='json')
+    print("JSON format - type:", type(json_content))
+    
+    # Text format
+    text_content = await asyncio.to_thread(tools_instance.extract_content, url, output_format='text')
+    print("\nText format - first 200 chars:")
+    print(text_content[:200] + "...")
+    
+    # XML format
+    xml_content = await asyncio.to_thread(tools_instance.extract_content, url, output_format='xml')
+    print("\nXML format - first 200 chars:")
+    print(xml_content[:200] + "...")
+
+# Example 8: Show available methods
+async def available_methods_example():
+    """Show what methods are available in the custom tool"""
+    tools_instance = get_tools()
+    
+    methods = tools_instance.get_available_methods()
+    print("Available methods in custom Trafilatura tools:")
+    for method in methods:
+        print(f"  - {method}")
+
+# Example 9: Security testing
+async def security_example():
+    """Test URL validation security features"""
+    tools_instance = get_tools()
+    
+    print("Testing URL security validation:")
+    unsafe_urls = [
+        "http://localhost/test",
+        "http://127.0.0.1/test", 
+        "http://169.254.169.254/metadata"
+    ]
+    
+    for unsafe_url in unsafe_urls:
+        result = await asyncio.to_thread(tools_instance.extract_content, unsafe_url)
+        if isinstance(result, dict) and 'error' in result:
+            print(f"✓ Correctly rejected: {unsafe_url}")
+        else:
+            print(f"✗ Failed to reject: {unsafe_url}")
+
+async def main():
+    """Run all examples"""
+    print("=== Custom Trafilatura Tools Examples ===\n")
+    
+    try:
+        # First check if we can create the tools
+        tools_instance = get_tools()
+        print("✓ Successfully created custom Trafilatura tools\n")
+        
+        print("1. Available Methods")
+        print("-" * 40)
+        await available_methods_example()
+        
+        print("\n2. Basic Content Extraction")
+        print("-" * 40)
+        await basic_extraction_example()
+        
+        print("\n3. Text-Only Extraction")
+        print("-" * 40)
+        await text_only_example()
+        
+        print("\n4. Metadata Extraction")
+        print("-" * 40)
+        await metadata_example()
+        
+        print("\n5. Tool Comparison")
+        print("-" * 40)
+        await comparison_example()
+        
+        print("\n6. Language-Specific Extraction")
+        print("-" * 40)
+        await language_example()
+        
+        print("\n7. Output Format Options")
+        print("-" * 40)
+        await format_example()
+        
+        print("\n8. Security Testing")
+        print("-" * 40)
+        await security_example()
+        
+        print("\n9. Agent-Based Analysis")
+        print("-" * 40)
+        await agent_example()
+        
+    except ImportError as e:
+        print(f"✗ Error: {e}")
+        print("\nPlease install required dependencies:")
+        print("pip install trafilatura newspaper3k requests beautifulsoup4")
+    except Exception as e:
+        print(f"✗ Unexpected error: {e}")
+
+if __name__ == "__main__":
+    # Run the examples
+    asyncio.run(main())

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

@@ -27,7 +27,8 @@ from ..main import (
     display_self_reflection,
     ReflectionOutput,
     adisplay_instruction,
-    approval_callback
+    approval_callback,
+    execute_sync_callback
 )
 import inspect
 import uuid
@@ -424,7 +425,13 @@ class Agent:
         # Otherwise, fall back to OpenAI environment/name
         else:
             self.llm = llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
-        self.tools = tools if tools else []  # Store original tools
+        # Handle tools parameter - ensure it's always a list
+        if callable(tools):
+            # If a single function/callable is passed, wrap it in a list
+            self.tools = [tools]
+        else:
+            # Handle all falsy values (None, False, 0, "", etc.) by defaulting to empty list
+            self.tools = tools or []
         self.function_calling_llm = function_calling_llm
         self.max_iter = max_iter
         self.max_rpm = max_rpm
@@ -1142,6 +1149,25 @@ Your Goal: {self.goal}"""
         except Exception as e:
             display_error(f"Error in chat completion: {e}")
             return None
+    
+    def _execute_callback_and_display(self, prompt: str, response: str, generation_time: float):
+        """Helper method to execute callbacks and display interaction.
+        
+        This centralizes the logic for callback execution and display to avoid duplication.
+        """
+        # Always execute callbacks regardless of verbose setting (only when not using custom LLM)
+        if not self._using_custom_llm:
+            execute_sync_callback(
+                'interaction',
+                message=prompt,
+                response=response,
+                markdown=self.markdown,
+                generation_time=generation_time
+            )
+        # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
+        if self.verbose and not self._using_custom_llm:
+            display_interaction(prompt, response, markdown=self.markdown, 
+                              generation_time=generation_time, console=self.console)
 
     def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None, reasoning_steps=False, stream=True):
         # Log all parameter values when in debug mode
@@ -1321,25 +1347,30 @@ Your Goal: {self.goal}"""
                             # Add to chat history and return raw response
                             # User message already added before LLM call via _build_messages
                             self.chat_history.append({"role": "assistant", "content": response_text})
-                            # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
-                            if self.verbose and not self._using_custom_llm:
-                                display_interaction(original_prompt, response_text, markdown=self.markdown, 
-                                                 generation_time=time.time() - start_time, console=self.console)
-                            return response_text
+                            # Apply guardrail validation even for JSON output
+                            try:
+                                validated_response = self._apply_guardrail_with_retry(response_text, original_prompt, temperature, tools)
+                                # Execute callback after validation
+                                self._execute_callback_and_display(original_prompt, validated_response, time.time() - start_time)
+                                return validated_response
+                            except Exception as e:
+                                logging.error(f"Agent {self.name}: Guardrail validation failed for JSON output: {e}")
+                                # Rollback chat history on guardrail failure
+                                self.chat_history = self.chat_history[:chat_history_length]
+                                return None
 
                         if not self.self_reflect:
                             # User message already added before LLM call via _build_messages
                             self.chat_history.append({"role": "assistant", "content": response_text})
                             if self.verbose:
                                 logging.debug(f"Agent {self.name} final response: {response_text}")
-                            # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
-                            if self.verbose and not self._using_custom_llm:
-                                display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                             # Return only reasoning content if reasoning_steps is True
                             if reasoning_steps and hasattr(response.choices[0].message, 'reasoning_content'):
                                 # Apply guardrail to reasoning content
                                 try:
                                     validated_reasoning = self._apply_guardrail_with_retry(response.choices[0].message.reasoning_content, original_prompt, temperature, tools)
+                                    # Execute callback after validation
+                                    self._execute_callback_and_display(original_prompt, validated_reasoning, time.time() - start_time)
                                     return validated_reasoning
                                 except Exception as e:
                                     logging.error(f"Agent {self.name}: Guardrail validation failed for reasoning content: {e}")
@@ -1349,6 +1380,8 @@ Your Goal: {self.goal}"""
                             # Apply guardrail to regular response
                             try:
                                 validated_response = self._apply_guardrail_with_retry(response_text, original_prompt, temperature, tools)
+                                # Execute callback after validation
+                                self._execute_callback_and_display(original_prompt, validated_response, time.time() - start_time)
                                 return validated_response
                             except Exception as e:
                                 logging.error(f"Agent {self.name}: Guardrail validation failed: {e}")
@@ -1412,12 +1445,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                     display_self_reflection("Agent marked the response as satisfactory after meeting minimum reflections", console=self.console)
                                 # User message already added before LLM call via _build_messages
                                 self.chat_history.append({"role": "assistant", "content": response_text})
-                                # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
-                                if self.verbose and not self._using_custom_llm:
-                                    display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                                 # Apply guardrail validation after satisfactory reflection
                                 try:
                                     validated_response = self._apply_guardrail_with_retry(response_text, original_prompt, temperature, tools)
+                                    # Execute callback after validation
+                                    self._execute_callback_and_display(original_prompt, validated_response, time.time() - start_time)
                                     return validated_response
                                 except Exception as e:
                                     logging.error(f"Agent {self.name}: Guardrail validation failed after reflection: {e}")
@@ -1431,12 +1463,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                     display_self_reflection("Maximum reflection count reached, returning current response", console=self.console)
                                 # User message already added before LLM call via _build_messages
                                 self.chat_history.append({"role": "assistant", "content": response_text})
-                                # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
-                                if self.verbose and not self._using_custom_llm:
-                                    display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                                 # Apply guardrail validation after max reflections
                                 try:
                                     validated_response = self._apply_guardrail_with_retry(response_text, original_prompt, temperature, tools)
+                                    # Execute callback after validation
+                                    self._execute_callback_and_display(original_prompt, validated_response, time.time() - start_time)
                                     return validated_response
                                 except Exception as e:
                                     logging.error(f"Agent {self.name}: Guardrail validation failed after max reflections: {e}")

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

@@ -491,18 +491,35 @@ Context:
                         tasks_to_run = []
                     
                     # Run sync task in an executor to avoid blocking the event loop
-                    loop = asyncio.get_event_loop()
+                    loop = asyncio.get_running_loop()
                     await loop.run_in_executor(None, self.run_task, task_id)
 
             if tasks_to_run:
                 await asyncio.gather(*tasks_to_run)
                 
         elif self.process == "sequential":
+            async_tasks_to_run = []
+            
+            async def flush_async_tasks():
+                """Execute all pending async tasks"""
+                nonlocal async_tasks_to_run
+                if async_tasks_to_run:
+                    await asyncio.gather(*async_tasks_to_run)
+                    async_tasks_to_run = []
+            
             async for task_id in process.asequential():
                 if self.tasks[task_id].async_execution:
-                    await self.arun_task(task_id)
+                    # Collect async tasks to run in parallel
+                    async_tasks_to_run.append(self.arun_task(task_id))
                 else:
-                    self.run_task(task_id)
+                    # Before running a sync task, execute all pending async tasks
+                    await flush_async_tasks()
+                    # Run sync task in an executor to avoid blocking the event loop
+                    loop = asyncio.get_running_loop()
+                    await loop.run_in_executor(None, self.run_task, task_id)
+            
+            # Execute any remaining async tasks at the end
+            await flush_async_tasks()
         elif self.process == "hierarchical":
             async for task_id in process.ahierarchical():
                 if isinstance(task_id, Task):
@@ -510,7 +527,9 @@ Context:
                 if self.tasks[task_id].async_execution:
                     await self.arun_task(task_id)
                 else:
-                    self.run_task(task_id)
+                    # Run sync task in an executor to avoid blocking the event loop
+                    loop = asyncio.get_running_loop()
+                    await loop.run_in_executor(None, self.run_task, task_id)
 
     async def astart(self, content=None, return_dict=False, **kwargs):
         """Async version of start method
@@ -1116,7 +1135,7 @@ Context:
                                 response = await agent_instance.achat(current_input)
                             else:
                                 # Run sync function in a thread to avoid blocking
-                                loop = asyncio.get_event_loop()
+                                loop = asyncio.get_running_loop()
                                 # Correctly pass current_input to the lambda for closure
                                 response = await loop.run_in_executor(None, lambda ci=current_input: agent_instance.chat(ci))
                             
@@ -1271,7 +1290,7 @@ Context:
                         if hasattr(agent_instance, 'achat') and asyncio.iscoroutinefunction(agent_instance.achat):
                             response = await agent_instance.achat(current_input, tools=agent_instance.tools)
                         elif hasattr(agent_instance, 'chat'): # Fallback to sync chat if achat not suitable
-                            loop = asyncio.get_event_loop()
+                            loop = asyncio.get_running_loop()
                             response = await loop.run_in_executor(None, lambda ci=current_input: agent_instance.chat(ci, tools=agent_instance.tools))
                         else:
                             logging.warning(f"Agent {agent_instance.name} has no suitable chat or achat method.")

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

@@ -14,6 +14,7 @@ from ..main import (
     display_generating,
     display_self_reflection,
     ReflectionOutput,
+    execute_sync_callback,
 )
 from rich.console import Console
 from rich.live import Live
@@ -130,8 +131,10 @@ class LLM:
             if 'tools' in safe_config:
                 tools = safe_config['tools']
                 # Check if tools is iterable before processing
-                if tools and hasattr(tools, '__iter__') and not isinstance(tools, str):
+                if tools and isinstance(tools, (list, tuple)):
                     safe_config['tools'] = [t.__name__ if hasattr(t, "__name__") else str(t) for t in tools]
+                elif tools and callable(tools):
+                    safe_config['tools'] = tools.__name__ if hasattr(tools, "__name__") else str(tools)
                 else:
                     safe_config['tools'] = None
             if 'output_json' in safe_config:
@@ -692,6 +695,7 @@ class LLM:
 
             start_time = time.time()
             reflection_count = 0
+            callback_executed = False  # Track if callback has been executed for this interaction
             interaction_displayed = False  # Track if interaction has been displayed
 
             # Display initial instruction once
@@ -737,13 +741,26 @@ class LLM:
                         response_text = resp["choices"][0]["message"]["content"]
                         final_response = resp
                         
+                        # Always execute callbacks regardless of verbose setting
+                        generation_time_val = time.time() - current_time
+                        interaction_displayed = False
+                        
+                        response_content = f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}" if reasoning_content else response_text
+                        execute_sync_callback(
+                            'interaction',
+                            message=original_prompt,
+                            response=response_content,
+                            markdown=markdown,
+                            generation_time=generation_time_val
+                        )
+                        
                         # Optionally display reasoning if present
                         if verbose and reasoning_content and not interaction_displayed:
                             display_interaction(
                                 original_prompt,
                                 f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
                                 markdown=markdown,
-                                generation_time=time.time() - current_time,
+                                generation_time=generation_time_val,
                                 console=console
                             )
                             interaction_displayed = True
@@ -752,7 +769,7 @@ class LLM:
                                 original_prompt,
                                 response_text,
                                 markdown=markdown,
-                                generation_time=time.time() - current_time,
+                                generation_time=generation_time_val,
                                 console=console
                             )
                             interaction_displayed = True
@@ -815,6 +832,16 @@ class LLM:
                             
                             response_text = response_text.strip() if response_text else ""
                             
+                            # Always execute callbacks after streaming completes
+                            execute_sync_callback(
+                                'interaction',
+                                message=original_prompt,
+                                response=response_text,
+                                markdown=markdown,
+                                generation_time=time.time() - current_time
+                            )
+
+                            
                             # Create a mock final_response with the captured data
                             final_response = {
                                 "choices": [{
@@ -839,6 +866,16 @@ class LLM:
                             )
                             response_text = final_response["choices"][0]["message"]["content"]
                             
+                            # Always execute callbacks regardless of verbose setting
+                            execute_sync_callback(
+                                'interaction',
+                                message=original_prompt,
+                                response=response_text,
+                                markdown=markdown,
+                                generation_time=time.time() - current_time
+                            )
+                            
+
                             if verbose and not interaction_displayed:
                                 # Display the complete response at once
                                 display_interaction(
@@ -954,6 +991,17 @@ class LLM:
                 return final_response_text
             
             # No tool calls were made in this iteration, return the response
+            # Always execute callbacks regardless of verbose setting
+            generation_time_val = time.time() - start_time
+            response_content = f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{response_text}" if stored_reasoning_content else response_text
+            execute_sync_callback(
+                'interaction',
+                message=original_prompt,
+                response=response_content,
+                markdown=markdown,
+                generation_time=generation_time_val
+            )
+            
             if verbose and not interaction_displayed:
                 # If we have stored reasoning content from tool execution, display it
                 if stored_reasoning_content:
@@ -984,6 +1032,15 @@ class LLM:
             if output_json or output_pydantic:
                 self.chat_history.append({"role": "user", "content": original_prompt})
                 self.chat_history.append({"role": "assistant", "content": response_text})
+                # Always execute callbacks regardless of verbose setting
+                if not interaction_displayed:
+                    execute_sync_callback(
+                        'interaction',
+                        message=original_prompt,
+                        response=response_text,
+                        markdown=markdown,
+                        generation_time=time.time() - start_time
+                    )
                 if verbose and not interaction_displayed:
                     display_interaction(original_prompt, response_text, markdown=markdown,
                                      generation_time=time.time() - start_time, console=console)
@@ -991,6 +1048,16 @@ class LLM:
                 return response_text
 
             if not self_reflect:
+                # Always execute callbacks regardless of verbose setting
+                if not interaction_displayed:
+                    execute_sync_callback(
+                        'interaction',
+                        message=original_prompt,
+                        response=response_text,
+                        markdown=markdown,
+                        generation_time=time.time() - start_time
+                    )
+
                 if verbose and not interaction_displayed:
                     display_interaction(original_prompt, response_text, markdown=markdown,
                                      generation_time=time.time() - start_time, console=console)

src/praisonai-agents/praisonaiagents/main.py

@@ -62,6 +62,19 @@ def register_approval_callback(callback_fn):
     global approval_callback
     approval_callback = callback_fn
 
+def execute_sync_callback(display_type: str, **kwargs):
+    """Execute synchronous callback for a given display type without displaying anything.
+    
+    This function is used to trigger callbacks even when verbose=False.
+    
+    Args:
+        display_type (str): Type of display event
+        **kwargs: Arguments to pass to the callback function
+    """
+    if display_type in sync_display_callbacks:
+        callback = sync_display_callbacks[display_type]
+        callback(**kwargs)
+
 async def execute_callback(display_type: str, **kwargs):
     """Execute both sync and async callbacks for a given display type.
     
@@ -113,15 +126,6 @@ def display_interaction(message, response, markdown=True, generation_time=None,
     message = _clean_display_content(str(message))
     response = _clean_display_content(str(response))
 
-    # Execute synchronous callback if registered
-    if 'interaction' in sync_display_callbacks:
-        sync_display_callbacks['interaction'](
-            message=message,
-            response=response,
-            markdown=markdown,
-            generation_time=generation_time
-        )
-
     # Rest of the display logic...
     if generation_time:
         console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
@@ -140,10 +144,6 @@ def display_self_reflection(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
-    # Execute callback if registered
-    if 'self_reflection' in sync_display_callbacks:
-        sync_display_callbacks['self_reflection'](message=message)
-    
     console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
 
 def display_instruction(message: str, console=None, agent_name: str = None, agent_role: str = None, agent_tools: List[str] = None):
@@ -153,10 +153,6 @@ def display_instruction(message: str, console=None, agent_name: str = None, agen
         console = Console()
     message = _clean_display_content(str(message))
     
-    # Execute callback if registered
-    if 'instruction' in sync_display_callbacks:
-        sync_display_callbacks['instruction'](message=message)
-    
     # Display agent info if available
     if agent_name:
         agent_info = f"[bold #FF9B9B]👤 Agent:[/] [#FFE5E5]{agent_name}[/]"
@@ -181,10 +177,6 @@ def display_tool_call(message: str, console=None):
     message = _clean_display_content(str(message))
     logging.debug(f"Cleaned message in display_tool_call: {repr(message)}")
     
-    # Execute callback if registered
-    if 'tool_call' in sync_display_callbacks:
-        sync_display_callbacks['tool_call'](message=message)
-    
     console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
 
 def display_error(message: str, console=None):
@@ -194,10 +186,6 @@ def display_error(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
-    # Execute callback if registered
-    if 'error' in sync_display_callbacks:
-        sync_display_callbacks['error'](message=message)
-    
     console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
     error_logs.append(message)
 
@@ -213,13 +201,6 @@ def display_generating(content: str = "", start_time: Optional[float] = None):
     
     content = _clean_display_content(str(content))
     
-    # Execute callback if registered
-    if 'generating' in sync_display_callbacks:
-        sync_display_callbacks['generating'](
-            content=content,
-            elapsed_time=elapsed_str.strip() if elapsed_str else None
-        )
-    
     return Panel(Markdown(content), title=f"Generating...{elapsed_str}", border_style="green")
 
 # Async versions with 'a' prefix

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

@@ -116,6 +116,16 @@ class Memory:
         self.use_mem0 = (self.provider.lower() == "mem0") and MEM0_AVAILABLE
         self.use_rag = (self.provider.lower() == "rag") and CHROMADB_AVAILABLE and self.cfg.get("use_embedding", False)
         self.graph_enabled = False  # Initialize graph support flag
+        
+        # Extract embedding model from config
+        self.embedder_config = self.cfg.get("embedder", {})
+        if isinstance(self.embedder_config, dict):
+            embedder_model_config = self.embedder_config.get("config", {})
+            self.embedding_model = embedder_model_config.get("model", "text-embedding-3-small")
+        else:
+            self.embedding_model = "text-embedding-3-small"
+        
+        self._log_verbose(f"Using embedding model: {self.embedding_model}")
 
         # Create .praison directory if it doesn't exist
         os.makedirs(".praison", exist_ok=True)
@@ -355,7 +365,7 @@ class Memory:
                     import litellm
                     
                     response = litellm.embedding(
-                        model="text-embedding-3-small",
+                        model=self.embedding_model,
                         input=query
                     )
                     query_embedding = response.data[0]["embedding"]
@@ -366,7 +376,7 @@ class Memory:
                     
                     response = client.embeddings.create(
                         input=query,
-                        model="text-embedding-3-small"
+                        model=self.embedding_model
                     )
                     query_embedding = response.data[0].embedding
                 else:
@@ -496,7 +506,7 @@ class Memory:
                     logger.debug(f"Embedding input text: {text}")
                     
                     response = litellm.embedding(
-                        model="text-embedding-3-small",
+                        model=self.embedding_model,
                         input=text
                     )
                     embedding = response.data[0]["embedding"]
@@ -513,7 +523,7 @@ class Memory:
                     
                     response = client.embeddings.create(
                         input=text,
-                        model="text-embedding-3-small"
+                        model=self.embedding_model
                     )
                     embedding = response.data[0].embedding
                     logger.info("Successfully got embeddings from OpenAI")
@@ -576,7 +586,7 @@ class Memory:
                     import litellm
                     
                     response = litellm.embedding(
-                        model="text-embedding-3-small",
+                        model=self.embedding_model,
                         input=query
                     )
                     query_embedding = response.data[0]["embedding"]
@@ -587,7 +597,7 @@ class Memory:
                     
                     response = client.embeddings.create(
                         input=query,
-                        model="text-embedding-3-small"
+                        model=self.embedding_model
                     )
                     query_embedding = response.data[0].embedding
                 else:

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

@@ -265,6 +265,17 @@ class Process:
         # Parse JSON and validate with Pydantic
         return self._parse_manager_instructions(response, ManagerInstructions)
 
+    def _check_all_tasks_completed(self) -> bool:
+        """Check if all tasks are completed and handle workflow completion.
+        
+        Returns:
+            bool: True if all tasks are completed and workflow should exit, False otherwise.
+        """
+        if all(task.status == "completed" for task in self.tasks.values()):
+            logging.info("All tasks are completed.")
+            self.workflow_finished = True
+            return True
+        return False
 
     async def aworkflow(self) -> AsyncGenerator[str, None]:
         """Async version of workflow method"""
@@ -327,10 +338,8 @@ Tasks by type:
             """)
 
             # ADDED: Check if all tasks are completed and set workflow_finished flag
-            if all(task.status == "completed" for task in self.tasks.values()):
-                logging.info("All tasks are completed.")
-                self.workflow_finished = True
-                # The next iteration loop check will break the workflow
+            if self._check_all_tasks_completed():
+                break  # Exit immediately to prevent task reset
 
             task_id = current_task.id
             logging.debug(f"""
@@ -887,10 +896,8 @@ Tasks by type:
             """)
 
             # ADDED: Check if all tasks are completed and set workflow_finished flag
-            if all(task.status == "completed" for task in self.tasks.values()):
-                logging.info("All tasks are completed.")
-                self.workflow_finished = True
-                # The next iteration loop check will break the workflow
+            if self._check_all_tasks_completed():
+                break  # Exit immediately to prevent task reset
 
 
             # Handle loop task file reading at runtime

src/praisonai-agents/praisonaiagents/tools/README.md

@@ -99,6 +99,19 @@ Ask yourself these questions:
 - Each search is independent and secure
 - Alternative to traditional search engines for privacy
 
+
+### Spider Tool (Function-Based)
+- General-purpose web scraping and crawling
+- Supports CSS selectors for precise content extraction
+- Can crawl multiple pages and extract links/images
+- Flexible for various web scraping needs
+
+### Newspaper Tool (Function-Based)
+- Specialized for news article extraction
+- Extracts article title, text, authors, and publish date
+- Includes NLP processing for keywords and summaries
+- Categorizes news sources by topic
+
 ### Stock Market Tool (Class-Based)
 - Does multiple things: check prices, get company info, get historical data
 - Remembers stock information to avoid repeated downloads

src/praisonai-agents/praisonaiagents/tools/__init__.py

@@ -39,6 +39,7 @@ TOOL_MAPPINGS = {
     'extract_text': ('.spider_tools', None),
     'spider_tools': ('.spider_tools', None),
     
+    
     # DuckDB Tools
     'query': ('.duckdb_tools', None),
     'create_table': ('.duckdb_tools', None),

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.129"
+version = "0.0.130"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [
@@ -61,6 +61,7 @@ telemetry = [
     "posthog>=3.0.0"
 ]
 
+
 # Combined features
 all = [
     "praisonaiagents[memory]",

src/praisonai-agents/test_async_sequential.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""Test script to verify async task execution in sequential mode"""
+
+import asyncio
+import time
+import os
+from datetime import datetime
+
+# Set up the environment
+import sys
+sys.path.insert(0, '/home/runner/work/PraisonAI/PraisonAI/src/praisonai-agents')
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create test agents
+async_agent = Agent(
+    name="AsyncAgent",
+    role="Async task executor",
+    goal="Execute async tasks",
+    backstory="An agent that executes async tasks",
+    llm="openai/gpt-3.5-turbo"  # Using a mock/test LLM
+)
+
+sync_agent = Agent(
+    name="SyncAgent", 
+    role="Sync task executor",
+    goal="Execute sync tasks",
+    backstory="An agent that executes sync tasks",
+    llm="openai/gpt-3.5-turbo"
+)
+
+# Track execution times
+execution_log = []
+
+def log_execution(task_name, start_time, end_time, is_async):
+    execution_log.append({
+        "task": task_name,
+        "start": start_time,
+        "end": end_time,
+        "duration": end_time - start_time,
+        "type": "async" if is_async else "sync"
+    })
+
+# Create test tasks
+async def async_task_function(task_name, delay):
+    start_time = time.time()
+    print(f"{datetime.now().strftime('%H:%M:%S.%f')[:-3]} - {task_name} started (async)")
+    await asyncio.sleep(delay)
+    end_time = time.time()
+    print(f"{datetime.now().strftime('%H:%M:%S.%f')[:-3]} - {task_name} completed (async)")
+    log_execution(task_name, start_time, end_time, True)
+    return f"{task_name} result after {delay}s"
+
+def sync_task_function(task_name, delay):
+    start_time = time.time()
+    print(f"{datetime.now().strftime('%H:%M:%S.%f')[:-3]} - {task_name} started (sync)")
+    time.sleep(delay)
+    end_time = time.time()
+    print(f"{datetime.now().strftime('%H:%M:%S.%f')[:-3]} - {task_name} completed (sync)")
+    log_execution(task_name, start_time, end_time, False)
+    return f"{task_name} result after {delay}s"
+
+# Test scenario: Multiple async tasks followed by sync task followed by more async tasks
+tasks = []
+
+# First batch of async tasks (should run in parallel)
+task1 = Task(
+    name="async_task_1",
+    description="First async task - sleep 2s",
+    expected_output="Task result",
+    agent=async_agent,
+    async_execution=True
+)
+
+task2 = Task(
+    name="async_task_2", 
+    description="Second async task - sleep 2s",
+    expected_output="Task result",
+    agent=async_agent,
+    async_execution=True
+)
+
+task3 = Task(
+    name="async_task_3",
+    description="Third async task - sleep 2s", 
+    expected_output="Task result",
+    agent=async_agent,
+    async_execution=True
+)
+
+# Sync task (should wait for async tasks to complete)
+task4 = Task(
+    name="sync_task_1",
+    description="First sync task - sleep 1s",
+    expected_output="Task result",
+    agent=sync_agent,
+    async_execution=False
+)
+
+# Second batch of async tasks (should run in parallel after sync task)
+task5 = Task(
+    name="async_task_4",
+    description="Fourth async task - sleep 1s",
+    expected_output="Task result", 
+    agent=async_agent,
+    async_execution=True
+)
+
+task6 = Task(
+    name="async_task_5",
+    description="Fifth async task - sleep 1s",
+    expected_output="Task result",
+    agent=async_agent,
+    async_execution=True
+)
+
+tasks = [task1, task2, task3, task4, task5, task6]
+
+async def test_sequential_async_execution():
+    """Test that async tasks run in parallel in sequential mode"""
+    
+    print("\n=== Testing Sequential Mode with Async Tasks ===\n")
+    
+    # Mock the agent execute methods to use our test functions
+    original_execute = Agent.execute
+    original_aexecute = Agent.aexecute
+    
+    def mock_execute(self, task, context=None):
+        if "async" in task.name:
+            # This shouldn't be called for async tasks
+            print(f"WARNING: Sync execute called for async task {task.name}")
+        else:
+            delay = int(task.description.split("sleep ")[1].split("s")[0])
+            return sync_task_function(task.name, delay)
+    
+    async def mock_aexecute(self, task, context=None):
+        if "async" in task.name:
+            delay = int(task.description.split("sleep ")[1].split("s")[0])
+            return await async_task_function(task.name, delay)
+        else:
+            # This shouldn't be called for sync tasks
+            print(f"WARNING: Async execute called for sync task {task.name}")
+    
+    # Patch the methods
+    Agent.execute = mock_execute
+    Agent.aexecute = mock_aexecute
+    
+    try:
+        # Create workflow
+        workflow = PraisonAIAgents(
+            agents=[async_agent, sync_agent],
+            tasks=tasks,
+            process="sequential",
+            verbose=True
+        )
+        
+        # Run the workflow
+        start_time = time.time()
+        await workflow.astart()
+        end_time = time.time()
+        
+        print(f"\nTotal execution time: {end_time - start_time:.2f}s")
+        
+        # Analyze results
+        print("\n=== Execution Analysis ===")
+        
+        # Check if first batch of async tasks ran in parallel
+        async_batch1 = [log for log in execution_log if log["task"] in ["async_task_1", "async_task_2", "async_task_3"]]
+        if async_batch1:
+            earliest_start = min(log["start"] for log in async_batch1)
+            latest_end = max(log["end"] for log in async_batch1)
+            batch1_duration = latest_end - earliest_start
+            print(f"\nFirst async batch (3 tasks, 2s each):")
+            print(f"  - Started at: {earliest_start:.2f}")
+            print(f"  - Ended at: {latest_end:.2f}")
+            print(f"  - Total duration: {batch1_duration:.2f}s")
+            print(f"  - Parallel execution: {'YES' if batch1_duration < 4 else 'NO'} (expected ~2s for parallel, 6s for sequential)")
+        
+        # Check sync task timing
+        sync_logs = [log for log in execution_log if log["type"] == "sync"]
+        if sync_logs:
+            sync_log = sync_logs[0]
+            print(f"\nSync task:")
+            print(f"  - Started at: {sync_log['start']:.2f}")
+            print(f"  - Ended at: {sync_log['end']:.2f}")
+            print(f"  - Started after async batch: {'YES' if sync_log['start'] >= latest_end - 0.1 else 'NO'}")
+        
+        # Check if second batch of async tasks ran in parallel
+        async_batch2 = [log for log in execution_log if log["task"] in ["async_task_4", "async_task_5"]]
+        if async_batch2:
+            earliest_start = min(log["start"] for log in async_batch2)
+            latest_end = max(log["end"] for log in async_batch2)
+            batch2_duration = latest_end - earliest_start
+            print(f"\nSecond async batch (2 tasks, 1s each):")
+            print(f"  - Started at: {earliest_start:.2f}")
+            print(f"  - Ended at: {latest_end:.2f}")
+            print(f"  - Total duration: {batch2_duration:.2f}s")
+            print(f"  - Parallel execution: {'YES' if batch2_duration < 1.5 else 'NO'} (expected ~1s for parallel, 2s for sequential)")
+        
+        # Overall assessment
+        print(f"\n=== Test Result ===")
+        expected_time = 2 + 1 + 1  # First batch (2s parallel) + sync (1s) + second batch (1s parallel)
+        actual_time = end_time - start_time
+        print(f"Expected total time (with parallel async): ~{expected_time}s")
+        print(f"Actual total time: {actual_time:.2f}s")
+        
+        if actual_time < expected_time + 1:  # Allow 1s margin for overhead
+            print("✅ PASS: Async tasks executed in parallel!")
+        else:
+            print("❌ FAIL: Async tasks did not execute in parallel as expected")
+            
+    finally:
+        # Restore original methods
+        Agent.execute = original_execute
+        Agent.aexecute = original_aexecute
+
+if __name__ == "__main__":
+    # Set a dummy API key to avoid errors
+    os.environ["OPENAI_API_KEY"] = "test-key"
+    
+    # Run the test
+    asyncio.run(test_sequential_async_execution())

src/praisonai-agents/tests/memory_example.py

@@ -101,6 +101,15 @@ def main():
     )
 
     # Initialize PraisonAIAgents with memory configuration
+    # Option 1: Use default OpenAI embeddings
+    # agents = PraisonAIAgents(
+    #     agents=[researcher, retriever],
+    #     tasks=[store_task, verify_task, query_task, query_both_task],
+    #     verbose=True,
+    #     memory=True
+    # )
+    
+    # Option 2: Explicitly configure OpenAI embeddings
     agents = PraisonAIAgents(
         agents=[researcher, retriever],
         tasks=[store_task, verify_task, query_task, query_both_task],
@@ -113,12 +122,19 @@ def main():
             }
         }
     )
-
+    
+    # Option 3: Use Gemini embeddings
     # agents = PraisonAIAgents(
     #     agents=[researcher, retriever],
     #     tasks=[store_task, verify_task, query_task, query_both_task],
-    #     verbose=True,  # Use same verbose level as memory
-    #     memory=True
+    #     verbose=True,
+    #     memory=True,
+    #     embedder={
+    #         "provider": "gemini",
+    #         "config": {
+    #             "model": "text-embedding-004"
+    #         }
+    #     }
     # )
     
     # Execute tasks

src/praisonai-agents/uv.lock

@@ -2375,7 +2375,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.129"
+version = "0.0.130"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

src/praisonai/praisonai.rb

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

src/praisonai/praisonai/deploy.py

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

src/praisonai/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.2.55"
+version = "2.2.56"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 readme = "README.md"
 license = ""
@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.129",
+    "praisonaiagents>=0.0.130",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",
@@ -95,7 +95,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.15", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.2.55"
+version = "2.2.56"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
@@ -113,7 +113,7 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.129"
+praisonaiagents = ">=0.0.130"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"

src/praisonai/uv.lock

@@ -3932,7 +3932,7 @@ wheels = [
 
 [[package]]
 name = "praisonai"
-version = "2.2.55"
+version = "2.2.56"
 source = { editable = "." }
 dependencies = [
     { name = "instructor" },
@@ -4074,7 +4074,7 @@ requires-dist = [
     { name = "plotly", marker = "extra == 'realtime'", specifier = ">=5.24.0" },
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.15" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.15" },
-    { name = "praisonaiagents", specifier = ">=0.0.129" },
+    { name = "praisonaiagents", specifier = ">=0.0.130" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = ">=0.2.19" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -4132,7 +4132,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.129"
+version = "0.0.130"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -4142,9 +4142,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/50/dd/9d43daf1c23fe7dcc444ebc0d0cec1f7472854ce1513607f261e477c19ee/praisonaiagents-0.0.129.tar.gz", hash = "sha256:411f0c984f877ee3473d8f914c219b1c519dd7bd35668c41434fd4f865849a6e", size = 192779, upload-time = "2025-07-14T10:08:37.744Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/30/3a/e4f4bf6724051ada87c8f4a02615075b7c9b3963bdb37268d79f8a2bde08/praisonaiagents-0.0.130.tar.gz", hash = "sha256:0f893fdb65b68b489d7a9daf732a9c0c8eb2ce942d2c7b1c073d41e9496da239", size = 193079, upload-time = "2025-07-14T16:26:59.782Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3a/1e/823fa0c77061dc914562670dcd71b5808a9d41e96c6cb182999d1615c92b/praisonaiagents-0.0.129-py3-none-any.whl", hash = "sha256:aae6f68291fb4cf6d75d7e74cd2359b5a7d9a584de12fa196f5b808fea2e4209", size = 214139, upload-time = "2025-07-14T10:08:36.075Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/8e/54f1858a001dbaf0a97b31406e06bfd47cbdf335b2ee509f591fcd4311de/praisonaiagents-0.0.130-py3-none-any.whl", hash = "sha256:c75983e55f9a0bd74905c28f7000acdd6d5516e519ce2aa5ef3e37048544ea6e", size = 214415, upload-time = "2025-07-14T16:26:58.109Z" },
 ]
 
 [[package]]

test_callback_fix.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Test script to verify callbacks work with verbose=False"""
+
+import sys
+sys.path.insert(0, 'src/praisonai-agents')
+
+from praisonaiagents import (
+    register_display_callback,
+    Agent, 
+    Task, 
+    PraisonAIAgents
+)
+
+# Track if callback was executed
+callback_executed = False
+
+def simple_callback(message=None, response=None, **kwargs):
+    global callback_executed
+    callback_executed = True
+    with open('callback_test_log.txt', 'a') as f:
+        f.write(f"CALLBACK EXECUTED!\n")
+        f.write(f"Message: {message}\n")
+        f.write(f"Response: {response}\n")
+        f.write(f"Other kwargs: {kwargs}\n")
+        f.write("-" * 50 + "\n")
+
+# Register callback
+register_display_callback('interaction', simple_callback, is_async=False)
+
+# Test with verbose=False
+print("Testing with verbose=False...")
+agent = Agent(
+    name="TestAgent",
+    role="Assistant",
+    goal="Help with tasks",
+    backstory="I am a helpful assistant",
+    llm="openai/gpt-4o-mini",  # Using a simple model for testing
+    verbose=False
+)
+
+task = Task(
+    name="simple_task",
+    description="Say hello world",
+    agent=agent,
+    expected_output="A greeting"
+)
+
+# Clear the log file
+with open('callback_test_log.txt', 'w') as f:
+    f.write("Starting test with verbose=False\n")
+
+# Run the agent
+try:
+    agents = PraisonAIAgents(
+        agents=[agent],
+        tasks=[task]
+    )
+    result = agents.start()
+    print(f"Task completed. Result: {result}")
+    print(f"Callback executed: {callback_executed}")
+    
+    # Check if callback was executed
+    if callback_executed:
+        print("✅ SUCCESS: Callback was executed with verbose=False!")
+    else:
+        print("❌ FAILED: Callback was NOT executed with verbose=False")
+        
+except Exception as e:
+    print(f"Error during test: {e}")
+    import traceback
+    traceback.print_exc()

test_gemini_embedding.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Test script for Gemini embedding support in PraisonAI"""
+
+import os
+import sys
+import json
+import logging
+
+# Add the source directory to Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src/praisonai-agents'))
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def test_gemini_embedding():
+    """Test Gemini embedding model integration"""
+    
+    # Test with OpenAI embedding (backward compatibility)
+    print("\n" + "="*50)
+    print("Testing OpenAI Embedding (Backward Compatibility)")
+    print("="*50)
+    
+    # Create a simple agent
+    agent = Agent(
+        name="Test Agent",
+        role="Memory Tester",
+        goal="Test memory storage with embeddings",
+        backstory="An agent that tests memory functionality",
+        llm="gpt-4o-mini"
+    )
+    
+    # Create a task
+    task = Task(
+        description="Remember this fact: The capital of France is Paris. This is a test fact for memory storage.",
+        expected_output="Confirmation that the fact has been stored",
+        agent=agent
+    )
+    
+    # Test with default OpenAI embeddings
+    agents_openai = PraisonAIAgents(
+        agents=[agent],
+        tasks=[task],
+        verbose=5,
+        memory=True
+    )
+    
+    print("\nRunning with default OpenAI embeddings...")
+    agents_openai.start()
+    
+    # Test with explicit OpenAI embedding config
+    print("\n" + "="*50)
+    print("Testing Explicit OpenAI Embedding Configuration")
+    print("="*50)
+    
+    agent2 = Agent(
+        name="Test Agent 2",
+        role="Memory Tester",
+        goal="Test memory storage with explicit OpenAI embeddings",
+        backstory="An agent that tests memory functionality",
+        llm="gpt-4o-mini"
+    )
+    
+    task2 = Task(
+        description="Remember this fact: The Eiffel Tower is 330 meters tall. This is another test fact.",
+        expected_output="Confirmation that the fact has been stored",
+        agent=agent2
+    )
+    
+    agents_openai_explicit = PraisonAIAgents(
+        agents=[agent2],
+        tasks=[task2],
+        verbose=5,
+        memory=True,
+        embedder={
+            "provider": "openai",
+            "config": {
+                "model": "text-embedding-3-small"
+            }
+        }
+    )
+    
+    print("\nRunning with explicit OpenAI embedding config...")
+    agents_openai_explicit.start()
+    
+    # Test with Gemini embeddings
+    print("\n" + "="*50)
+    print("Testing Gemini Embedding Model")
+    print("="*50)
+    
+    agent3 = Agent(
+        name="Gemini Test Agent",
+        role="Memory Tester with Gemini",
+        goal="Test memory storage with Gemini embeddings",
+        backstory="An agent that tests Gemini embedding functionality",
+        llm="gpt-4o-mini"  # Still use GPT for chat, but Gemini for embeddings
+    )
+    
+    task3 = Task(
+        description="Remember this fact: Google released Gemini in 2023. This tests Gemini embedding storage.",
+        expected_output="Confirmation that the fact has been stored using Gemini embeddings",
+        agent=agent3
+    )
+    
+    # Configure with Gemini embeddings
+    agents_gemini = PraisonAIAgents(
+        agents=[agent3],
+        tasks=[task3],
+        verbose=5,
+        memory=True,
+        embedder={
+            "provider": "gemini",
+            "config": {
+                "model": "text-embedding-004"  # Gemini embedding model
+            }
+        }
+    )
+    
+    print("\nRunning with Gemini embeddings...")
+    try:
+        agents_gemini.start()
+        print("\n✅ Gemini embedding test completed successfully!")
+    except Exception as e:
+        print(f"\n❌ Gemini embedding test failed: {e}")
+        logger.error(f"Error details: {e}", exc_info=True)
+    
+    # Test memory search across different embedding models
+    print("\n" + "="*50)
+    print("Testing Memory Search")
+    print("="*50)
+    
+    if agents_gemini.shared_memory:
+        print("\nSearching for 'Gemini' in memory...")
+        results = agents_gemini.shared_memory.search_long_term("Gemini", limit=5)
+        print(f"Found {len(results)} results")
+        for i, result in enumerate(results):
+            print(f"\nResult {i+1}:")
+            print(f"  Text: {result.get('text', '')[:100]}...")
+            print(f"  Score: {result.get('score', 'N/A')}")
+
+    print("\n" + "="*50)
+    print("All tests completed!")
+    print("="*50)
+
+if __name__ == "__main__":
+    # Check if Google API key is set
+    if not os.environ.get("GOOGLE_API_KEY"):
+        print("\n⚠️  Warning: GOOGLE_API_KEY not found in environment variables.")
+        print("   Gemini embedding test will likely fail without it.")
+        print("   Set it with: export GOOGLE_API_KEY='your-api-key'")
+    
+    test_gemini_embedding()

test_issue_877.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""
+Test script to reproduce and verify the fix for issue #877
+where callbacks only work when verbose=True.
+"""
+
+import sys
+sys.path.insert(0, 'src/praisonai-agents')
+
+from praisonaiagents import (
+    register_display_callback,
+    Agent, 
+    Task, 
+    PraisonAIAgents
+)
+
+# Track callback execution
+callback_log = []
+
+def simple_callback(message=None, response=None, **kwargs):
+    callback_log.append({
+        'message': message,
+        'response': response,
+        'kwargs': kwargs
+    })
+    with open('callback_log.txt', 'a') as f:
+        f.write(f"Received message: {message}\n")
+        f.write(f"Got response: {response}\n")
+        f.write(f"Other stuff: {kwargs}\n\n")
+
+# Clear the log file
+with open('callback_log.txt', 'w') as f:
+    f.write("=== Testing Callback Issue #877 ===\n\n")
+
+# Register as synchronous callback
+register_display_callback('interaction', simple_callback, is_async=False)
+
+print("=" * 60)
+print("Testing Issue #877: Callbacks Only Work When verbose=True")
+print("=" * 60)
+
+# Test Case 1: verbose=False
+print("\nTest Case 1: verbose=False")
+print("-" * 30)
+callback_log.clear()
+
+agent1 = Agent(
+    name="MyAgent",
+    role="Assistant",
+    goal="Help with tasks",
+    backstory="I am a helpful assistant",
+    llm="gemini/gemini-2.5-flash-lite-preview-06-17",  # Using the same model as in the issue
+    verbose=False  
+)
+
+task1 = Task(
+    name="simple_task",
+    description="Say the number 1",
+    agent=agent1,
+    expected_output="1"
+)
+
+try:
+    agents1 = PraisonAIAgents(
+        agents=[agent1],
+        tasks=[task1]
+    )
+    result1 = agents1.start()
+    print(f"Task completed. Callbacks executed: {len(callback_log)}")
+    if len(callback_log) > 0:
+        print("✅ SUCCESS: Callbacks were executed with verbose=False!")
+        print(f"   First callback: message='{callback_log[0]['message'][:50]}...', response='{callback_log[0]['response'][:50]}...'")
+    else:
+        print("❌ FAILED: No callbacks were executed with verbose=False")
+except Exception as e:
+    print(f"❌ ERROR during test: {e}")
+    import traceback
+    traceback.print_exc()
+
+# Test Case 2: verbose=True (for comparison)
+print("\n\nTest Case 2: verbose=True (for comparison)")
+print("-" * 30)
+callback_log.clear()
+
+agent2 = Agent(
+    name="MyAgent",
+    role="Assistant",
+    goal="Help with tasks",
+    backstory="I am a helpful assistant",
+    llm="gemini/gemini-2.5-flash-lite-preview-06-17",
+    verbose=True  
+)
+
+task2 = Task(
+    name="simple_task",
+    description="Say the number 2",
+    agent=agent2,
+    expected_output="2"
+)
+
+try:
+    agents2 = PraisonAIAgents(
+        agents=[agent2],
+        tasks=[task2]
+    )
+    result2 = agents2.start()
+    print(f"\nTask completed. Callbacks executed: {len(callback_log)}")
+    if len(callback_log) > 0:
+        print("✅ Callbacks were executed with verbose=True as expected")
+        print(f"   First callback: message='{callback_log[0]['message'][:50]}...', response='{callback_log[0]['response'][:50]}...'")
+    else:
+        print("⚠️  WARNING: No callbacks were executed even with verbose=True")
+except Exception as e:
+    print(f"❌ ERROR during test: {e}")
+    import traceback
+    traceback.print_exc()
+
+print("\n" + "=" * 60)
+print("Test Results Summary:")
+print("-" * 30)
+print("Check callback_log.txt for detailed callback logs")
+print("=" * 60)