Merge pull request #609 from MervinPraison/develop

Develop
Update PraisonAI version to 2.2.29 across Dockerfiles and related files
2026-11-09 03:39:37 -10:00 · 2025-06-05 17:55:15 +01:00 · 2025-06-05 17:54:57 +01:00 · 2025-06-05 17:53:38 +01:00 · 2025-06-05 17:43:36 +01:00 · 2025-06-05 17:43:19 +01:00
22 changed files with 1889 additions and 35 deletions
@@ -74,4 +74,5 @@ agents/praisonaiagents/praisonaiagents.egg-info
 .praison
 # Local Netlify folder
 .netlify
-.qodo
+.qodo
+CopilotKit*
@@ -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.28" \
+    "praisonai>=2.2.29" \
    "praisonai[api]" \
    gunicorn \
    markdown
@@ -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.28" \
+    "praisonai>=2.2.29" \
    "praisonai[chat]" \
    "embedchain[github,youtube]"

@@ -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.28" \
+    "praisonai>=2.2.29" \
    "praisonai[ui]" \
    "praisonai[chat]" \
    "praisonai[realtime]" \
@@ -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.28" \
+    "praisonai>=2.2.29" \
    "praisonai[ui]" \
    "praisonai[crewai]"

@@ -121,7 +121,7 @@ healthcheck:
 ## 📦 Package Versions

 All Docker images use consistent, up-to-date versions:
- PraisonAI: `>=2.2.28`
+- PraisonAI: `>=2.2.29`
 - 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.28" "praisonaiagents==0.0.92"
+RUN pip install "praisonai==2.2.29" "praisonaiagents==0.0.92"
 ```

 ## 🌐 Production Deployment
@@ -14,7 +14,11 @@
    {
      "cell_type": "markdown",
      "source": [
+
+        "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DhivyaBharathy-web/PraisonAI/blob/main/examples/cookbooks/Code_Analysis_Agent.ipynb)\n"
+=======
        "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DhivyaBharathy-web/PraisonAI/blob/main/examples/cookbooks/code_analysis_agent.ipynb)\n"
+
      ],
      "metadata": {
        "id": "P3X8PXPyojnL"
@@ -456,4 +460,8 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+
+}
+=======
+}
+
@@ -0,0 +1,605 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "PnWDOzZelHlE",
+   "metadata": {
+    "id": "PnWDOzZelHlE"
+   },
+   "source": [
+    "# 🌱 Gemma 2B Instruction Agent\n",
+    "\n",
+    "**Goal:** You will learn how to do data prep, how to train, how to run the model, and how to save it using Google’s `gemma-2b-it` open-source model.\n",
+    "\n",
+    "---\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4qumJb5qs9CF",
+   "metadata": {
+    "id": "4qumJb5qs9CF"
+   },
+   "source": [
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DhivyaBharathy-web/PraisonAI/blob/main/examples/cookbooks/Gemma2B_Instruction_Agent.ipynb)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "qdsqiQDosXmA",
+   "metadata": {
+    "id": "qdsqiQDosXmA"
+   },
+   "source": [
+    "#  Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6G4RPDe3lHlH",
+   "metadata": {
+    "id": "6G4RPDe3lHlH"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install transformers accelerate datasets bitsandbytes -q"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "mop0KNO7sdEl",
+   "metadata": {
+    "id": "mop0KNO7sdEl"
+   },
+   "source": [
+    "# Tools & Model Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "spOeRX2UlHlI",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 369,
+     "referenced_widgets": [
+      "a2db67e368d94f579c59b36c6ce7af33",
+      "5816fa4288cd42d6b15094e2c79f760f",
+      "5d6fe9b464f944cdbb00b9936669e737",
+      "19920e5b8157423ba5d173dd376e52e6",
+      "bd7157974bc5485ab5b6db54facb9721",
+      "0063e7320c98440d91ae475596c5cd90",
+      "a0f045bc54754d5a85ed6bf7b6b33c1a",
+      "9174c5aff19b4caab8a38fbf3acb2449",
+      "3de0f0b7ecb34c488145b24e30418e4b",
+      "d4457543819d468eb916f126382184b0",
+      "08f90c04f0de4b1db57624db4b43e17d",
+      "269373e971704b9ea2e10e261b1c56d1",
+      "d54d35c945ce4f75af6f83f37dd6af6c",
+      "b828857fecdc40fa91f6a8633f0f20b4",
+      "b5e70949aea24ae9a75e45aa291cc3aa",
+      "9c556838b24246a8b39b1f3f9babfe4a",
+      "062b64d17b7043c1bccc419280c9db0a",
+      "138ae14327184f65896c29a424bad18d",
+      "cb65fa660df54218ad804815dfba4071",
+      "93d2454f1b564896bef50906e859c660",
+      "64e7861e6afc4b57b28063096533aac8",
+      "13fe0b8a8fd14a3684ae5d9beefb3f76",
+      "d1ec61e51d4c4b07b301959c4919f2a2",
+      "a45e9ed3d46645a18ca1f6b06f875ec9",
+      "a364770555cf40fdab5ff7bb85997127",
+      "12b3225aeb8c4f61b23b588738d48683",
+      "dca4952bae4c49ddb2fec2c36726a34d",
+      "163df8921f04425caed240465d8bd8b7",
+      "1a09718a80cd4bb5a9e985a3f599c614",
+      "71c719d57e4f4e23bd520f80e2e07e33",
+      "5e8c8eb7eba948fc8a39b601e9ac658e",
+      "db4fa2c97b7247c4826a1a9f69c1bed3",
+      "42a6f9c136584cc98fc2be973d9edaec",
+      "c1bc8cf2ed6542c49c1940673a662b1d",
+      "365b69634e2846a09b91de6b61d0719b",
+      "13eb69bc1c3c432db6c504856f3a0f7a",
+      "56444404d97549848ed729ee8bc14ec8",
+      "f0303454544d42a1ada2213a085a4ac0",
+      "c717969ed1b145a9af67d74482d49eab",
+      "9e9a826dfb264e44aa69c553d978729d",
+      "f2b4ff56a96c4d7e9f56668f6b7b5213",
+      "f71f0a3ccc654df288d7489abca0ffc0",
+      "5ab0574ed1db47e9b6f43e27acd6c2b2",
+      "426fae423dbb43ef9252e6fcfb099c6f",
+      "2e1c3ca06b2948f0bcf53a975dd67aec",
+      "3685a74a466a4ca0b5f05e7aee631d74",
+      "7bda5a4e803c4cbc8da67da8a565725b",
+      "5450fde9a54d450d90d14b009047b522",
+      "e827839bf4d34d2193776d1ee90d27ad",
+      "3d9854af016a4c3c8a582fc7f0f0b0bf",
+      "7045a11d5f0f4b2d8ff224bb76a9c943",
+      "32e568b25c2d447a8fa63055cb44c75c",
+      "ebd9d55db82542e5ae6bb9e715e36a6a",
+      "798a57883792465ab024dc19a58a54be",
+      "c9d1133770b44b22bda89f3d0eecd4f8",
+      "c040fa1bbd9f442884776fdf33efb4a2",
+      "c57e497d4fd546ff950eb2c898b94c88",
+      "5ae22935b7374219a16272cef31d6d9e",
+      "aae2686ee64740218d046ec37e50b584",
+      "87b4c953163a4cff8a88b76f40da9de8",
+      "30ee0e766fae44bfb570ae8adfba1a54",
+      "1c2db67dfc904e30a4013d9fe0253a4c",
+      "f6c5380bba0f40a4bea9b78d205eb726",
+      "0de9f765500b45428f828ad173dd279e",
+      "0663e5cfc20c496993b7c0054ce3d1a1",
+      "7ce5d369129b461681f424e52415e534",
+      "dfa90d76c670436a80f1a4fd0971b171",
+      "0694216654ac41909d567a8c4af247de",
+      "658048f25b4a4ad6a3ee66e97a542cc9",
+      "0edccfd243f940cfad9723b1d3f5a97c",
+      "32d473040a6744718b1b35543f2b3a0f",
+      "eadbfe846763427e98a40597560d8519",
+      "3cec8231bccb4bcf8d657ee8d2120f79",
+      "8bd43207fa8f4b309590f605ad81354f",
+      "8821912860f04105959ceb42e53de948",
+      "3666b044c757439f948f6942d7682c2f",
+      "d47e7c7504374fee82eef9f8cbe24eff",
+      "9c6d577f113f4f4baaa1f0e001549862",
+      "b0c88d34b0df46b7a3da8db42ff3274e",
+      "e4e4a2d0422b45c09c8691ce14ba9b9a",
+      "d9b1de1b37f14d70bc56a5f6cb468c9b",
+      "cb95b11368984236937fcec7cb689b04",
+      "69e70bfdafd4459491bad75651028626",
+      "a3b9f03c1f014691b5959fb9012c0bab",
+      "088da12bcff64297ad82dc7b2d01709e",
+      "8a69dc8aa84e49b1aabb58eddca1eee3",
+      "263e458b8a5f405bb1ee365fe561309d",
+      "aa3039e03447492da11f86185384470b",
+      "3c22264e11c0402fb07f56a0763dc055",
+      "db2c5746b8cc48d9a059bcef3b55217d",
+      "ad3ab2ab81f6469485a3072bd1ba6a4a",
+      "74ab1c79c43041c7ac314d62a6da04bf",
+      "ad1a3719b1814f6b88202e131ae923c7",
+      "d1cb72251682425fa6ca68341a084f95",
+      "895914fca4204593b1a4314e50b8e5a1",
+      "a8374dc19b294b6d8f5f92bee5196a1a",
+      "b7bef910950949fbac65fd996ad058e2",
+      "ce6b7aadbd904b3caa93d927ced6beb3",
+      "ba6a9e31ddf7419db317a5d27a1567bf",
+      "f271e9c78dcf4ab686caac37f18bd6f7",
+      "9ed57fe81783476986d6cb98d07e9aa1",
+      "8da75a35ab184675b0164682d8217406",
+      "f411c4485b844ceb9b3116f209a6fc86",
+      "60ac9cd6505141348323b39db7314554",
+      "59b2d494f11344879463a3471716bc3f",
+      "46abda4b52224874a93b729f5d4d195b",
+      "37bc81b97d48474aa0fd7e7739654d86",
+      "73da5101d99440abac30dc8c084439d4",
+      "ef790742325743fdb8f7cc6822388185",
+      "5eccfbe5715f4df9a96cffb2573f916f",
+      "3bf293367470430f84f341ef8711460a",
+      "317281ca2af54a148fa4cfd8f6e0f382",
+      "d655ef37643448aa95253143f8552f58",
+      "158e61376dee400e820f47c87d59bac5",
+      "d1fbbe8010e340119bf556c75284e1c2",
+      "eea1731926554e56a85867de15153f82",
+      "766fb34d23b941b2a9e0de153f4cb031",
+      "beb52b95db564105bbd8bc2b2d21c1ce",
+      "2effd1c45bee4278bd9172310f58fed4",
+      "91d6488876284748932b664953c02146",
+      "9157d82cca3f45c5b5a666a3d35d6abe"
+     ]
+    },
+    "id": "spOeRX2UlHlI",
+    "outputId": "093b74d1-9ece-4db5-d177-3aff6e2d6e0b"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a2db67e368d94f579c59b36c6ce7af33",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json:   0%|          | 0.00/47.0k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "269373e971704b9ea2e10e261b1c56d1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.model:   0%|          | 0.00/4.24M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d1ec61e51d4c4b07b301959c4919f2a2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json:   0%|          | 0.00/17.5M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c1bc8cf2ed6542c49c1940673a662b1d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "special_tokens_map.json:   0%|          | 0.00/636 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2e1c3ca06b2948f0bcf53a975dd67aec",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/838 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c040fa1bbd9f442884776fdf33efb4a2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model.safetensors.index.json:   0%|          | 0.00/24.2k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "dfa90d76c670436a80f1a4fd0971b171",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Fetching 2 files:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9c6d577f113f4f4baaa1f0e001549862",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model-00001-of-00002.safetensors:   0%|          | 0.00/4.99G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3c22264e11c0402fb07f56a0763dc055",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model-00002-of-00002.safetensors:   0%|          | 0.00/241M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f271e9c78dcf4ab686caac37f18bd6f7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3bf293367470430f84f341ef8711460a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "generation_config.json:   0%|          | 0.00/187 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from huggingface_hub import login\n",
+    "from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer\n",
+    "from datasets import load_dataset\n",
+    "import torch\n",
+    "\n",
+    "login(\"Enter your token here\")\n",
+    "\n",
+    "model_id = \"google/gemma-2-2b-it\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_id)\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    model_id,\n",
+    "    device_map=\"auto\",              # Automatically selects GPU if available\n",
+    "    torch_dtype=torch.float16       # Optimized for performance\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "GaykKFKYspMd",
+   "metadata": {
+    "id": "GaykKFKYspMd"
+   },
+   "source": [
+    "# Yaml Prompt Configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "iLBZ7WPAlHlJ",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "iLBZ7WPAlHlJ",
+    "outputId": "a99fc3f2-68e0-4af8-cfbd-3c48a865538f"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "You are Qwen, a helpful assistant.\n",
+      "User: What is the capital of France?\n",
+      "Assistant: The capital of France is **Paris**. \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "prompt = \"You are Qwen, a helpful assistant.\\nUser: What is the capital of France?\\nAssistant:\"\n",
+    "inputs = tokenizer(prompt, return_tensors=\"pt\").to(model.device)\n",
+    "outputs = model.generate(**inputs, max_new_tokens=100)\n",
+    "response = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "print(response)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "XPqtCExSsvhn",
+   "metadata": {
+    "id": "XPqtCExSsvhn"
+   },
+   "source": [
+    "# Use a small sample dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "ActfjFx0lHlK",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 49,
+     "referenced_widgets": [
+      "f1028b5dcab4460c81b09802ca7ec89c",
+      "ff33dcccaad945e9bf136d0f72e38d74",
+      "eec3a11b0605435d8d1e55092f5e5b85",
+      "d997b7bc993b4aa58cfafa7c59829ad3",
+      "62e2dc508746419ba3c0405a7199c6dc",
+      "2a7fc59019c749aa98d0e970a9b6b168",
+      "78067f66c8544020aa262c0012aa019b",
+      "f5e511b4279747c0a33b10f499a4f718",
+      "10e248a5730c4c09834b4065b6dd7843",
+      "bbd5a106c1de43e497987648899569e0",
+      "118faf3d1ed142038af4783fb3ba86cc"
+     ]
+    },
+    "id": "ActfjFx0lHlK",
+    "outputId": "f257e553-7baa-4f1e-b531-a6b7dc358665"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f1028b5dcab4460c81b09802ca7ec89c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/4 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from datasets import Dataset\n",
+    "\n",
+    "sample_data = {\n",
+    "    'text': [\n",
+    "        'The sun is a star at the center of our solar system.',\n",
+    "        'Photosynthesis is the process by which green plants make food.',\n",
+    "        'Water freezes at 0 degrees Celsius.',\n",
+    "        'The Earth revolves around the sun in 365 days.'\n",
+    "    ]\n",
+    "}\n",
+    "\n",
+    "dataset = Dataset.from_dict(sample_data)\n",
+    "\n",
+    "def tokenize_function(example):\n",
+    "    return tokenizer(example['text'], padding='max_length', truncation=True, max_length=64)\n",
+    "\n",
+    "tokenized_dataset = dataset.map(tokenize_function)\n",
+    "tokenized_dataset.set_format(type='torch', columns=['input_ids', 'attention_mask'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "x7icWpOnszjj",
+   "metadata": {
+    "id": "x7icWpOnszjj"
+   },
+   "source": [
+    "# Inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "8mM4PAhRlHlL",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "8mM4PAhRlHlL",
+    "outputId": "1ba90639-b847-4cb1-df42-3fdd644e4cb8"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "user\n",
+      "Explain photosynthesis to a child.\n",
+      "model\n",
+      "Imagine plants are like tiny chefs, and they cook their own food! \n",
+      "\n",
+      "They use sunlight, air, and water to make yummy food called sugar.  \n",
+      "\n",
+      "Here's how it works:\n",
+      "\n",
+      "1. **Sunlight:** Plants have special green stuff called chlorophyll that acts like a solar panel, soaking up the sun's energy.\n",
+      "2. **Air:** Plants take in air through tiny holes in their leaves called stomata.  The air has a gas called carbon dioxide.\n",
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "input_text = \"Explain photosynthesis to a child.\"\n",
+    "chat = tokenizer.apply_chat_template(\n",
+    "    [{\"role\": \"user\", \"content\": input_text}],\n",
+    "    tokenize=False,\n",
+    "    add_generation_prompt=True\n",
+    ")\n",
+    "inputs = tokenizer(chat, return_tensors=\"pt\").to(model.device)\n",
+    "output = model.generate(**inputs, max_new_tokens=100)\n",
+    "print(tokenizer.decode(output[0], skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "Fhkfhbjns2oq",
+   "metadata": {
+    "id": "Fhkfhbjns2oq"
+   },
+   "source": [
+    "# Save Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "OuJEt2-jlHlL",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "OuJEt2-jlHlL",
+    "outputId": "f076e950-cce7-4850-edd9-ff1d84a096d6"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('gemma-finetuned-demo/tokenizer_config.json',\n",
+       " 'gemma-finetuned-demo/special_tokens_map.json',\n",
+       " 'gemma-finetuned-demo/chat_template.jinja',\n",
+       " 'gemma-finetuned-demo/tokenizer.model',\n",
+       " 'gemma-finetuned-demo/added_tokens.json',\n",
+       " 'gemma-finetuned-demo/tokenizer.json')"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.save_pretrained(\"gemma-finetuned-demo\")\n",
+    "tokenizer.save_pretrained(\"gemma-finetuned-demo\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "uFK1sCzblHlM",
+   "metadata": {
+    "id": "uFK1sCzblHlM"
+   },
+   "source": [
+    "# Output\n",
+    "`Photosynthesis is how plants eat sunlight! 🌞 They use air, water, and sunlight to make food and grow.`"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
@@ -0,0 +1,401 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "l7oSysosTfJj"
+      },
+      "source": [
+        "# Predictive Maintenance Workflow using PraisonAIAgents\n",
+        "\n",
+        "This notebook demonstrates how to build a predictive maintenance workflow using multiple AI agents."
+      ],
+      "id": "l7oSysosTfJj"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DhivyaBharathy-web/PraisonAI/blob/main/examples/cookbooks/Predictive_Maintenance_Multi-Agent_Workflow.ipynb)"
+      ],
+      "metadata": {
+        "id": "LH0_JjO7Y1G2"
+      },
+      "id": "LH0_JjO7Y1G2"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Dependencies"
+      ],
+      "metadata": {
+        "id": "ei-yNZSKXgtJ"
+      },
+      "id": "ei-yNZSKXgtJ"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "fnkuN8sTTfJq"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install praisonaiagents"
+      ],
+      "id": "fnkuN8sTTfJq"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Set your OpenAI API key"
+      ],
+      "metadata": {
+        "id": "7PUSTQHwX5ia"
+      },
+      "id": "7PUSTQHwX5ia"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "id": "33HivD-LTfJu"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "os.environ['OPENAI_API_KEY'] = 'enter your api key'"
+      ],
+      "id": "33HivD-LTfJu"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Import required modules"
+      ],
+      "metadata": {
+        "id": "D6we7t4nYESB"
+      },
+      "id": "D6we7t4nYESB"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "03z7Pi22TfJw"
+      },
+      "outputs": [],
+      "source": [
+        "from praisonaiagents import Agent, Task, PraisonAIAgents\n",
+        "import time\n",
+        "from typing import Dict, List\n",
+        "import asyncio"
+      ],
+      "id": "03z7Pi22TfJw"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Define helper functions"
+      ],
+      "metadata": {
+        "id": "TzZt0jbjYGgw"
+      },
+      "id": "TzZt0jbjYGgw"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2oMzDsp3TfJw"
+      },
+      "outputs": [],
+      "source": [
+        "\n",
+        "def collect_sensor_data():\n",
+        "    return {\n",
+        "        \"temperature\": 75 + (int(time.time()) % 20),\n",
+        "        \"vibration\": 0.5 + (int(time.time()) % 10) / 10,\n",
+        "        \"pressure\": 100 + (int(time.time()) % 50),\n",
+        "        \"noise_level\": 60 + (int(time.time()) % 30)\n",
+        "    }\n",
+        "\n",
+        "def analyze_performance():\n",
+        "    return {\n",
+        "        \"efficiency\": 0.8 + (int(time.time()) % 20) / 100,\n",
+        "        \"uptime\": 0.95 + (int(time.time()) % 5) / 100,\n",
+        "        \"output_quality\": 0.9 + (int(time.time()) % 10) / 100\n",
+        "    }\n",
+        "\n",
+        "def detect_anomalies(sensor_data: Dict, performance: Dict):\n",
+        "    anomalies = []\n",
+        "    if sensor_data[\"temperature\"] > 90:\n",
+        "        anomalies.append({\"type\": \"temperature_high\", \"severity\": \"critical\"})\n",
+        "    if sensor_data[\"vibration\"] > 1.2:\n",
+        "        anomalies.append({\"type\": \"vibration_excess\", \"severity\": \"warning\"})\n",
+        "    if performance[\"efficiency\"] < 0.85:\n",
+        "        anomalies.append({\"type\": \"efficiency_low\", \"severity\": \"warning\"})\n",
+        "    return anomalies\n",
+        "\n",
+        "def predict_failures(anomalies: List[Dict]):\n",
+        "    predictions = []\n",
+        "    severity_scores = {\"critical\": 0.9, \"warning\": 0.6}\n",
+        "    for anomaly in anomalies:\n",
+        "        predictions.append({\n",
+        "            \"component\": anomaly[\"type\"].split(\"_\")[0],\n",
+        "            \"probability\": severity_scores[anomaly[\"severity\"]],\n",
+        "            \"timeframe\": \"24_hours\" if anomaly[\"severity\"] == \"critical\" else \"7_days\"\n",
+        "        })\n",
+        "    return predictions\n",
+        "\n",
+        "def schedule_maintenance(predictions: List[Dict]):\n",
+        "    schedule = []\n",
+        "    for pred in predictions:\n",
+        "        schedule.append({\n",
+        "            \"component\": pred[\"component\"],\n",
+        "            \"priority\": \"immediate\" if pred[\"timeframe\"] == \"24_hours\" else \"planned\",\n",
+        "            \"estimated_duration\": \"2_hours\",\n",
+        "            \"required_parts\": [\"replacement_\" + pred[\"component\"]]\n",
+        "        })\n",
+        "    return schedule"
+      ],
+      "id": "2oMzDsp3TfJw"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Define agents and tasks"
+      ],
+      "metadata": {
+        "id": "-7qMHyY5YIph"
+      },
+      "id": "-7qMHyY5YIph"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "4ZYbYzjNTfJy"
+      },
+      "outputs": [],
+      "source": [
+        "\n",
+        "sensor_monitor = Agent(\"Sensor Monitor\", \"Data Collection\", \"Collect sensor data\", \"Monitor and collect sensor readings\", [collect_sensor_data])\n",
+        "performance_analyzer = Agent(\"Performance Analyzer\", \"Performance Analysis\", \"Analyze equipment performance\", \"Analyze operational metrics\", [analyze_performance])\n",
+        "anomaly_detector = Agent(\"Anomaly Detector\", \"Anomaly Detection\", \"Detect operational anomalies\", \"Identify abnormal patterns\", [detect_anomalies])\n",
+        "failure_predictor = Agent(\"Failure Predictor\", \"Failure Prediction\", \"Predict potential failures\", \"Predict equipment failures\", [predict_failures])\n",
+        "maintenance_scheduler = Agent(\"Maintenance Scheduler\", \"Maintenance Planning\", \"Schedule maintenance activities\", \"Plan and schedule maintenance\", [schedule_maintenance])\n",
+        "\n",
+        "sensor_task = Task(\"collect_data\", \"Collect sensor data\", \"Sensor readings\", sensor_monitor, is_start=True, next_tasks=[\"analyze_performance\"], async_execution=True)\n",
+        "performance_task = Task(\"analyze_performance\", \"Analyze performance metrics\", \"Performance analysis\", performance_analyzer, next_tasks=[\"detect_anomalies\"], async_execution=True)\n",
+        "anomaly_task = Task(\"detect_anomalies\", \"Detect operational anomalies\", \"Detected anomalies\", anomaly_detector, next_tasks=[\"predict_failures\"], context=[sensor_task, performance_task])\n",
+        "prediction_task = Task(\"predict_failures\", \"Predict potential failures\", \"Failure predictions\", failure_predictor, next_tasks=[\"schedule_maintenance\"], task_type=\"decision\", condition={\"critical\": [\"schedule_maintenance\"], \"warning\": [\"schedule_maintenance\"], \"normal\": \"\"})\n",
+        "scheduling_task = Task(\"schedule_maintenance\", \"Schedule maintenance activities\", \"Maintenance schedule\", maintenance_scheduler, context=[prediction_task])"
+      ],
+      "id": "4ZYbYzjNTfJy"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Create and run the workflow"
+      ],
+      "metadata": {
+        "id": "XOdIxJKiYKuD"
+      },
+      "id": "XOdIxJKiYKuD"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "KYu_YTVDTfJz"
+      },
+      "outputs": [],
+      "source": [
+        "\n",
+        "workflow = PraisonAIAgents(\n",
+        "    agents=[sensor_monitor, performance_analyzer, anomaly_detector, failure_predictor, maintenance_scheduler],\n",
+        "    tasks=[sensor_task, performance_task, anomaly_task, prediction_task, scheduling_task],\n",
+        "    process=\"workflow\",\n",
+        "    verbose=True\n",
+        ")\n",
+        "\n",
+        "async def main():\n",
+        "    print(\"\\nStarting Predictive Maintenance Workflow...\")\n",
+        "    print(\"=\" * 50)\n",
+        "    results = await workflow.astart()\n",
+        "    print(\"\\nMaintenance Planning Results:\")\n",
+        "    print(\"=\" * 50)\n",
+        "    for task_id, result in results[\"task_results\"].items():\n",
+        "        if result:\n",
+        "            print(f\"\\nTask: {task_id}\\nResult: {result.raw}\\n{'-'*50}\")\n",
+        "\n",
+        "await main()"
+      ],
+      "id": "KYu_YTVDTfJz"
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(\"\"\"\n",
+        "[Starting Predictive Maintenance Workflow...\n",
+        "==================================================\n",
+        "╭─ Agent Info ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮\n",
+        "│                                                                                                                                              │\n",
+        "│  👤 Agent: Sensor Monitor                                                                                                                    │\n",
+        "│  Role: Data Collection                                                                                                                       │\n",
+        "│  Tools: collect_sensor_data                                                                                                                  │\n",
+        "│                                                                                                                                              │\n",
+        "╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+        "\n",
+        "╭─ Agent Info ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮\n",
+        "│                                                                                                                                              │\n",
+        "│  👤 Agent: Performance Analyzer                                                                                                              │\n",
+        "│  Role: Performance Analysis                                                                                                                  │\n",
+        "│  Tools: analyze_performance                                                                                                                  │\n",
+        "│                                                                                                                                              │\n",
+        "╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+        "\n",
+        "[20:01:26] INFO     [20:01:26] process.py:429 INFO Task schedule_maintenance has no next tasks, ending workflow                   process.py:429\n",
+        "\n",
+        "Maintenance Planning Results:\n",
+        "==================================================\n",
+        "\n",
+        "Task: 0\n",
+        "Result: The sensor readings you have collected are as follows:\n",
+        "\n",
+        "- **Temperature**: 86°F\n",
+        "- **Vibration**: 0.6 (units not specified, but typically measured in g-forces or mm/s)\n",
+        "- **Pressure**: 101 (units not specified, but typically measured in kPa or psi)\n",
+        "- **Noise Level**: 81 dB\n",
+        "\n",
+        "Here's a brief analysis of these readings:\n",
+        "\n",
+        "1. **Temperature**: At 86°F, the temperature is relatively warm. Depending on the context (e.g., industrial equipment, environmental monitoring), this could be within normal operating conditions or might require cooling measures if it's above the optimal range.\n",
+        "\n",
+        "2. **Vibration**: A vibration level of 0.6 is generally low, but the significance depends on the type of equipment being monitored. For precision machinery, even small vibrations can be critical, whereas for more robust equipment, this might be negligible.\n",
+        "\n",
+        "3. **Pressure**: A pressure reading of 101 is often within normal ranges for many systems, but without specific units or context, it's hard to determine if this is optimal or requires adjustment.\n",
+        "\n",
+        "4. **Noise Level**: At 81 dB, the noise level is relatively high. Prolonged exposure to noise levels above 85 dB can be harmful to hearing, so if this is a workplace environment, it might be necessary to implement noise reduction measures or provide hearing protection.\n",
+        "\n",
+        "Overall, these readings should be compared against the specific operational thresholds and safety standards relevant to the equipment or environment being monitored. If any values are outside of acceptable ranges, further investigation or corrective actions may be needed.\n",
+        "--------------------------------------------------\n",
+        "\n",
+        "Task: 1\n",
+        "Result: Based on the provided operational metrics, here's an analysis of the equipment performance:\n",
+        "\n",
+        "1. **Efficiency (94%)**:\n",
+        "   - The equipment is operating at a high efficiency level, with 94% of the input being effectively converted into useful output. This suggests\n",
+        "that the equipment is well-maintained and optimized for performance. However, there is still a 6% margin for improvement, which could be addressed by identifying and minimizing any inefficiencies in the process.\n",
+        "\n",
+        "2. **Uptime (99%)**:\n",
+        "   - The equipment has an excellent uptime rate of 99%, indicating that it is available and operational almost all the time. This is a strong indicator of reliability and suggests that downtime due to maintenance or unexpected failures is minimal. Maintaining this level of uptime should\n",
+        "be a priority, as it directly impacts productivity and operational continuity.\n",
+        "\n",
+        "3. **Output Quality (94%)**:\n",
+        "   - The output quality is also at 94%, which is a positive sign that the equipment is producing high-quality products or results. However, similar to efficiency, there is room for improvement. Efforts could be made to identify any factors that might be affecting quality, such as calibration issues, material inconsistencies, or process deviations.\n",
+        "\n",
+        "**Overall Assessment**:\n",
+        "The equipment is performing well across all key metrics, with high efficiency, uptime, and output quality. To further enhance performance, focus should be placed on fine-tuning processes to close the small gaps in efficiency and quality. Regular maintenance, monitoring, and process optimization can help sustain and potentially improve these metrics.\n",
+        "--------------------------------------------------]\n",
+        "\"\"\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4hrEJ5S6XpJ7",
+        "outputId": "899e677d-19d5-4e0a-d9ab-ebc945aeee1b"
+      },
+      "id": "4hrEJ5S6XpJ7",
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "[Starting Predictive Maintenance Workflow...\n",
+            "==================================================\n",
+            "╭─ Agent Info ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮\n",
+            "│                                                                                                                                              │\n",
+            "│  👤 Agent: Sensor Monitor                                                                                                                    │\n",
+            "│  Role: Data Collection                                                                                                                       │\n",
+            "│  Tools: collect_sensor_data                                                                                                                  │\n",
+            "│                                                                                                                                              │\n",
+            "╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+            "\n",
+            "╭─ Agent Info ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮\n",
+            "│                                                                                                                                              │\n",
+            "│  👤 Agent: Performance Analyzer                                                                                                              │\n",
+            "│  Role: Performance Analysis                                                                                                                  │\n",
+            "│  Tools: analyze_performance                                                                                                                  │\n",
+            "│                                                                                                                                              │\n",
+            "╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+            "\n",
+            "[20:01:26] INFO     [20:01:26] process.py:429 INFO Task schedule_maintenance has no next tasks, ending workflow                   process.py:429\n",
+            "\n",
+            "Maintenance Planning Results:\n",
+            "==================================================\n",
+            "\n",
+            "Task: 0\n",
+            "Result: The sensor readings you have collected are as follows:\n",
+            "\n",
+            "- **Temperature**: 86°F\n",
+            "- **Vibration**: 0.6 (units not specified, but typically measured in g-forces or mm/s)\n",
+            "- **Pressure**: 101 (units not specified, but typically measured in kPa or psi)\n",
+            "- **Noise Level**: 81 dB\n",
+            "\n",
+            "Here's a brief analysis of these readings:\n",
+            "\n",
+            "1. **Temperature**: At 86°F, the temperature is relatively warm. Depending on the context (e.g., industrial equipment, environmental monitoring), this could be within normal operating conditions or might require cooling measures if it's above the optimal range.\n",
+            "\n",
+            "2. **Vibration**: A vibration level of 0.6 is generally low, but the significance depends on the type of equipment being monitored. For precision machinery, even small vibrations can be critical, whereas for more robust equipment, this might be negligible.\n",
+            "\n",
+            "3. **Pressure**: A pressure reading of 101 is often within normal ranges for many systems, but without specific units or context, it's hard to determine if this is optimal or requires adjustment.\n",
+            "\n",
+            "4. **Noise Level**: At 81 dB, the noise level is relatively high. Prolonged exposure to noise levels above 85 dB can be harmful to hearing, so if this is a workplace environment, it might be necessary to implement noise reduction measures or provide hearing protection.\n",
+            "\n",
+            "Overall, these readings should be compared against the specific operational thresholds and safety standards relevant to the equipment or environment being monitored. If any values are outside of acceptable ranges, further investigation or corrective actions may be needed.\n",
+            "--------------------------------------------------\n",
+            "\n",
+            "Task: 1\n",
+            "Result: Based on the provided operational metrics, here's an analysis of the equipment performance:\n",
+            "\n",
+            "1. **Efficiency (94%)**:\n",
+            "   - The equipment is operating at a high efficiency level, with 94% of the input being effectively converted into useful output. This suggests \n",
+            "that the equipment is well-maintained and optimized for performance. However, there is still a 6% margin for improvement, which could be addressed by identifying and minimizing any inefficiencies in the process.\n",
+            "\n",
+            "2. **Uptime (99%)**:\n",
+            "   - The equipment has an excellent uptime rate of 99%, indicating that it is available and operational almost all the time. This is a strong indicator of reliability and suggests that downtime due to maintenance or unexpected failures is minimal. Maintaining this level of uptime should \n",
+            "be a priority, as it directly impacts productivity and operational continuity.\n",
+            "\n",
+            "3. **Output Quality (94%)**:\n",
+            "   - The output quality is also at 94%, which is a positive sign that the equipment is producing high-quality products or results. However, similar to efficiency, there is room for improvement. Efforts could be made to identify any factors that might be affecting quality, such as calibration issues, material inconsistencies, or process deviations.\n",
+            "\n",
+            "**Overall Assessment**:\n",
+            "The equipment is performing well across all key metrics, with high efficiency, uptime, and output quality. To further enhance performance, focus should be placed on fine-tuning processes to close the small gaps in efficiency and quality. Regular maintenance, monitoring, and process optimization can help sustain and potentially improve these metrics.\n",
+            "--------------------------------------------------]\n",
+            "\n"
+          ]
+        }
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python",
+      "version": "3.9"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
@@ -0,0 +1,420 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "MLutIRWTYLqq",
+   "metadata": {
+    "id": "MLutIRWTYLqq"
+   },
+   "source": [
+    "# Simple Chat with Qwen2.5 (0.5B) using Hugging Face Transformers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2LoeTPnYQOW",
+   "metadata": {
+    "id": "a2LoeTPnYQOW"
+   },
+   "source": [
+    "This beginner-friendly notebook demonstrates how to use the Qwen2.5-0.5B-Instruct model for simple chat-based generation. It includes installing dependencies, setting up authentication via Hugging Face token, generating a response using a chat prompt, and displaying the output. The notebook is organized into 5 clean sections for easy understanding."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "WlfJBFucY9gi",
+   "metadata": {
+    "id": "WlfJBFucY9gi"
+   },
+   "source": [
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DhivyaBharathy-web/PraisonAI/blob/main/examples/cookbooks/Qwen2_5_InstructionAgent.ipynb)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57059c85",
+   "metadata": {
+    "id": "57059c85"
+   },
+   "source": [
+    "# 🔧 Dependencies\n",
+    "Install necessary Python packages."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1cdaae47",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "1cdaae47",
+    "outputId": "5b140b09-5c16-4849-f370-f8b5abcc127a"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m3.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m58.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m58.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m39.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m1.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m14.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m64.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install transformers --quiet\n",
+    "!pip install accelerate --quiet\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9a65a2fa",
+   "metadata": {
+    "id": "9a65a2fa"
+   },
+   "source": [
+    "# 🛠️ Tools\n",
+    "Import required tools and libraries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a8a4bc30",
+   "metadata": {
+    "id": "a8a4bc30"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+    "import torch\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ad2bec4",
+   "metadata": {
+    "id": "1ad2bec4"
+   },
+   "source": [
+    "# ⚙️ YAML Prompt (Token Authentication)\n",
+    "Use Hugging Face token to access the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cd030b94",
+   "metadata": {
+    "id": "cd030b94"
+   },
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import login\n",
+    "login(token=\"Enter your huggingface token\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b7b1a32d",
+   "metadata": {
+    "id": "b7b1a32d"
+   },
+   "source": [
+    "# 🚀 Main\n",
+    "Load model, prepare prompt and generate response."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "ef73b9ea",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 365,
+     "referenced_widgets": [
+      "a175e2b1fa8c4733afe1ddc78095be58",
+      "f5aaf63d7be04927a33e5cdd3655a003",
+      "7af74b8c184b4e72a2dba769b9caa40f",
+      "22b1c604d91648479cf01198db25a863",
+      "faaeb1c3ab914a6db9ff9b8ea06a440f",
+      "138860a12c6347fba11437eb098d31b5",
+      "d2f5fe459d544fa6adc92debab823ee6",
+      "468e8e7bee5c4198b121ac1aa677153d",
+      "068991c9ac44496bab06ccaa7d030722",
+      "44436151662f41ef81f6a4005add51de",
+      "c774c78c4fce4825872a76bb1e5fde33",
+      "4a7d0a84994c4b628974f631ecb95425",
+      "4adb654ea143456eb3b4244c3030b39f",
+      "d8dbdbc9327f4799a07767b59db59c47",
+      "669ea95c4cb642b580aa176ae2e89f9f",
+      "0bc8529b03364f83adf1110b5c1378ec",
+      "2eb8007145ef4c3caf7f5a9d1fd299e3",
+      "3fa4c368cea4474e8b97a215a20fd8d8",
+      "c750b36cfda24e24ae44a615e426de4b",
+      "e3001e1e3ba74c7ba28702fa5b2a6ed8",
+      "7ac0f7770ad341f68f194705f59ccb27",
+      "f9140e1979c6412993eee36c3f79c0d9",
+      "1ad8e2e2200c4277ba10dd8e9ac83b90",
+      "f193e4fb00b64e86b6f40f10f514739d",
+      "ae3aa36b649a43eb928ed843d2cfc239",
+      "c346fba7badb4c4596f6d6e8fa62224b",
+      "39dd29002d7b46848a29dfeb7405d9f9",
+      "166e17a0be5a4aa8831101eeb07a8645",
+      "60f9503b404945a3b99b5207190474f5",
+      "c480a676b82b48a0aae3dc438fa02ba8",
+      "d97b7d0765e84926b974b2c19156ae20",
+      "b22ca5c038f7419aa8e03f5f9a54accc",
+      "0387fba7ed044fbfb2a78c8d593c7b38",
+      "d6a31c3cf026450088596db5917c3e4a",
+      "4948c0014a95413b81848ae2b4a5fe7e",
+      "377cbca7363a495ea131a1e49a702168",
+      "a5eaad3284034beab09d212765d7ff78",
+      "7ed393b7c7564ab1897446eba875a4da",
+      "66d773bc8c7a40bc95dcba35052675cb",
+      "ad196b0deb2144b083cf8fddcbcfd147",
+      "09a99df922154a528f327bba0a47cb9a",
+      "bc9918e686244eb5b5db78932600a9d6",
+      "4fef54176f4b4a2d8d543a4bf04b416a",
+      "48551fb8dd5140cbb2d792e72b5fbb0d",
+      "955225e4206a4ee5a4284579935db920",
+      "e2faef80a0034c5384daf8ba66c1b75d",
+      "f27c3ec92bc74bacb3f86672b689370a",
+      "ec03dfb79a26474e812606b2664c931b",
+      "4705d2f502a74c3bb8eb8a06c3ba6889",
+      "7d8c99f622c34229894024c9772aed84",
+      "1e6e892b153c4c05b7de806ec674215f",
+      "85ac6a67bb0944b5bb8713fcf302da45",
+      "796771b887ce49119307725382f73bfd",
+      "c686586c431f4c22b0f0c698a9b213b6",
+      "239180fd12624e3a90188270b55ee218",
+      "e04653090c7e454d9c5e520e7f313588",
+      "992c7a4b44aa4feb8e13714fa922d705",
+      "a0a238c78d2842d680be448a2cb20157",
+      "6ab5ebed63674b5e87327a1623eba7f0",
+      "a49887aa0fcd4b91a0d5d978b29c1e0a",
+      "d9b2e4142dd14264b90829a5a4116613",
+      "154b27bb2ba44d10bde5c96929b65cc9",
+      "f0bf6206c31f49f2ad1ce97b99963011",
+      "1762735cfbcf4706b1c0686d3c2926a0",
+      "d5e3440785794f0f9ad4fd0650c2f682",
+      "08019bdd70364fabbc222dca66db0bb1",
+      "6f0b3a92d47c42dd815a670bb1c0f42c",
+      "54554545ad5a4f39b649f3acff6d5cba",
+      "bfd8f4ee8c414349a3695975e79c332e",
+      "332fc944eef14a9c82f71a68a3857dea",
+      "3b0b899fcfae451ba8ec3d8da176fcec",
+      "8383df3f07bd427287ad05726737cc67",
+      "67c267d7d1ec424593775bf8129e8ac9",
+      "85a50e2cb406403988639e6d6ecf9dc1",
+      "7251ed20382c4a60bae8549f68971043",
+      "44fbc377fd6a4c5a910c00dcceb143af",
+      "2d6d273941f04c13af598c53e067aae7"
+     ]
+    },
+    "id": "ef73b9ea",
+    "outputId": "34512fa7-527c-45cb-f3c7-b42d37e74980"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.11/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n",
+      "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
+      "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
+      "You will be able to reuse this secret in all of your notebooks.\n",
+      "Please note that authentication is recommended but still optional to access public models or datasets.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a175e2b1fa8c4733afe1ddc78095be58",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json:   0%|          | 0.00/7.30k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4a7d0a84994c4b628974f631ecb95425",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "vocab.json:   0%|          | 0.00/2.78M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1ad8e2e2200c4277ba10dd8e9ac83b90",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "merges.txt:   0%|          | 0.00/1.67M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d6a31c3cf026450088596db5917c3e4a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json:   0%|          | 0.00/7.03M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "955225e4206a4ee5a4284579935db920",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/659 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e04653090c7e454d9c5e520e7f313588",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model.safetensors:   0%|          | 0.00/988M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6f0b3a92d47c42dd815a670bb1c0f42c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "generation_config.json:   0%|          | 0.00/242 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model_name = \"Qwen/Qwen2.5-0.5B-Instruct\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    model_name,\n",
+    "    torch_dtype=\"auto\",\n",
+    "    device_map=\"auto\"\n",
+    ")\n",
+    "\n",
+    "messages = [\n",
+    "    {\"role\": \"system\", \"content\": \"You are Qwen, a helpful assistant.\"},\n",
+    "    {\"role\": \"user\", \"content\": \"Explain photosynthesis in simple words.\"}\n",
+    "]\n",
+    "\n",
+    "text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n",
+    "inputs = tokenizer(text, return_tensors=\"pt\").to(model.device)\n",
+    "\n",
+    "outputs = model.generate(**inputs, max_new_tokens=100)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf70c765",
+   "metadata": {
+    "id": "bf70c765"
+   },
+   "source": [
+    "# 📤 Output\n",
+    "Print the model response."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d8f70a7b",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "d8f70a7b",
+    "outputId": "559e9358-c2b7-4410-c1a6-1624640dfeae"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "system\n",
+      "You are Qwen, a helpful assistant.\n",
+      "user\n",
+      "Explain photosynthesis in simple words.\n",
+      "assistant\n",
+      "Photosynthesis is the process by which plants, algae, and some bacteria convert light energy from the sun into chemical energy stored in glucose molecules, using carbon dioxide and water as reactants. This process occurs in chloroplasts within plant cells and involves two main stages: the light-dependent reactions and the light-independent reactions (also known as the Calvin cycle).\n",
+      "\n",
+      "In the light-dependent reactions, light energy is captured by pigments like chlorophyll, causing electrons to be excited and transferred to oxygen through a series\n"
+     ]
+    }
+   ],
+   "source": [
+    "response = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "print(response)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
@@ -0,0 +1,364 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3622c575",
+   "metadata": {
+    "id": "3622c575"
+   },
+   "source": [
+    "# TinyLlama Agent Demo\n",
+    "\n",
+    "This notebook demonstrates how to create a simple AI agent using the TinyLlama (1.1B) model.\n",
+    "\n",
+    "**Requirements:**\n",
+    "- `transformers`\n",
+    "- `accelerate`\n",
+    "- `torch`\n",
+    "\n",
+    "We will load the model, prepare a basic conversational interface, and test it with a simple prompt."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "qS0M9pRhTGpf",
+   "metadata": {
+    "id": "qS0M9pRhTGpf"
+   },
+   "source": [
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/DhivyaBharathy-web/PraisonAI/blob/main/examples/cookbooks/TinyLlama_1_1B_model_SimpleAIAgent.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "tuw0IDpBS0ei",
+   "metadata": {
+    "id": "tuw0IDpBS0ei"
+   },
+   "source": [
+    "# Install necessary packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "0d06cae9",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "0d06cae9",
+    "outputId": "3e1d8fb7-19be-455b-dc35-d0ab19146669"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m3.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m29.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m29.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m20.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m12.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m45.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install -q transformers accelerate torch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "RFhYLkO1S5F9",
+   "metadata": {
+    "id": "RFhYLkO1S5F9"
+   },
+   "source": [
+    "# Load TinyLlama model and tokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "415af398",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 241,
+     "referenced_widgets": [
+      "dae7d635257948149c74e65956f614e3",
+      "17ec6fcc9f624cdbb62fe2b8b55230d0",
+      "58474504488044138a0252bb75258d86",
+      "04fe4518fac04b9f8b29c62ed70f1dfd",
+      "c6a9d3ea25594170977243d2048d3408",
+      "730bebf00be142d3979c6d12b55d6757",
+      "03ad1674c0884e7b9c4a21af0a1e66c3",
+      "ebac47c887f04b79a60bd0918002bf0d",
+      "ece9bce5d2ca4dd7b019040175513118",
+      "458f11dbadb045f1aa8c72780e7aa2a0",
+      "ec28a20d0a14445489723684d2d69c0a",
+      "d347fa0c0fc849559b66c8f116c86317",
+      "117f649fa62b4f5d9add0160e6cd80a4",
+      "66f702418fa348eea27778282dc443aa",
+      "44413339df5b4ae688f8101faf9ed3b5",
+      "00cc576df95441c8916ce38a7c6decc2",
+      "22e9ea6d191841bf9a5a5072326aa6d8",
+      "bd94a291b3164113b5ea460b38b8c167",
+      "9d132a297f924a3d867605df81e70d8e",
+      "5345feddca204db784ea0452e739eda6",
+      "ace33e6e88d842c89efd180b3a83f674",
+      "61dd85a7edf544f196c60a259a91fa0d",
+      "7451ec9bd091441c852d075b47bd1ca5",
+      "05e3446e7c9243819a25d1ca8e8fa38e",
+      "73141c4c9218462da97999d3afa459bc",
+      "1cffc33252b94fbc861edb0953f13153",
+      "de917c0fc49040c8a9254333c34c884a",
+      "50962ececc0b42c28170eb0c23fd6171",
+      "856cc834a33a4f9fb59c77f748006b36",
+      "17fd1d476c1f4891b8cbeb8cacdeb866",
+      "c97dc50f42cb44b8a71aeff5272d5337",
+      "2e3a66f622d445c4be544a9306798cb6",
+      "92920b1d428a4ed68a9e0329e2034cad",
+      "7e282c1fcae842cc87c93ecfc1763654",
+      "f9ed70f887204e2fb336e38a35096eec",
+      "a4d99f9beca44e4a8fadff65b27aa78f",
+      "b4f77b96d00445eea77ac78baa8c1e99",
+      "695898e4a4c8476cb318446a6da592ba",
+      "d70bcacbe77c41f685a4f8020f767889",
+      "af49afc49ecf47fb9ebf2d299954eff2",
+      "1bd2a253348f4b45928c875940f72481",
+      "b6c5f55fc85b4331a2e749d27ce15f89",
+      "81a87638c71046d7aeb1c642558602f7",
+      "e750883103444391bd64872344c651d7",
+      "e78dca0cf1314d01a5d5126e448e9d87",
+      "d0c53dffc0c34d7090febf78231972b2",
+      "152a118177914c6692e7ee4987b92b9b",
+      "88fd71fd6dbf43ebb0a3b8471fd35f8d",
+      "ddb91266f8834e4eaaf136cc15f4a831",
+      "9f8179d135054eb292c9adc7fd66a91a",
+      "297d5bc8b3a04f26b80e2cc5ee3f7bbd",
+      "f49f72679cb944cd8fce5557bbd68b1b",
+      "2ee28c8ef4f74690b80a89050da4ebb5",
+      "c29924d6561a4feaa9238d1b34394941",
+      "03636146b7c14f5db80b8f105be55303",
+      "b391081de4444859ac3213aac99cc33a",
+      "2babb83499fc46dc8422473f7b98403c",
+      "a32f6cc2777941bca5b6250e36624ead",
+      "90cd9996184a452ab651f9b8cc590f47",
+      "dc04209c92764096ba9bd4aefa81c189",
+      "16e5b93c3c964a8a8ca460d9077d0638",
+      "794f22ded07d46c5a916325109618987",
+      "dce367f1a5a74ebf94aea37209aa0a40",
+      "5e355e3f340f4a7590e4a88d44b03383",
+      "4e725e19c877462aa3c10726a335bbde",
+      "d60ab6c255d244098a459459016a2089",
+      "f1b07183320d42af88f985bd1abf054f",
+      "d23103bb4b354e29a2c3e7dc93867b36",
+      "ea3e0ae0aef54e5da113c9686ebbbab9",
+      "4d3365c1bb7740dc8f36f4b419af135a",
+      "c06ccbc051264027bd2c6521fec69abe",
+      "597dbf5b28134cc0bf9d613443243455",
+      "faa4f285eb224bbcbed649bd479e571f",
+      "6e684d35885a4706b8add6834cd521ad",
+      "f9c55ada3386460183e02559defec8a4",
+      "9d64cbe1605f4f358923754c5f8b6424",
+      "6008ed7eca09485195eb37c36acfbe79"
+     ]
+    },
+    "id": "415af398",
+    "outputId": "28de1886-e83f-49bf-b05f-cd19439605c5"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "dae7d635257948149c74e65956f614e3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json:   0%|          | 0.00/1.29k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d347fa0c0fc849559b66c8f116c86317",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.model:   0%|          | 0.00/500k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7451ec9bd091441c852d075b47bd1ca5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json:   0%|          | 0.00/1.84M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7e282c1fcae842cc87c93ecfc1763654",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "special_tokens_map.json:   0%|          | 0.00/551 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e78dca0cf1314d01a5d5126e448e9d87",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/608 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b391081de4444859ac3213aac99cc33a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model.safetensors:   0%|          | 0.00/2.20G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f1b07183320d42af88f985bd1abf054f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "generation_config.json:   0%|          | 0.00/124 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+    "import torch\n",
+    "\n",
+    "model_name = \"TinyLlama/TinyLlama-1.1B-Chat-v1.0\"\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map=\"auto\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "N0bRTd_DS8aL",
+   "metadata": {
+    "id": "N0bRTd_DS8aL"
+   },
+   "source": [
+    "# Define a function to generate responses from the agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "1b0483e1",
+   "metadata": {
+    "id": "1b0483e1"
+   },
+   "outputs": [],
+   "source": [
+    "def generate_response(prompt, max_length=256):\n",
+    "    inputs = tokenizer(prompt, return_tensors=\"pt\").to(model.device)\n",
+    "    outputs = model.generate(**inputs, max_new_tokens=max_length)\n",
+    "    return tokenizer.decode(outputs[0], skip_special_tokens=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "vbHKNxc-S_Bk",
+   "metadata": {
+    "id": "vbHKNxc-S_Bk"
+   },
+   "source": [
+    "# Example usage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "298c9811",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "298c9811",
+    "outputId": "6e412608-735c-4604-8a5d-a66b98dd9df0"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "You are a helpful assistant. What is the capital of France?\n"
+     ]
+    }
+   ],
+   "source": [
+    "prompt = \"You are a helpful assistant. What is the capital of France?\"\n",
+    "response = generate_response(prompt)\n",
+    "print(response)"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
@@ -0,0 +1,14 @@
+from praisonaiagents import Agent
+
+def validate_content(data):
+    if len(str(data)) < 50:
+        return False, "Content too short"
+    return True, data
+
+agent = Agent(
+    instructions="You are a writer",
+    guardrail=validate_content,
+    max_guardrail_retries=1
+)
+
+agent.start("Write a welcome message with 5 words")
@@ -619,12 +619,9 @@ Your Goal: {self.goal}
        while retry_count <= self.max_guardrail_retries:
            # Create TaskOutput object
            task_output = TaskOutput(
+                description="Agent response output",
                raw=current_response,
-                output=current_response,
-                pydantic=None,
-                json_dict=None,
-                name=f"{self.name}_output",
-                description="Agent response output"
+                agent=self.name
            )
            
            # Process guardrail
@@ -910,11 +910,14 @@ class Memory:
        """

        try:
-            # Use OpenAI client from main.py
-            from ..main import client
+            # Use LiteLLM for consistency with the rest of the codebase
+            import litellm
            
-            response = client.chat.completions.create(
-                model=llm or "gpt-4o",
+            # Convert model name if it's in litellm format
+            model_name = llm or "gpt-4o-mini"
+            
+            response = litellm.completion(
+                model=model_name,
                messages=[{
                    "role": "user", 
                    "content": custom_prompt or default_prompt
@@ -308,7 +308,11 @@ class Task:
                if self.agent:
                    if getattr(self.agent, '_using_custom_llm', False) and hasattr(self.agent, 'llm_instance'):
                        # For custom LLM instances (like Ollama)
-                        llm_model = self.agent.llm_instance
+                        # Extract the model name from the LLM instance
+                        if hasattr(self.agent.llm_instance, 'model'):
+                            llm_model = self.agent.llm_instance.model
+                        else:
+                            llm_model = "gpt-4o-mini"  # Default fallback
                    elif hasattr(self.agent, 'llm') and self.agent.llm:
                        # For standard model strings
                        llm_model = self.agent.llm
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "praisonaiagents"
-version = "0.0.99"
+version = "0.0.101"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [
@@ -25,7 +25,8 @@ mcp = [
 ]

 memory = [
-    "chromadb>=1.0.0"
+    "chromadb>=1.0.0",
+    "litellm>=1.50.0",
 ]

 knowledge = [
@@ -63,5 +64,6 @@ all = [
    "praisonaiagents[api]"
 ]

-[tool.setuptools]
-packages = ["praisonaiagents"]
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["praisonaiagents*"]
@@ -0,0 +1,33 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+llm_config = {
+    "model": "openai/gpt-4o-mini",
+    "api_key": os.getenv('OPENAI_API_KEY'),
+    "temperature": 0.7,
+    "max_tokens": 2000
+}
+
+blog_agent = Agent(
+    role="Blog Writer",
+    goal="Write a blog post about AI",
+    backstory="Expert at writing blog posts",
+    llm="gpt-4o-mini",
+)
+
+blog_task = Task(
+    description="Write a blog post about AI trends in 1 paragraph",
+    expected_output="Well-written blog post about AI trends",
+    agent=blog_agent
+)
+
+agents = PraisonAIAgents(
+    agents=[blog_agent],
+    tasks=[blog_task],
+    memory=True
+)
+
+result = agents.start()
@@ -2398,7 +2398,7 @@ wheels = [

 [[package]]
 name = "praisonaiagents"
-version = "0.0.99"
+version = "0.0.101"
 source = { editable = "." }
 dependencies = [
    { name = "mcp" },
@@ -2444,6 +2444,7 @@ mcp = [
 ]
 memory = [
    { name = "chromadb" },
+    { name = "litellm" },
 ]

 [package.metadata]
@@ -2455,6 +2456,7 @@ requires-dist = [
    { name = "fastapi", marker = "extra == 'api'", specifier = ">=0.115.0" },
    { name = "fastapi", marker = "extra == 'mcp'", specifier = ">=0.115.0" },
    { name = "litellm", marker = "extra == 'llm'", specifier = ">=1.50.0" },
+    { name = "litellm", marker = "extra == 'memory'", specifier = ">=1.50.0" },
    { name = "markitdown", extras = ["all"], marker = "extra == 'knowledge'", specifier = ">=0.1.0" },
    { name = "mcp", specifier = ">=1.6.0" },
    { name = "mcp", marker = "extra == 'mcp'", specifier = ">=1.6.0" },
@@ -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.28.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.28.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.29.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.29.tar.gz | shasum -a 256`.split.first
    license "MIT"
  
    depends_on "[email protected]"
@@ -56,7 +56,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.28 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.2.29 gunicorn markdown\n")
            file.write("EXPOSE 8080\n")
            file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
            
@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.2.28"
+version = "2.2.29"
 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.99",
+    "praisonaiagents>=0.0.101",
    "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.28"
+version = "2.2.29"
 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.99"
+praisonaiagents = ">=0.0.101"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"
@@ -3931,7 +3931,7 @@ wheels = [

 [[package]]
 name = "praisonai"
-version = "2.2.28"
+version = "2.2.29"
 source = { editable = "." }
 dependencies = [
    { name = "instructor" },
@@ -4073,7 +4073,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.99" },
+    { name = "praisonaiagents", specifier = ">=0.0.101" },
    { 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" },
@@ -4130,7 +4130,7 @@ wheels = [

 [[package]]
 name = "praisonaiagents"
-version = "0.0.99"
+version = "0.0.101"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "mcp" },
@@ -4138,9 +4138,9 @@ dependencies = [
    { name = "pydantic" },
    { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0e/c9/61a2a5ba41a1a81f93101a14bd2c4399139dd2b37782651e46a579a3b23c/praisonaiagents-0.0.99.tar.gz", hash = "sha256:acc6f00cc0c7e6193535a69a12d5cfbccdeb52bf38b7944019a1ef30b7411251", size = 140604 }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/20/5b34f6a42752a0033034483ef116d419e5b0c51a5bcb92aa285312a62466/praisonaiagents-0.0.101.tar.gz", hash = "sha256:55d2a79726aac286a93815768a6cfa04c821f430370f276b18e5a2aab698aa2b", size = 145011 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/50/df/b86106a107c6a9f16dbaba4f516f054f1569a8c02a6d05cecf8f0adcaee2/praisonaiagents-0.0.99-py3-none-any.whl", hash = "sha256:d8724d66900d4c6a9219d8e56575c9d542a1843592159abb8a6bf82618e801ba", size = 158680 },
+    { url = "https://files.pythonhosted.org/packages/89/57/3f17cc757f6c12125a6a6e3518d8221ba74bae10d5512362134db6dda8b5/praisonaiagents-0.0.101-py3-none-any.whl", hash = "sha256:4c6174b50e6084cf375b1eef196dfc4f48c72b82d1edf043660d48754558e14c", size = 164959 },
 ]

 [[package]]
Author	SHA1	Message	Date
Mervin Praison	603f0ea008	Merge pull request #609 from MervinPraison/develop Develop	2025-06-05 17:55:15 +01:00
MervinPraison	db38b55174	Update PraisonAI version to 2.2.29 across Dockerfiles and related files - Incremented the version of PraisonAI from 2.2.28 to 2.2.29 in Dockerfiles (Dockerfile, Dockerfile.chat, Dockerfile.dev, Dockerfile.ui). - Updated the version in the README.md and pyproject.toml files to reflect the new version. - Adjusted the deploy.py script to install the updated version of PraisonAI. - Ensured consistency across all relevant files for seamless integration.	2025-06-05 17:54:57 +01:00
MervinPraison	cebd175d61	Update versioning and dependencies in project files - Incremented version of PraisonAI from 0.0.99 to 0.0.101 in pyproject.toml and uv.lock. - Added 'litellm' dependency to memory requirements for enhanced functionality. - Updated .gitignore to include 'CopilotKit*' for better file management. - Optimised TaskOutput instantiation in agent.py for clarity. - Refined memory handling in memory.py to utilise LiteLLM for consistency. - Improved model extraction logic in task.py for better fallback handling.	2025-06-05 17:53:38 +01:00
Mervin Praison	01ff75e573	Merge pull request #606 from DhivyaBharathy-web/add-qwen2-5-agent Add Qwen2.5 Instruction Agent notebook using Hugging Face Transformers	2025-06-05 17:43:36 +01:00
Mervin Praison	28629f2203	Merge pull request #607 from DhivyaBharathy-web/add-gemma2b-instruction-agent Add Gemma2B_Instruction_Agent to Cookbooks	2025-06-05 17:43:19 +01:00
Mervin Praison	ac5c463362	Merge pull request #602 from DhivyaBharathy-web/add-predictive-maintenance-notebook Add predictive maintenance notebook	2025-06-05 17:43:05 +01:00
Mervin Praison	84dc57583e	Merge pull request #608 from DhivyaBharathy-web/add-tinyllama-model-agent Add tinyllama model agent	2025-06-05 17:42:50 +01:00
DhivyaBharathy	460e8b45a7	Merge branch 'main' into add-tinyllama-model-agent	2025-06-05 19:30:02 +05:30
DhivyaBharathy	f6bbbd7cd6	Update TinyLlama_1_1B_model_SimpleAIAgent.ipynb	2025-06-05 19:29:06 +05:30
DhivyaBharathy	8a435571f4	Add files via upload	2025-06-05 19:10:44 +05:30
DhivyaBharathy	204106daa8	Merge branch 'main' into add-gemma2b-instruction-agent	2025-06-05 16:47:50 +05:30
DhivyaBharathy	6a1e14f97a	Merge branch 'main' into add-qwen2-5-agent	2025-06-05 16:47:02 +05:30
DhivyaBharathy	333777b991	Merge branch 'main' into add-predictive-maintenance-notebook	2025-06-05 16:46:13 +05:30
DhivyaBharathy	b02cd85290	Update Gemma2B_Instruction_Agent.ipynb	2025-06-05 16:27:38 +05:30
DhivyaBharathy	3bc0c2b533	Update Gemma2B_Instruction_Agent.ipynb	2025-06-05 16:26:56 +05:30
DhivyaBharathy	68d4f34bb7	Update Gemma2B_Instruction_Agent.ipynb	2025-06-05 16:26:37 +05:30
DhivyaBharathy	a24d900a8c	Add files via upload	2025-06-05 16:22:33 +05:30
DhivyaBharathy-web	552a10df9e	Add Qwen2.5 Instruction Agent notebook	2025-06-05 10:49:32 +00:00
DhivyaBharathy	9c57aa3165	Update Qwen2_5_InstructionAgent.ipynb	2025-06-05 15:16:04 +05:30
DhivyaBharathy	40fe92f1d0	Update Qwen2_5_InstructionAgent.ipynb	2025-06-05 15:14:56 +05:30
DhivyaBharathy	179cc9566d	Update Qwen2_5_InstructionAgent.ipynb	2025-06-05 15:09:09 +05:30
DhivyaBharathy	d9cf9ba534	Add files via upload	2025-06-05 15:07:47 +05:30
DhivyaBharathy-web	4ec0366e79	Add Qwen2.5 Instruction Agent notebook	2025-06-05 09:26:46 +00:00
DhivyaBharathy	b824d950b5	Add files via upload	2025-06-04 20:32:10 +05:30
DhivyaBharathy	b31edc90d5	Update Code_Analysis_Agent.ipynb	2025-06-04 16:58:52 +05:30
DhivyaBharathy	d2841ccb3a	Merge branch 'MervinPraison:main' into main	2025-06-04 16:53:54 +05:30