Delete community_contributions

community_contributions/1_lab1_DA.ipynb

@@ -1,396 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Welcome to the start of your adventure in Agentic AI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Are you ready for action??</h2>\n",
-    "            <span style=\"color:#ff7800;\">Have you completed all the setup steps in the <a href=\"../setup/\">setup</a> folder?<br/>\n",
-    "            Have you read the <a href=\"../README.md\">README</a>? Many common questions are answered here!<br/>\n",
-    "            Have you checked out the guides in the <a href=\"../guides/01_intro.ipynb\">guides</a> folder?<br/>\n",
-    "            Well in that case, you're ready!!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/tools.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">This code is a live resource - keep an eye out for my updates</h2>\n",
-    "            <span style=\"color:#00bfff;\">I push updates regularly. As people ask questions or have problems, I add more examples and improve explanations. As a result, the code below might not be identical to the videos, as I've added more steps and better comments. Consider this like an interactive book that accompanies the lectures.<br/><br/>\n",
-    "            I try to send emails regularly with important updates related to the course. You can find this in the 'Announcements' section of Udemy in the left sidebar. You can also choose to receive my emails via your Notification Settings in Udemy. I'm respectful of your inbox and always try to add value with my emails!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### And please do remember to contact me if I can help\n",
-    "\n",
-    "And I love to connect: https://www.linkedin.com/in/eddonner/\n",
-    "\n",
-    "\n",
-    "### New to Notebooks like this one? Head over to the guides folder!\n",
-    "\n",
-    "Just to check you've already added the Python and Jupyter extensions to Cursor, if not already installed:\n",
-    "- Open extensions (View >> extensions)\n",
-    "- Search for python, and when the results show, click on the ms-python one, and Install it if not already installed\n",
-    "- Search for jupyter, and when the results show, click on the Microsoft one, and Install it if not already installed  \n",
-    "Then View >> Explorer to bring back the File Explorer.\n",
-    "\n",
-    "And then:\n",
-    "1. Click where it says \"Select Kernel\" near the top right, and select the option called `.venv (Python 3.12.9)` or similar, which should be the first choice or the most prominent choice. You may need to choose \"Python Environments\" first.\n",
-    "2. Click in each \"cell\" below, starting with the cell immediately below this text, and press Shift+Enter to run\n",
-    "3. Enjoy!\n",
-    "\n",
-    "After you click \"Select Kernel\", if there is no option like `.venv (Python 3.12.9)` then please do the following:  \n",
-    "1. On Mac: From the Cursor menu, choose Settings >> VS Code Settings (NOTE: be sure to select `VSCode Settings` not `Cursor Settings`);  \n",
-    "On Windows PC: From the File menu, choose Preferences >> VS Code Settings(NOTE: be sure to select `VSCode Settings` not `Cursor Settings`)  \n",
-    "2. In the Settings search bar, type \"venv\"  \n",
-    "3. In the field \"Path to folder with a list of Virtual Environments\" put the path to the project root, like C:\\Users\\username\\projects\\agents (on a Windows PC) or /Users/username/projects/agents (on Mac or Linux).  \n",
-    "And then try again.\n",
-    "\n",
-    "Having problems with missing Python versions in that list? Have you ever used Anaconda before? It might be interferring. Quit Cursor, bring up a new command line, and make sure that your Anaconda environment is deactivated:    \n",
-    "`conda deactivate`  \n",
-    "And if you still have any problems with conda and python versions, it's possible that you will need to run this too:  \n",
-    "`conda config --set auto_activate_base false`  \n",
-    "and then from within the Agents directory, you should be able to run `uv python list` and see the Python 3.12 version."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First let's do an import. If you get an Import Error, double check that your Kernel is correct..\n",
-    "\n",
-    "from dotenv  import load_dotenv\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Next it's time to load the API keys into environment variables\n",
-    "# If this returns false, see the next cell!\n",
-    "\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Wait, did that just output `False`??\n",
-    "\n",
-    "If so, the most common reason is that you didn't save your `.env` file after adding the key! Be sure to have saved.\n",
-    "\n",
-    "Also, make sure the `.env` file is named precisely `.env` and is in the project root directory (`agents`)\n",
-    "\n",
-    "By the way, your `.env` file should have a stop symbol next to it in Cursor on the left, and that's actually a good thing: that's Cursor saying to you, \"hey, I realize this is a file filled with secret information, and I'm not going to send it to an external AI to suggest changes, because your keys should not be shown to anyone else.\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Final reminders</h2>\n",
-    "            <span style=\"color:#ff7800;\">1. If you're not confident about Environment Variables or Web Endpoints / APIs, please read Topics 3 and 5 in this <a href=\"../guides/04_technical_foundations.ipynb\">technical foundations guide</a>.<br/>\n",
-    "            2. If you want to use AIs other than OpenAI, like Gemini, DeepSeek or Ollama (free), please see the first section in this <a href=\"../guides/09_ai_apis_and_ollama.ipynb\">AI APIs guide</a>.<br/>\n",
-    "            3. If you ever get a Name Error in Python, you can always fix it immediately; see the last section of this <a href=\"../guides/06_python_foundations.ipynb\">Python Foundations guide</a> and follow both tutorials and exercises.<br/>\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Check the key - if you're not using OpenAI, check whichever key you're using! Ollama doesn't need a key.\n",
-    "\n",
-    "import os\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set - please head to the troubleshooting guide in the setup folder\")\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - the all important import statement\n",
-    "# If you get an import error - head over to troubleshooting in the Setup folder\n",
-    "# Even for other LLM providers like Gemini, you still use this OpenAI import - see Guide 9 for why\n",
-    "\n",
-    "from openai import OpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now we'll create an instance of the OpenAI class\n",
-    "# If you're not sure what it means to create an instance of a class - head over to the guides folder (guide 6)!\n",
-    "# If you get a NameError - head over to the guides folder (guide 6)to learn about NameErrors - always instantly fixable\n",
-    "# If you're not using OpenAI, you just need to slightly modify this - precise instructions are in the AI APIs guide (guide 9)\n",
-    "\n",
-    "openai = OpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a list of messages in the familiar OpenAI format\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": \"What is 2+2?\"}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now call it! Any problems, head to the troubleshooting guide\n",
-    "# This uses GPT 4.1 nano, the incredibly cheap model\n",
-    "# The APIs guide (guide 9) has exact instructions for using even cheaper or free alternatives to OpenAI\n",
-    "# If you get a NameError, head to the guides folder (guide 6) to learn about NameErrors - always instantly fixable\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-nano\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "print(response.choices[0].message.content)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - let's ask for a question:\n",
-    "\n",
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ask it - this uses GPT 4.1 mini, still cheap but more powerful than nano\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "question = response.choices[0].message.content\n",
-    "\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# form a new messages list\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ask it again\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "answer = response.choices[0].message.content\n",
-    "print(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Congratulations!\n",
-    "\n",
-    "That was a small, simple step in the direction of Agentic AI, with your new environment!\n",
-    "\n",
-    "Next time things get more interesting..."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Now try this commercial application:<br/>\n",
-    "            First ask the LLM to pick a business area that might be worth exploring for an Agentic AI opportunity.<br/>\n",
-    "            Then ask the LLM to present a pain-point in that industry - something challenging that might be ripe for an Agentic solution.<br/>\n",
-    "            Finally have 3 third LLM call propose the Agentic AI solution. <br/>\n",
-    "            We will cover this at up-coming labs, so don't worry if you're unsure.. just give it a try!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - let's ask for a question:\n",
-    "\n",
-    "import os\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "from openai import OpenAI\n",
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "# And now we'll create an instance of the OpenAI class\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "\n",
-    "question1 = \"Please pick a business area that might be worth exploring for an Agentic AI opportunity.\"\n",
-    "messages1 = [{\"role\": \"user\", \"content\": question1}]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "response1 = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages1\n",
-    ")\n",
-    "\n",
-    "question2 = \" Please present the pain-point in \"+response1.choices[0].message.content +\" industry - something challenging that might be ripe for an Agentic solution\"\n",
-    "messages2 = [{\"role\": \"user\", \"content\": question2}]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "response2 = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages2\n",
-    ")\n",
-    "\n",
-    "question3 = \" Please presentpropose and Agentic AI solution for pain-point \"+response2.choices[0].message.content\n",
-    "messages3 = [{\"role\": \"user\", \"content\": question3}]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "response3 = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages3\n",
-    ")\n",
-    "\n",
-    "Final_Answer = \" Please presentpropose and Agentic AI solution for pain-point \"+response2.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(Final_Answer))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab1_Hy.ipynb

@@ -1,688 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Welcome to the start of your adventure in Agentic AI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Are you ready for action??</h2>\n",
-    "            <span style=\"color:#ff7800;\">Have you completed all the setup steps in the <a href=\"../setup/\">setup</a> folder?<br/>\n",
-    "            Have you read the <a href=\"../README.md\">README</a>? Many common questions are answered here!<br/>\n",
-    "            Have you checked out the guides in the <a href=\"../guides/01_intro.ipynb\">guides</a> folder?<br/>\n",
-    "            Well in that case, you're ready!!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/tools.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">This code is a live resource - keep an eye out for my updates</h2>\n",
-    "            <span style=\"color:#00bfff;\">I push updates regularly. As people ask questions or have problems, I add more examples and improve explanations. As a result, the code below might not be identical to the videos, as I've added more steps and better comments. Consider this like an interactive book that accompanies the lectures.<br/><br/>\n",
-    "            I try to send emails regularly with important updates related to the course. You can find this in the 'Announcements' section of Udemy in the left sidebar. You can also choose to receive my emails via your Notification Settings in Udemy. I'm respectful of your inbox and always try to add value with my emails!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### And please do remember to contact me if I can help\n",
-    "\n",
-    "And I love to connect: https://www.linkedin.com/in/eddonner/\n",
-    "\n",
-    "\n",
-    "### New to Notebooks like this one? Head over to the guides folder!\n",
-    "\n",
-    "Just to check you've already added the Python and Jupyter extensions to Cursor, if not already installed:\n",
-    "- Open extensions (View >> extensions)\n",
-    "- Search for python, and when the results show, click on the ms-python one, and Install it if not already installed\n",
-    "- Search for jupyter, and when the results show, click on the Microsoft one, and Install it if not already installed  \n",
-    "Then View >> Explorer to bring back the File Explorer.\n",
-    "\n",
-    "And then:\n",
-    "1. Click where it says \"Select Kernel\" near the top right, and select the option called `.venv (Python 3.12.9)` or similar, which should be the first choice or the most prominent choice. You may need to choose \"Python Environments\" first.\n",
-    "2. Click in each \"cell\" below, starting with the cell immediately below this text, and press Shift+Enter to run\n",
-    "3. Enjoy!\n",
-    "\n",
-    "After you click \"Select Kernel\", if there is no option like `.venv (Python 3.12.9)` then please do the following:  \n",
-    "1. On Mac: From the Cursor menu, choose Settings >> VS Code Settings (NOTE: be sure to select `VSCode Settings` not `Cursor Settings`);  \n",
-    "On Windows PC: From the File menu, choose Preferences >> VS Code Settings(NOTE: be sure to select `VSCode Settings` not `Cursor Settings`)  \n",
-    "2. In the Settings search bar, type \"venv\"  \n",
-    "3. In the field \"Path to folder with a list of Virtual Environments\" put the path to the project root, like C:\\Users\\username\\projects\\agents (on a Windows PC) or /Users/username/projects/agents (on Mac or Linux).  \n",
-    "And then try again.\n",
-    "\n",
-    "Having problems with missing Python versions in that list? Have you ever used Anaconda before? It might be interferring. Quit Cursor, bring up a new command line, and make sure that your Anaconda environment is deactivated:    \n",
-    "`conda deactivate`  \n",
-    "And if you still have any problems with conda and python versions, it's possible that you will need to run this too:  \n",
-    "`conda config --set auto_activate_base false`  \n",
-    "and then from within the Agents directory, you should be able to run `uv python list` and see the Python 3.12 version."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First let's do an import. If you get an Import Error, double check that your Kernel is correct..\n",
-    "\n",
-    "from dotenv import load_dotenv\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Next it's time to load the API keys into environment variables\n",
-    "# If this returns false, see the next cell!\n",
-    "\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Wait, did that just output `False`??\n",
-    "\n",
-    "If so, the most common reason is that you didn't save your `.env` file after adding the key! Be sure to have saved.\n",
-    "\n",
-    "Also, make sure the `.env` file is named precisely `.env` and is in the project root directory (`agents`)\n",
-    "\n",
-    "By the way, your `.env` file should have a stop symbol next to it in Cursor on the left, and that's actually a good thing: that's Cursor saying to you, \"hey, I realize this is a file filled with secret information, and I'm not going to send it to an external AI to suggest changes, because your keys should not be shown to anyone else.\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Final reminders</h2>\n",
-    "            <span style=\"color:#ff7800;\">1. If you're not confident about Environment Variables or Web Endpoints / APIs, please read Topics 3 and 5 in this <a href=\"../guides/04_technical_foundations.ipynb\">technical foundations guide</a>.<br/>\n",
-    "            2. If you want to use AIs other than OpenAI, like Gemini, DeepSeek or Ollama (free), please see the first section in this <a href=\"../guides/09_ai_apis_and_ollama.ipynb\">AI APIs guide</a>.<br/>\n",
-    "            3. If you ever get a Name Error in Python, you can always fix it immediately; see the last section of this <a href=\"../guides/06_python_foundations.ipynb\">Python Foundations guide</a> and follow both tutorials and exercises.<br/>\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "OpenAI API Key exists and begins sk-proj-\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Check the key - if you're not using OpenAI, check whichever key you're using! Ollama doesn't need a key.\n",
-    "\n",
-    "import os\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set - please head to the troubleshooting guide in the setup folder\")\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - the all important import statement\n",
-    "# If you get an import error - head over to troubleshooting in the Setup folder\n",
-    "# Even for other LLM providers like Gemini, you still use this OpenAI import - see Guide 9 for why\n",
-    "\n",
-    "from openai import OpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now we'll create an instance of the OpenAI class\n",
-    "# If you're not sure what it means to create an instance of a class - head over to the guides folder (guide 6)!\n",
-    "# If you get a NameError - head over to the guides folder (guide 6)to learn about NameErrors - always instantly fixable\n",
-    "# If you're not using OpenAI, you just need to slightly modify this - precise instructions are in the AI APIs guide (guide 9)\n",
-    "\n",
-    "openai = OpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a list of messages in the familiar OpenAI format\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": \"What is 2+2?\"}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "ChatCompletion(id='chatcmpl-C9oVaLh1gjzKH07zcVLaXQ4o4FDQ7', choices=[Choice(finish_reason='stop', index=0, logprobs=None, message=ChatCompletionMessage(content='2 + 2 equals 4.', refusal=None, role='assistant', annotations=[], audio=None, function_call=None, tool_calls=None))], created=1756455142, model='gpt-4.1-nano-2025-04-14', object='chat.completion', service_tier='default', system_fingerprint='fp_c4c155951e', usage=CompletionUsage(completion_tokens=8, prompt_tokens=14, total_tokens=22, completion_tokens_details=CompletionTokensDetails(accepted_prediction_tokens=0, audio_tokens=0, reasoning_tokens=0, rejected_prediction_tokens=0), prompt_tokens_details=PromptTokensDetails(audio_tokens=0, cached_tokens=0)))\n",
-      "2 + 2 equals 4.\n"
-     ]
-    }
-   ],
-   "source": [
-    "# And now call it! Any problems, head to the troubleshooting guide\n",
-    "# This uses GPT 4.1 nano, the incredibly cheap model\n",
-    "# The APIs guide (guide 9) has exact instructions for using even cheaper or free alternatives to OpenAI\n",
-    "# If you get a NameError, head to the guides folder (guide 6) to learn about NameErrors - always instantly fixable\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-nano\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "print(response.choices[0].message.content)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - let's ask for a question:\n",
-    "\n",
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "If three people can paint three walls in three hours, how many people are needed to paint 18 walls in six hours?\n"
-     ]
-    }
-   ],
-   "source": [
-    "# ask it - this uses GPT 4.1 mini, still cheap but more powerful than nano\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "question = response.choices[0].message.content\n",
-    "\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# form a new messages list\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Let's analyze the problem step-by-step:\n",
-      "\n",
-      "---\n",
-      "\n",
-      "**Given:**\n",
-      "\n",
-      "- 3 people can paint 3 walls in 3 hours.\n",
-      "\n",
-      "**Question:**\n",
-      "\n",
-      "- How many people are needed to paint 18 walls in 6 hours?\n",
-      "\n",
-      "---\n",
-      "\n",
-      "### Step 1: Find the rate of painting per person\n",
-      "\n",
-      "- Total walls painted: 3 walls\n",
-      "- Total people: 3 people\n",
-      "- Total time: 3 hours\n",
-      "\n",
-      "**Walls per person per hour:**\n",
-      "\n",
-      "First, find how many walls 3 people paint per hour:\n",
-      "\n",
-      "\\[\n",
-      "\\frac{3 \\text{ walls}}{3 \\text{ hours}} = 1 \\text{ wall per hour by 3 people}\n",
-      "\\]\n",
-      "\n",
-      "So, 3 people paint 1 wall per hour.\n",
-      "\n",
-      "Then, walls per person per hour:\n",
-      "\n",
-      "\\[\n",
-      "\\frac{1 \\text{ wall per hour}}{3 \\text{ people}} = \\frac{1}{3} \\text{ wall per person per hour}\n",
-      "\\]\n",
-      "\n",
-      "---\n",
-      "\n",
-      "### Step 2: Calculate total work needed\n",
-      "\n",
-      "You want to paint 18 walls in 6 hours.\n",
-      "\n",
-      "This means the rate of painting must be:\n",
-      "\n",
-      "\\[\n",
-      "\\frac{18 \\text{ walls}}{6 \\text{ hours}} = 3 \\text{ walls per hour}\n",
-      "\\]\n",
-      "\n",
-      "---\n",
-      "\n",
-      "### Step 3: Find how many people are needed for this rate\n",
-      "\n",
-      "Since each person paints \\(\\frac{1}{3}\\) wall per hour,\n",
-      "\n",
-      "\\[\n",
-      "\\text{Number of people} \\times \\frac{1}{3} = 3 \\text{ walls per hour}\n",
-      "\\]\n",
-      "\n",
-      "Multiply both sides by 3:\n",
-      "\n",
-      "\\[\n",
-      "\\text{Number of people} = 3 \\times 3 = 9\n",
-      "\\]\n",
-      "\n",
-      "---\n",
-      "\n",
-      "### **Answer:**\n",
-      "\n",
-      "\\[\n",
-      "\\boxed{9}\n",
-      "\\]\n",
-      "\n",
-      "You need **9 people** to paint 18 walls in 6 hours.\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Ask it again\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "answer = response.choices[0].message.content\n",
-    "print(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "Let's analyze the problem step-by-step:\n",
-       "\n",
-       "---\n",
-       "\n",
-       "**Given:**\n",
-       "\n",
-       "- 3 people can paint 3 walls in 3 hours.\n",
-       "\n",
-       "**Question:**\n",
-       "\n",
-       "- How many people are needed to paint 18 walls in 6 hours?\n",
-       "\n",
-       "---\n",
-       "\n",
-       "### Step 1: Find the rate of painting per person\n",
-       "\n",
-       "- Total walls painted: 3 walls\n",
-       "- Total people: 3 people\n",
-       "- Total time: 3 hours\n",
-       "\n",
-       "**Walls per person per hour:**\n",
-       "\n",
-       "First, find how many walls 3 people paint per hour:\n",
-       "\n",
-       "\\[\n",
-       "\\frac{3 \\text{ walls}}{3 \\text{ hours}} = 1 \\text{ wall per hour by 3 people}\n",
-       "\\]\n",
-       "\n",
-       "So, 3 people paint 1 wall per hour.\n",
-       "\n",
-       "Then, walls per person per hour:\n",
-       "\n",
-       "\\[\n",
-       "\\frac{1 \\text{ wall per hour}}{3 \\text{ people}} = \\frac{1}{3} \\text{ wall per person per hour}\n",
-       "\\]\n",
-       "\n",
-       "---\n",
-       "\n",
-       "### Step 2: Calculate total work needed\n",
-       "\n",
-       "You want to paint 18 walls in 6 hours.\n",
-       "\n",
-       "This means the rate of painting must be:\n",
-       "\n",
-       "\\[\n",
-       "\\frac{18 \\text{ walls}}{6 \\text{ hours}} = 3 \\text{ walls per hour}\n",
-       "\\]\n",
-       "\n",
-       "---\n",
-       "\n",
-       "### Step 3: Find how many people are needed for this rate\n",
-       "\n",
-       "Since each person paints \\(\\frac{1}{3}\\) wall per hour,\n",
-       "\n",
-       "\\[\n",
-       "\\text{Number of people} \\times \\frac{1}{3} = 3 \\text{ walls per hour}\n",
-       "\\]\n",
-       "\n",
-       "Multiply both sides by 3:\n",
-       "\n",
-       "\\[\n",
-       "\\text{Number of people} = 3 \\times 3 = 9\n",
-       "\\]\n",
-       "\n",
-       "---\n",
-       "\n",
-       "### **Answer:**\n",
-       "\n",
-       "\\[\n",
-       "\\boxed{9}\n",
-       "\\]\n",
-       "\n",
-       "You need **9 people** to paint 18 walls in 6 hours."
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Congratulations!\n",
-    "\n",
-    "That was a small, simple step in the direction of Agentic AI, with your new environment!\n",
-    "\n",
-    "Next time things get more interesting..."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Now try this commercial application:<br/>\n",
-    "            First ask the LLM to pick a business area that might be worth exploring for an Agentic AI opportunity.<br/>\n",
-    "            Then ask the LLM to present a pain-point in that industry - something challenging that might be ripe for an Agentic solution.<br/>\n",
-    "            Finally have 3 third LLM call propose the Agentic AI solution. <br/>\n",
-    "            We will cover this at up-coming labs, so don't worry if you're unsure.. just give it a try!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "Certainly! Building on your outlined pain-point and the high-level Agentic AI functionalities, here’s a detailed proposal for an **Agentic AI solution** designed to tackle fragmented patient data and enable real-time, holistic health management.\n",
-       "\n",
-       "---\n",
-       "\n",
-       "# Agentic AI Solution Proposal: **HealthSynth AI**\n",
-       "\n",
-       "### Overview  \n",
-       "**HealthSynth AI** is an autonomous health management agent that continuously synthesizes fragmented patient data from multiple sources to provide a real-time, unified, and actionable health profile for patients and their care teams. It acts as a 24/7 health assistant, proactive coordinator, and personalized medical advisor.\n",
-       "\n",
-       "---\n",
-       "\n",
-       "## Key Features & Capabilities\n",
-       "\n",
-       "### 1. **Autonomous Data Aggregation & Normalization**  \n",
-       "- Uses API integrations, secure data exchanges (FHIR, HL7 standards), and device SDKs to continuously fetch data from:  \n",
-       "  - EHR systems across different providers  \n",
-       "  - Wearable and home medical devices (heart rate, glucose monitors, BP cuffs)  \n",
-       "  - Pharmacy records and prescription databases  \n",
-       "  - Lab results portals  \n",
-       "  - Insurance claims and coverage data  \n",
-       "- Applies intelligent data cleaning, deduplication, and semantic normalization to unify heterogeneous data formats into a consistent patient health graph.\n",
-       "\n",
-       "### 2. **Real-Time Multimodal Health Analytics Engine**  \n",
-       "- Employs advanced ML and deep learning models to detect:  \n",
-       "  - Emerging risk patterns (e.g., early signs of infection, deterioration of chronic conditions)  \n",
-       "  - Anomalies (missed medications, unusual vital sign changes)  \n",
-       "  - Compliance gaps (lifestyle, medication adherence)  \n",
-       "- Continuously updates predictive health trajectories personalized to each patient’s condition and history.\n",
-       "\n",
-       "### 3. **Proactive Action & Recommendation System**  \n",
-       "- Generates context-aware, evidence-based alerts and recommendations such as:  \n",
-       "  - Medication reminders or dosage adjustments flagged in consultation with prescribing physicians  \n",
-       "  - Suggestions for scheduling lab tests or specialist visits timely before symptoms worsen  \n",
-       "  - Lifestyle coaching tips adapted using patient preferences and progress  \n",
-       "- Classes recommendations into urgency tiers (info, caution, immediate action) and routes notifications appropriately.\n",
-       "\n",
-       "### 4. **Automated Care Coordination & Workflow Integration**  \n",
-       "- Interacts programmatically with provider scheduling systems, telemedicine platforms, pharmacies, and insurance portals to:  \n",
-       "  - Automatically request appointment reschedules or referrals based on patient status  \n",
-       "  - Notify involved healthcare professionals about critical health events or lab results  \n",
-       "  - Facilitate prescription renewals or modifications with minimal human intervention  \n",
-       "- Maintains secure, auditable communication logs ensuring compliance (HIPAA, GDPR).\n",
-       "\n",
-       "### 5. **Patient-Centric Digital Health Companion**  \n",
-       "- Provides patients with an intuitive mobile/web app featuring:  \n",
-       "  - A dynamic health dashboard summarizing key metrics, risks, and recent activities in plain language  \n",
-       "  - Intelligent daily check-ins and symptom trackers powered by conversational AI  \n",
-       "  - Adaptive educational content tailored to health literacy levels and language preferences  \n",
-       "  - Privacy controls empowering patients to manage data sharing settings\n",
-       "\n",
-       "---\n",
-       "\n",
-       "## Technical Architecture (High-Level)\n",
-       "\n",
-       "- **Data Ingestion Layer:** Connectors for EHRs, wearables, pharmacies, labs  \n",
-       "- **Data Lake & Processing:** Cloud-native secure storage with HIPAA-compliant encryption  \n",
-       "- **Knowledge Graph:** Patient-centric semantic graph linking clinical concepts, timelines, interventions  \n",
-       "- **Analytics & ML Models:** Ensemble predictive models incorporating temporal health data, risk scoring, anomaly detection  \n",
-       "- **Agentic Orchestrator:** Rule-based and reinforcement learning-driven workflow engine enabling autonomous decision-making and stakeholder communications  \n",
-       "- **Frontend Interfaces:** Responsive patient app, provider portals, API access for system integration\n",
-       "\n",
-       "---\n",
-       "\n",
-       "## Potential Challenges & Mitigations\n",
-       "\n",
-       "| Challenge | Mitigation Strategy |\n",
-       "|-----------|---------------------|\n",
-       "| Data privacy & regulatory compliance | Built-in privacy-by-design, end-to-end encryption, rigorous consent management, audit trails |\n",
-       "| Data interoperability & standardization | Utilize open standards (FHIR, DICOM), NLP for unstructured data extraction |\n",
-       "| Model explainability | Implement interpretable ML techniques and transparent reasoning for clinicians |\n",
-       "| Patient engagement sustainability | Gamification, behavior science-driven personalized nudges |\n",
-       "| Integration complexity across healthcare IT systems | Modular adaptors/plugins, partnerships with major EHR vendors |\n",
-       "\n",
-       "---\n",
-       "\n",
-       "## Impact & Benefits\n",
-       "\n",
-       "- **For Patients:** Reduced health risks, increased empowerment, improved treatment adherence, and personal convenience  \n",
-       "- **For Providers:** Enhanced clinical decision support, reduced administrative burden, timely interventions  \n",
-       "- **For Payers:** Lowered costs via preventive care and reduced hospital readmissions\n",
-       "\n",
-       "---\n",
-       "\n",
-       "Would you like me to help you design detailed user journeys, develop specific ML model architectures, or draft an implementation roadmap for **HealthSynth AI**?"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# First create the messages:\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": \"I want you to pick a business area that might be worth exploring for an Agentic AI opportunity.\"}]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "# Then read the business idea:\n",
-    "\n",
-    "business_idea = response.choices[0].message.content\n",
-    "\n",
-    "# print(business_idea)\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": f\"Please propose a pain-point in the {business_idea} industry.\"}]\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "pain_point = response.choices[0].message.content\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": f\"Please propose an Agentic AI solution to the pain-point: {pain_point}.\"}]\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "agentic_solution = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(agentic_solution))\n",
-    "\n",
-    "# And repeat! In the next message, include the business idea within the message"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab1_Mudassar.ipynb

@@ -1,260 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# First Agentic AI workflow with OPENAI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### And please do remember to contact me if I can help\n",
-    "\n",
-    "And I love to connect: https://www.linkedin.com/in/muhammad-mudassar-a65645192/"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Import Libraries"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 59,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import re\n",
-    "from openai import OpenAI\n",
-    "from dotenv import load_dotenv\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai_api_key=os.getenv(\"OPENAI_API_KEY\")\n",
-    "if openai_api_key:\n",
-    "    print(f\"openai api key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set - please head to the troubleshooting guide in the gui\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Workflow with OPENAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai=OpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "message = [{'role':'user','content':\"what is 2+3?\"}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "response = openai.chat.completions.create(model=\"gpt-4o-mini\",messages=message)\n",
-    "print(response.choices[0].message.content)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "message=[{'role':'user','content':question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "response=openai.chat.completions.create(model=\"gpt-4o-mini\",messages=message)\n",
-    "question=response.choices[0].message.content\n",
-    "print(f\"Answer: {question}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "message=[{'role':'user','content':question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "response=openai.chat.completions.create(model=\"gpt-4o-mini\",messages=message)\n",
-    "answer = response.choices[0].message.content\n",
-    "print(f\"Answer: {answer}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# convert \\[ ... \\] to $$ ... $$, to properly render Latex\n",
-    "converted_answer = re.sub(r'\\\\[\\[\\]]', '$$', answer)\n",
-    "display(Markdown(converted_answer))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Exercise"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <span style=\"color:#ff7800;\">Now try this commercial application:<br/>\n",
-    "            First ask the LLM to pick a business area that might be worth exploring for an Agentic AI opportunity.<br/>\n",
-    "            Then ask the LLM to present a pain-point in that industry - something challenging that might be ripe for an Agentic solution.<br/>\n",
-    "            Finally have 3 third LLM call propose the Agentic AI solution.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "message = [{'role':'user','content':\"give me a business area related to ecommerce that might be worth exploring for a agentic opportunity.\"}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "response = openai.chat.completions.create(model=\"gpt-4o-mini\",messages=message)\n",
-    "business_area = response.choices[0].message.content\n",
-    "business_area"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "message = business_area + \"present a pain-point in that industry - something challenging that might be ripe for an agentic solutions.\"\n",
-    "message"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "message = [{'role': 'user', 'content': message}]\n",
-    "response = openai.chat.completions.create(model=\"gpt-4o-mini\",messages=message)\n",
-    "question=response.choices[0].message.content\n",
-    "question"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "message=[{'role':'user','content':question}]\n",
-    "response=openai.chat.completions.create(model=\"gpt-4o-mini\",messages=message)\n",
-    "answer=response.choices[0].message.content\n",
-    "print(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "display(Markdown(answer))"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab1_Thanh.ipynb

@@ -1,165 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Welcome to the start of your adventure in Agentic AI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### And please do remember to contact me if I can help\n",
-    "\n",
-    "And I love to connect: https://www.linkedin.com/in/eddonner/\n",
-    "\n",
-    "\n",
-    "### New to Notebooks like this one? Head over to the guides folder!\n",
-    "\n",
-    "Just to check you've already added the Python and Jupyter extensions to Cursor, if not already installed:\n",
-    "- Open extensions (View >> extensions)\n",
-    "- Search for python, and when the results show, click on the ms-python one, and Install it if not already installed\n",
-    "- Search for jupyter, and when the results show, click on the Microsoft one, and Install it if not already installed  \n",
-    "Then View >> Explorer to bring back the File Explorer.\n",
-    "\n",
-    "And then:\n",
-    "1. Click where it says \"Select Kernel\" near the top right, and select the option called `.venv (Python 3.12.9)` or similar, which should be the first choice or the most prominent choice. You may need to choose \"Python Environments\" first.\n",
-    "2. Click in each \"cell\" below, starting with the cell immediately below this text, and press Shift+Enter to run\n",
-    "3. Enjoy!\n",
-    "\n",
-    "After you click \"Select Kernel\", if there is no option like `.venv (Python 3.12.9)` then please do the following:  \n",
-    "1. On Mac: From the Cursor menu, choose Settings >> VS Code Settings (NOTE: be sure to select `VSCode Settings` not `Cursor Settings`);  \n",
-    "On Windows PC: From the File menu, choose Preferences >> VS Code Settings(NOTE: be sure to select `VSCode Settings` not `Cursor Settings`)  \n",
-    "2. In the Settings search bar, type \"venv\"  \n",
-    "3. In the field \"Path to folder with a list of Virtual Environments\" put the path to the project root, like C:\\Users\\username\\projects\\agents (on a Windows PC) or /Users/username/projects/agents (on Mac or Linux).  \n",
-    "And then try again.\n",
-    "\n",
-    "Having problems with missing Python versions in that list? Have you ever used Anaconda before? It might be interferring. Quit Cursor, bring up a new command line, and make sure that your Anaconda environment is deactivated:    \n",
-    "`conda deactivate`  \n",
-    "And if you still have any problems with conda and python versions, it's possible that you will need to run this too:  \n",
-    "`conda config --set auto_activate_base false`  \n",
-    "and then from within the Agents directory, you should be able to run `uv python list` and see the Python 3.12 version."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from dotenv import load_dotenv\n",
-    "load_dotenv()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Check the keys\n",
-    "import google.generativeai as genai\n",
-    "import os\n",
-    "genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))\n",
-    "model = genai.GenerativeModel(model_name=\"gemini-1.5-flash\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a list of messages in the familiar Gemini GenAI format\n",
-    "\n",
-    "response = model.generate_content([\"2+2=?\"])\n",
-    "response.text"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - let's ask for a question:\n",
-    "\n",
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "\n",
-    "response = model.generate_content([question])\n",
-    "print(response.text)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "display(Markdown(response.text))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Congratulations!\n",
-    "\n",
-    "That was a small, simple step in the direction of Agentic AI, with your new environment!\n",
-    "\n",
-    "Next time things get more interesting..."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First create the messages:\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": \"Something here\"}]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "\n",
-    "response =\n",
-    "\n",
-    "# Then read the business idea:\n",
-    "\n",
-    "business_idea = response.\n",
-    "\n",
-    "# And repeat!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "llm_projects",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.15"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab1_cm.ipynb

@@ -1,305 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Welcome to the start of your adventure in Agentic AI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Are you ready for action??</h2>\n",
-    "            <span style=\"color:#ff7800;\">Have you completed all the setup steps in the <a href=\"../setup/\">setup</a> folder?<br/>\n",
-    "            Have you checked out the guides in the <a href=\"../guides/01_intro.ipynb\">guides</a> folder?<br/>\n",
-    "            Well in that case, you're ready!!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../../assets/tools.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Treat these labs as a resource</h2>\n",
-    "            <span style=\"color:#00bfff;\">I push updates to the code regularly. When people ask questions or have problems, I incorporate it in the code, adding more examples or improved commentary. As a result, you'll notice that the code below isn't identical to the videos. Everything from the videos is here; but in addition, I've added more steps and better explanations. Consider this like an interactive book that accompanies the lectures.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### And please do remember to contact me if I can help\n",
-    "\n",
-    "And I love to connect: https://www.linkedin.com/in/eddonner/\n",
-    "\n",
-    "\n",
-    "### New to Notebooks like this one? Head over to the guides folder!\n",
-    "\n",
-    "Just to check you've already added the Python and Jupyter extensions to Cursor, if not already installed:\n",
-    "- Open extensions (View >> extensions)\n",
-    "- Search for python, and when the results show, click on the ms-python one, and Install it if not already installed\n",
-    "- Search for jupyter, and when the results show, click on the Microsoft one, and Install it if not already installed  \n",
-    "Then View >> Explorer to bring back the File Explorer.\n",
-    "\n",
-    "And then:\n",
-    "1. Run `uv add google-genai` to install the Google Gemini library. (If you had started your environment before running this command, you will need to restart your environment in the Jupyter notebook.)\n",
-    "2. Click where it says \"Select Kernel\" near the top right, and select the option called `.venv (Python 3.12.9)` or similar, which should be the first choice or the most prominent choice. You may need to choose \"Python Environments\" first.\n",
-    "3. Click in each \"cell\" below, starting with the cell immediately below this text, and press Shift+Enter to run\n",
-    "4. Enjoy!\n",
-    "\n",
-    "After you click \"Select Kernel\", if there is no option like `.venv (Python 3.12.9)` then please do the following:  \n",
-    "1. From the Cursor menu, choose Settings >> VSCode Settings (NOTE: be sure to select `VSCode Settings` not `Cursor Settings`)  \n",
-    "2. In the Settings search bar, type \"venv\"  \n",
-    "3. In the field \"Path to folder with a list of Virtual Environments\" put the path to the project root, like C:\\Users\\username\\projects\\agents (on a Windows PC) or /Users/username/projects/agents (on Mac or Linux).  \n",
-    "And then try again.\n",
-    "\n",
-    "Having problems with missing Python versions in that list? Have you ever used Anaconda before? It might be interferring. Quit Cursor, bring up a new command line, and make sure that your Anaconda environment is deactivated:    \n",
-    "`conda deactivate`  \n",
-    "And if you still have any problems with conda and python versions, it's possible that you will need to run this too:  \n",
-    "`conda config --set auto_activate_base false`  \n",
-    "and then from within the Agents directory, you should be able to run `uv python list` and see the Python 3.12 version."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from dotenv import load_dotenv\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Next it's time to load the API keys into environment variables\n",
-    "\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Check the keys\n",
-    "\n",
-    "import os\n",
-    "gemini_api_key = os.getenv('GEMINI_API_KEY')\n",
-    "\n",
-    "if gemini_api_key:\n",
-    "    print(f\"Gemini API Key exists and begins {gemini_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"Gemini API Key not set - please head to the troubleshooting guide in the guides folder\")\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - the all important import statement\n",
-    "# If you get an import error - head over to troubleshooting guide\n",
-    "\n",
-    "from google import genai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now we'll create an instance of the Gemini GenAI class\n",
-    "# If you're not sure what it means to create an instance of a class - head over to the guides folder!\n",
-    "# If you get a NameError - head over to the guides folder to learn about NameErrors\n",
-    "\n",
-    "client = genai.Client(api_key=gemini_api_key)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a list of messages in the familiar Gemini GenAI format\n",
-    "\n",
-    "messages = [\"What is 2+2?\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now call it! Any problems, head to the troubleshooting guide\n",
-    "\n",
-    "response = client.models.generate_content(\n",
-    "    model=\"gemini-2.0-flash\", contents=messages\n",
-    ")\n",
-    "\n",
-    "print(response.text)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "# Lets no create a challenging question\n",
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "\n",
-    "# Ask the the model\n",
-    "response = client.models.generate_content(\n",
-    "    model=\"gemini-2.0-flash\", contents=question\n",
-    ")\n",
-    "\n",
-    "question = response.text\n",
-    "\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ask the models generated question to the model\n",
-    "response = client.models.generate_content(\n",
-    "    model=\"gemini-2.0-flash\", contents=question\n",
-    ")\n",
-    "\n",
-    "# Extract the answer from the response\n",
-    "answer = response.text\n",
-    "\n",
-    "# Debug log the answer\n",
-    "print(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "# Nicely format the answer using Markdown\n",
-    "display(Markdown(answer))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Congratulations!\n",
-    "\n",
-    "That was a small, simple step in the direction of Agentic AI, with your new environment!\n",
-    "\n",
-    "Next time things get more interesting..."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Now try this commercial application:<br/>\n",
-    "            First ask the LLM to pick a business area that might be worth exploring for an Agentic AI opportunity.<br/>\n",
-    "            Then ask the LLM to present a pain-point in that industry - something challenging that might be ripe for an Agentic solution.<br/>\n",
-    "            Finally have 3 third LLM call propose the Agentic AI solution.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First create the messages:\n",
-    "\n",
-    "\n",
-    "messages = [\"Something here\"]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "\n",
-    "response =\n",
-    "\n",
-    "# Then read the business idea:\n",
-    "\n",
-    "business_idea = response.\n",
-    "\n",
-    "# And repeat!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.10"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab1_gemini.ipynb

@@ -1,305 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Welcome to the start of your adventure in Agentic AI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Are you ready for action??</h2>\n",
-    "            <span style=\"color:#ff7800;\">Have you completed all the setup steps in the <a href=\"../setup/\">setup</a> folder?<br/>\n",
-    "            Have you checked out the guides in the <a href=\"../guides/01_intro.ipynb\">guides</a> folder?<br/>\n",
-    "            Well in that case, you're ready!!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../../assets/tools.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Treat these labs as a resource</h2>\n",
-    "            <span style=\"color:#00bfff;\">I push updates to the code regularly. When people ask questions or have problems, I incorporate it in the code, adding more examples or improved commentary. As a result, you'll notice that the code below isn't identical to the videos. Everything from the videos is here; but in addition, I've added more steps and better explanations. Consider this like an interactive book that accompanies the lectures.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### And please do remember to contact me if I can help\n",
-    "\n",
-    "And I love to connect: https://www.linkedin.com/in/eddonner/\n",
-    "\n",
-    "\n",
-    "### New to Notebooks like this one? Head over to the guides folder!\n",
-    "\n",
-    "Just to check you've already added the Python and Jupyter extensions to Cursor, if not already installed:\n",
-    "- Open extensions (View >> extensions)\n",
-    "- Search for python, and when the results show, click on the ms-python one, and Install it if not already installed\n",
-    "- Search for jupyter, and when the results show, click on the Microsoft one, and Install it if not already installed  \n",
-    "Then View >> Explorer to bring back the File Explorer.\n",
-    "\n",
-    "And then:\n",
-    "1. Run `uv add google-genai` to install the Google Gemini library. (If you had started your environment before running this command, you will need to restart your environment in the Jupyter notebook.)\n",
-    "2. Click where it says \"Select Kernel\" near the top right, and select the option called `.venv (Python 3.12.9)` or similar, which should be the first choice or the most prominent choice. You may need to choose \"Python Environments\" first.\n",
-    "3. Click in each \"cell\" below, starting with the cell immediately below this text, and press Shift+Enter to run\n",
-    "4. Enjoy!\n",
-    "\n",
-    "After you click \"Select Kernel\", if there is no option like `.venv (Python 3.12.9)` then please do the following:  \n",
-    "1. From the Cursor menu, choose Settings >> VSCode Settings (NOTE: be sure to select `VSCode Settings` not `Cursor Settings`)  \n",
-    "2. In the Settings search bar, type \"venv\"  \n",
-    "3. In the field \"Path to folder with a list of Virtual Environments\" put the path to the project root, like C:\\Users\\username\\projects\\agents (on a Windows PC) or /Users/username/projects/agents (on Mac or Linux).  \n",
-    "And then try again.\n",
-    "\n",
-    "Having problems with missing Python versions in that list? Have you ever used Anaconda before? It might be interferring. Quit Cursor, bring up a new command line, and make sure that your Anaconda environment is deactivated:    \n",
-    "`conda deactivate`  \n",
-    "And if you still have any problems with conda and python versions, it's possible that you will need to run this too:  \n",
-    "`conda config --set auto_activate_base false`  \n",
-    "and then from within the Agents directory, you should be able to run `uv python list` and see the Python 3.12 version."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from dotenv import load_dotenv\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Next it's time to load the API keys into environment variables\n",
-    "\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Check the keys\n",
-    "\n",
-    "import os\n",
-    "gemini_api_key = os.getenv('GEMINI_API_KEY')\n",
-    "\n",
-    "if gemini_api_key:\n",
-    "    print(f\"Gemini API Key exists and begins {gemini_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"Gemini API Key not set - please head to the troubleshooting guide in the guides folder\")\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - the all important import statement\n",
-    "# If you get an import error - head over to troubleshooting guide\n",
-    "\n",
-    "from google import genai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now we'll create an instance of the Gemini GenAI class\n",
-    "# If you're not sure what it means to create an instance of a class - head over to the guides folder!\n",
-    "# If you get a NameError - head over to the guides folder to learn about NameErrors\n",
-    "\n",
-    "client = genai.Client(api_key=gemini_api_key)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a list of messages in the familiar Gemini GenAI format\n",
-    "\n",
-    "messages = [\"What is 2+2?\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now call it! Any problems, head to the troubleshooting guide\n",
-    "\n",
-    "response = client.models.generate_content(\n",
-    "    model=\"gemini-2.0-flash\", contents=messages\n",
-    ")\n",
-    "\n",
-    "print(response.text)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "# Lets no create a challenging question\n",
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "\n",
-    "# Ask the the model\n",
-    "response = client.models.generate_content(\n",
-    "    model=\"gemini-2.0-flash\", contents=question\n",
-    ")\n",
-    "\n",
-    "question = response.text\n",
-    "\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ask the models generated question to the model\n",
-    "response = client.models.generate_content(\n",
-    "    model=\"gemini-2.0-flash\", contents=question\n",
-    ")\n",
-    "\n",
-    "# Extract the answer from the response\n",
-    "answer = response.text\n",
-    "\n",
-    "# Debug log the answer\n",
-    "print(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "# Nicely format the answer using Markdown\n",
-    "display(Markdown(answer))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Congratulations!\n",
-    "\n",
-    "That was a small, simple step in the direction of Agentic AI, with your new environment!\n",
-    "\n",
-    "Next time things get more interesting..."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Now try this commercial application:<br/>\n",
-    "            First ask the LLM to pick a business area that might be worth exploring for an Agentic AI opportunity.<br/>\n",
-    "            Then ask the LLM to present a pain-point in that industry - something challenging that might be ripe for an Agentic solution.<br/>\n",
-    "            Finally have 3 third LLM call propose the Agentic AI solution.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First create the messages:\n",
-    "\n",
-    "\n",
-    "messages = [\"Something here\"]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "\n",
-    "response =\n",
-    "\n",
-    "# Then read the business idea:\n",
-    "\n",
-    "business_idea = response.\n",
-    "\n",
-    "# And repeat!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.10"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab1_groq.ipynb

@@ -1,262 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Implementing Notebook 1 using various LLMs via Groq"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from dotenv import load_dotenv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set - please head to the troubleshooting guide in the setup folder\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set - please head to the troubleshooting guide in the setup folder\")\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from openai import OpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI(\n",
-    "    base_url=\"https://api.groq.com/openai/v1\",\n",
-    "    api_key=groq_api_key\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - let's ask for a question:\n",
-    "\n",
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# openai/gpt-oss-120b\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"openai/gpt-oss-120b\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "print(response.choices[0].message.content)\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# moonshotai/kimi-k2-instruct\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"moonshotai/kimi-k2-instruct\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "question = response.choices[0].message.content\n",
-    "\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# form a new messages list\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ask meta-llama/llama-guard-4-12b\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"llama-3.1-8b-instant\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "answer = response.choices[0].message.content\n",
-    "print(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "display(Markdown(question))\n",
-    "display(Markdown(answer))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Now try this commercial application:<br/>\n",
-    "            First ask the LLM to pick a business area that might be worth exploring for an Agentic AI opportunity.<br/>\n",
-    "            Then ask the LLM to present a pain-point in that industry - something challenging that might be ripe for an Agentic solution.<br/>\n",
-    "            Finally have 3 third LLM call propose the Agentic AI solution. <br/>\n",
-    "            We will cover this at up-coming labs, so don't worry if you're unsure.. just give it a try!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First create the messages:\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": \"Pick a business area that is worth exploring for a Gen-Z audience, that can be an agentic-ai opportunity. \\\n",
-    "             Somehwere where the concept of agentisation can be applied commerically. Respond only with the business idea.\"}]\n",
-    "\n",
-    "# Then make the first call: \n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model = \"qwen/qwen3-32b\",\n",
-    "    messages = messages\n",
-    ")\n",
-    "\n",
-    "# Then read the business idea:\n",
-    "\n",
-    "business_idea = response.choices[0].message.content\n",
-    "print(business_idea)\n",
-    "\n",
-    "# And repeat! In the next message, include the business idea within the message\n",
-    "\n",
-    "user_prompt_pain_point = f\"What is the pain point of the Gen-Z audience in the business area of {business_idea}?, that can be solved by an agentic-ai solution? Give a brief answer\"\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model = \"gemma2-9b-it\",\n",
-    "    messages = [{\"role\": \"user\", \"content\": user_prompt_pain_point}]\n",
-    ")\n",
-    "\n",
-    "pain_point = response.choices[0].message.content\n",
-    "print(pain_point)\n",
-    "\n",
-    "user_prompt_solution = f\"What is the solution to the pain point {pain_point} of the Gen-Z audience in the business area of {business_idea}?, that can be solved by an agentic-ai solution? Provide a step-by-step breakdown\"\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model = \"deepseek-r1-distill-llama-70b\",\n",
-    "    messages = [{\"role\": \"user\", \"content\": user_prompt_solution}]\n",
-    ")\n",
-    "\n",
-    "business_solution = response.choices[0].message.content"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "display(Markdown(business_solution))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab1_groq_llama.ipynb

@@ -1,296 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# First Agentic AI workflow with Groq and Llama-3.3 LLM(Free of cost) "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First let's do an import\n",
-    "from dotenv import load_dotenv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Next it's time to load the API keys into environment variables\n",
-    "\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Check the Groq API key\n",
-    "\n",
-    "import os\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"GROQ API Key exists and begins {groq_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"GROQ API Key not set\")\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - the all important import statement\n",
-    "# If you get an import error - head over to troubleshooting guide\n",
-    "\n",
-    "from groq import Groq"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a Groq instance\n",
-    "groq = Groq()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a list of messages in the familiar Groq format\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": \"What is 2+2?\"}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now call it!\n",
-    "\n",
-    "response = groq.chat.completions.create(model='llama-3.3-70b-versatile', messages=messages)\n",
-    "print(response.choices[0].message.content)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - let's ask for a question:\n",
-    "\n",
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ask it\n",
-    "response = groq.chat.completions.create(\n",
-    "    model=\"llama-3.3-70b-versatile\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "question = response.choices[0].message.content\n",
-    "\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# form a new messages list\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ask it again\n",
-    "\n",
-    "response = groq.chat.completions.create(\n",
-    "    model=\"llama-3.3-70b-versatile\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "answer = response.choices[0].message.content\n",
-    "print(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Now try this commercial application:<br/>\n",
-    "            First ask the LLM to pick a business area that might be worth exploring for an Agentic AI opportunity.<br/>\n",
-    "            Then ask the LLM to present a pain-point in that industry - something challenging that might be ripe for an Agentic solution.<br/>\n",
-    "            Finally have 3 third LLM call propose the Agentic AI solution.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First create the messages:\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": \"Give me a business area that might be ripe for an Agentic AI solution.\"}]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "\n",
-    "response = groq.chat.completions.create(model='llama-3.3-70b-versatile', messages=messages)\n",
-    "\n",
-    "# Then read the business idea:\n",
-    "\n",
-    "business_idea = response.choices[0].message.content\n",
-    "\n",
-    "\n",
-    "# And repeat!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "display(Markdown(business_idea))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Update the message with the business idea from previous step\n",
-    "messages = [{\"role\": \"user\", \"content\": \"What is the pain point in the business area of \" + business_idea + \"?\"}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Make the second call\n",
-    "response = groq.chat.completions.create(model='llama-3.3-70b-versatile', messages=messages)\n",
-    "# Read the pain point\n",
-    "pain_point = response.choices[0].message.content\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "display(Markdown(pain_point))\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Make the third call\n",
-    "messages = [{\"role\": \"user\", \"content\": \"What is the Agentic AI solution for the pain point of \" + pain_point + \"?\"}]\n",
-    "response = groq.chat.completions.create(model='llama-3.3-70b-versatile', messages=messages)\n",
-    "# Read the agentic solution\n",
-    "agentic_solution = response.choices[0].message.content\n",
-    "display(Markdown(agentic_solution))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.10"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab1_moneek.ipynb

@@ -1,407 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Welcome to the start of your adventure in Agentic AI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Are you ready for action??</h2>\n",
-    "            <span style=\"color:#ff7800;\">Have you completed all the setup steps in the <a href=\"../setup/\">setup</a> folder?<br/>\n",
-    "            Have you read the <a href=\"../README.md\">README</a>? Many common questions are answered here!<br/>\n",
-    "            Have you checked out the guides in the <a href=\"../guides/01_intro.ipynb\">guides</a> folder?<br/>\n",
-    "            Well in that case, you're ready!!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/tools.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">This code is a live resource - keep an eye out for my updates</h2>\n",
-    "            <span style=\"color:#00bfff;\">I push updates regularly. As people ask questions or have problems, I add more examples and improve explanations. As a result, the code below might not be identical to the videos, as I've added more steps and better comments. Consider this like an interactive book that accompanies the lectures.<br/><br/>\n",
-    "            I try to send emails regularly with important updates related to the course. You can find this in the 'Announcements' section of Udemy in the left sidebar. You can also choose to receive my emails via your Notification Settings in Udemy. I'm respectful of your inbox and always try to add value with my emails!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### And please do remember to contact me if I can help\n",
-    "\n",
-    "And I love to connect: https://www.linkedin.com/in/eddonner/\n",
-    "\n",
-    "\n",
-    "### New to Notebooks like this one? Head over to the guides folder!\n",
-    "\n",
-    "Just to check you've already added the Python and Jupyter extensions to Cursor, if not already installed:\n",
-    "- Open extensions (View >> extensions)\n",
-    "- Search for python, and when the results show, click on the ms-python one, and Install it if not already installed\n",
-    "- Search for jupyter, and when the results show, click on the Microsoft one, and Install it if not already installed  \n",
-    "Then View >> Explorer to bring back the File Explorer.\n",
-    "\n",
-    "And then:\n",
-    "1. Click where it says \"Select Kernel\" near the top right, and select the option called `.venv (Python 3.12.9)` or similar, which should be the first choice or the most prominent choice. You may need to choose \"Python Environments\" first.\n",
-    "2. Click in each \"cell\" below, starting with the cell immediately below this text, and press Shift+Enter to run\n",
-    "3. Enjoy!\n",
-    "\n",
-    "After you click \"Select Kernel\", if there is no option like `.venv (Python 3.12.9)` then please do the following:  \n",
-    "1. On Mac: From the Cursor menu, choose Settings >> VS Code Settings (NOTE: be sure to select `VSCode Settings` not `Cursor Settings`);  \n",
-    "On Windows PC: From the File menu, choose Preferences >> VS Code Settings(NOTE: be sure to select `VSCode Settings` not `Cursor Settings`)  \n",
-    "2. In the Settings search bar, type \"venv\"  \n",
-    "3. In the field \"Path to folder with a list of Virtual Environments\" put the path to the project root, like C:\\Users\\username\\projects\\agents (on a Windows PC) or /Users/username/projects/agents (on Mac or Linux).  \n",
-    "And then try again.\n",
-    "\n",
-    "Having problems with missing Python versions in that list? Have you ever used Anaconda before? It might be interferring. Quit Cursor, bring up a new command line, and make sure that your Anaconda environment is deactivated:    \n",
-    "`conda deactivate`  \n",
-    "And if you still have any problems with conda and python versions, it's possible that you will need to run this too:  \n",
-    "`conda config --set auto_activate_base false`  \n",
-    "and then from within the Agents directory, you should be able to run `uv python list` and see the Python 3.12 version."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First let's do an import. If you get an Import Error, double check that your Kernel is correct..\n",
-    "\n",
-    "from dotenv import load_dotenv\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Next it's time to load the API keys into environment variables\n",
-    "# If this returns false, see the next cell!\n",
-    "\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Wait, did that just output `False`??\n",
-    "\n",
-    "If so, the most common reason is that you didn't save your `.env` file after adding the key! Be sure to have saved.\n",
-    "\n",
-    "Also, make sure the `.env` file is named precisely `.env` and is in the project root directory (`agents`)\n",
-    "\n",
-    "By the way, your `.env` file should have a stop symbol next to it in Cursor on the left, and that's actually a good thing: that's Cursor saying to you, \"hey, I realize this is a file filled with secret information, and I'm not going to send it to an external AI to suggest changes, because your keys should not be shown to anyone else.\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Final reminders</h2>\n",
-    "            <span style=\"color:#ff7800;\">1. If you're not confident about Environment Variables or Web Endpoints / APIs, please read Topics 3 and 5 in this <a href=\"../guides/04_technical_foundations.ipynb\">technical foundations guide</a>.<br/>\n",
-    "            2. If you want to use AIs other than OpenAI, like Gemini, DeepSeek or Ollama (free), please see the first section in this <a href=\"../guides/09_ai_apis_and_ollama.ipynb\">AI APIs guide</a>.<br/>\n",
-    "            3. If you ever get a Name Error in Python, you can always fix it immediately; see the last section of this <a href=\"../guides/06_python_foundations.ipynb\">Python Foundations guide</a> and follow both tutorials and exercises.<br/>\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Check the key - if you're not using OpenAI, check whichever key you're using! Ollama doesn't need a key.\n",
-    "\n",
-    "import os\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set - please head to the troubleshooting guide in the setup folder\")\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - the all important import statement\n",
-    "# If you get an import error - head over to troubleshooting in the Setup folder\n",
-    "# Even for other LLM providers like Gemini, you still use this OpenAI import - see Guide 9 for why\n",
-    "\n",
-    "from openai import OpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now we'll create an instance of the OpenAI class\n",
-    "# If you're not sure what it means to create an instance of a class - head over to the guides folder (guide 6)!\n",
-    "# If you get a NameError - head over to the guides folder (guide 6)to learn about NameErrors - always instantly fixable\n",
-    "# If you're not using OpenAI, you just need to slightly modify this - precise instructions are in the AI APIs guide (guide 9)\n",
-    "\n",
-    "openai = OpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a list of messages in the familiar OpenAI format\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": \"What is 2+2?\"}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now call it! Any problems, head to the troubleshooting guide\n",
-    "# This uses GPT 4.1 nano, the incredibly cheap model\n",
-    "# The APIs guide (guide 9) has exact instructions for using even cheaper or free alternatives to OpenAI\n",
-    "# If you get a NameError, head to the guides folder (guide 6) to learn about NameErrors - always instantly fixable\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-nano\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "print(response.choices[0].message.content)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - let's ask for a question:\n",
-    "\n",
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ask it - this uses GPT 4.1 mini, still cheap but more powerful than nano\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "question = response.choices[0].message.content\n",
-    "\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# form a new messages list\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ask it again\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "answer = response.choices[0].message.content\n",
-    "print(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Congratulations!\n",
-    "\n",
-    "That was a small, simple step in the direction of Agentic AI, with your new environment!\n",
-    "\n",
-    "Next time things get more interesting..."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Now try this commercial application:<br/>\n",
-    "            First ask the LLM to pick a business area that might be worth exploring for an Agentic AI opportunity.<br/>\n",
-    "            Then ask the LLM to present a pain-point in that industry - something challenging that might be ripe for an Agentic solution.<br/>\n",
-    "            Finally have 3 third LLM call propose the Agentic AI solution. <br/>\n",
-    "            We will cover this at up-coming labs, so don't worry if you're unsure.. just give it a try!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First create the messages:\n",
-    "question = \"Pick a business area that may have agentic AI opportunities\"\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "# Then read the business idea:\n",
-    "\n",
-    "business_idea = response.choices[0].message.content\n",
-    "print(business_idea)\n",
-    "\n",
-    "# And repeat! In the next message, include the business idea within the message"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [{\"role\": \"user\", \"content\": question + \"\\n\\n\" + business_idea},\n",
-    "            {\"role\": \"assistant\", \"content\": \"What is the pain point in this industry?\" }]\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "pain_point = response.choices[0].message.content\n",
-    "print(pain_point)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [{\"role\": \"user\", \"content\": question + \"\\n\\n\" + business_idea + \"\\n\\n\" + pain_point},   \n",
-    "            {\"role\": \"assistant\", \"content\": \"What is the Agentic AI solution?\"}]\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4.1-mini\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "agentic_solution = response.choices[0].message.content\n",
-    "print(agentic_solution)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab1_open_router.ipynb

@@ -1,323 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Welcome to the start of your adventure in Agentic AI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Are you ready for action??</h2>\n",
-    "            <span style=\"color:#ff7800;\">Have you completed all the setup steps in the <a href=\"../setup/\">setup</a> folder?<br/>\n",
-    "            Have you checked out the guides in the <a href=\"../guides/01_intro.ipynb\">guides</a> folder?<br/>\n",
-    "            Well in that case, you're ready!!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/tools.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">This code is a live resource - keep an eye out for my updates</h2>\n",
-    "            <span style=\"color:#00bfff;\">I push updates regularly. As people ask questions or have problems, I add more examples and improve explanations. As a result, the code below might not be identical to the videos, as I've added more steps and better comments. Consider this like an interactive book that accompanies the lectures.<br/><br/>\n",
-    "            I try to send emails regularly with important updates related to the course. You can find this in the 'Announcements' section of Udemy in the left sidebar. You can also choose to receive my emails via your Notification Settings in Udemy. I'm respectful of your inbox and always try to add value with my emails!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### And please do remember to contact me if I can help\n",
-    "\n",
-    "And I love to connect: https://www.linkedin.com/in/eddonner/\n",
-    "\n",
-    "\n",
-    "### New to Notebooks like this one? Head over to the guides folder!\n",
-    "\n",
-    "Just to check you've already added the Python and Jupyter extensions to Cursor, if not already installed:\n",
-    "- Open extensions (View >> extensions)\n",
-    "- Search for python, and when the results show, click on the ms-python one, and Install it if not already installed\n",
-    "- Search for jupyter, and when the results show, click on the Microsoft one, and Install it if not already installed  \n",
-    "Then View >> Explorer to bring back the File Explorer.\n",
-    "\n",
-    "And then:\n",
-    "1. Click where it says \"Select Kernel\" near the top right, and select the option called `.venv (Python 3.12.9)` or similar, which should be the first choice or the most prominent choice. You may need to choose \"Python Environments\" first.\n",
-    "2. Click in each \"cell\" below, starting with the cell immediately below this text, and press Shift+Enter to run\n",
-    "3. Enjoy!\n",
-    "\n",
-    "After you click \"Select Kernel\", if there is no option like `.venv (Python 3.12.9)` then please do the following:  \n",
-    "1. On Mac: From the Cursor menu, choose Settings >> VS Code Settings (NOTE: be sure to select `VSCode Settings` not `Cursor Settings`);  \n",
-    "On Windows PC: From the File menu, choose Preferences >> VS Code Settings(NOTE: be sure to select `VSCode Settings` not `Cursor Settings`)  \n",
-    "2. In the Settings search bar, type \"venv\"  \n",
-    "3. In the field \"Path to folder with a list of Virtual Environments\" put the path to the project root, like C:\\Users\\username\\projects\\agents (on a Windows PC) or /Users/username/projects/agents (on Mac or Linux).  \n",
-    "And then try again.\n",
-    "\n",
-    "Having problems with missing Python versions in that list? Have you ever used Anaconda before? It might be interferring. Quit Cursor, bring up a new command line, and make sure that your Anaconda environment is deactivated:    \n",
-    "`conda deactivate`  \n",
-    "And if you still have any problems with conda and python versions, it's possible that you will need to run this too:  \n",
-    "`conda config --set auto_activate_base false`  \n",
-    "and then from within the Agents directory, you should be able to run `uv python list` and see the Python 3.12 version."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 76,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First let's do an import\n",
-    "from dotenv import load_dotenv\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Next it's time to load the API keys into environment variables\n",
-    "\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Check the keys\n",
-    "\n",
-    "import os\n",
-    "open_router_api_key = os.getenv('OPEN_ROUTER_API_KEY')\n",
-    "\n",
-    "if open_router_api_key:\n",
-    "    print(f\"Open router API Key exists and begins {open_router_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"Open router API Key not set - please head to the troubleshooting guide in the setup folder\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 79,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from openai import OpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 80,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Initialize the client to point at OpenRouter instead of OpenAI\n",
-    "# You can use the exact same OpenAI Python package—just swap the base_url!\n",
-    "client = OpenAI(\n",
-    "    base_url=\"https://openrouter.ai/api/v1\",\n",
-    "    api_key=open_router_api_key\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 81,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [{\"role\": \"user\", \"content\": \"What is 2+2?\"}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "client = OpenAI(\n",
-    "    base_url=\"https://openrouter.ai/api/v1\",\n",
-    "    api_key=open_router_api_key\n",
-    ")\n",
-    "\n",
-    "resp = client.chat.completions.create(\n",
-    "    # Select a model from https://openrouter.ai/models and provide the model name here\n",
-    "    model=\"meta-llama/llama-3.3-8b-instruct:free\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "print(resp.choices[0].message.content)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 83,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - let's ask for a question:\n",
-    "\n",
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "response = client.chat.completions.create(\n",
-    "    model=\"meta-llama/llama-3.3-8b-instruct:free\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "question = response.choices[0].message.content\n",
-    "\n",
-    "print(question)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 85,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# form a new messages list\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ask it again\n",
-    "\n",
-    "response = client.chat.completions.create(\n",
-    "    model=\"meta-llama/llama-3.3-8b-instruct:free\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "answer = response.choices[0].message.content\n",
-    "print(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Congratulations!\n",
-    "\n",
-    "That was a small, simple step in the direction of Agentic AI, with your new environment!\n",
-    "\n",
-    "Next time things get more interesting..."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Now try this commercial application:<br/>\n",
-    "            First ask the LLM to pick a business area that might be worth exploring for an Agentic AI opportunity.<br/>\n",
-    "            Then ask the LLM to present a pain-point in that industry - something challenging that might be ripe for an Agentic solution.<br/>\n",
-    "            Finally have 3 third LLM call propose the Agentic AI solution.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First create the messages:\n",
-    "\n",
-    "\n",
-    "messages = [\"Something here\"]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "\n",
-    "response =\n",
-    "\n",
-    "# Then read the business idea:\n",
-    "\n",
-    "business_idea = response.\n",
-    "\n",
-    "# And repeat!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab2_Kaushik_Parallelization.ipynb

@@ -1,355 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from IPython.display import Markdown"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Refresh dot env"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "open_api_key = os.getenv(\"OPENAI_API_KEY\")\n",
-    "google_api_key = os.getenv(\"GOOGLE_API_KEY\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create initial query to get challange reccomendation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "query = 'Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. '\n",
-    "query += 'Answer only with the question, no explanation.'\n",
-    "\n",
-    "messages = [{'role':'user', 'content':query}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(messages)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Call openai gpt-4o-mini "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    messages=messages,\n",
-    "    model='gpt-4o-mini'\n",
-    ")\n",
-    "\n",
-    "challange = response.choices[0].message.content\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(challange)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "competitors = []\n",
-    "answers = []"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create messages with the challange query"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [{'role':'user', 'content':challange}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(messages)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from threading import Thread"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def gpt_mini_processor():\n",
-    "    modleName = 'gpt-4o-mini'\n",
-    "    competitors.append(modleName)\n",
-    "    response_gpt = openai.chat.completions.create(\n",
-    "        messages=messages,\n",
-    "        model=modleName\n",
-    "    )\n",
-    "    answers.append(response_gpt.choices[0].message.content)\n",
-    "\n",
-    "def gemini_processor():\n",
-    "    gemini = OpenAI(api_key=google_api_key, base_url='https://generativelanguage.googleapis.com/v1beta/openai/')\n",
-    "    modleName = 'gemini-2.0-flash'\n",
-    "    competitors.append(modleName)\n",
-    "    response_gemini = gemini.chat.completions.create(\n",
-    "        messages=messages,\n",
-    "        model=modleName\n",
-    "    )\n",
-    "    answers.append(response_gemini.choices[0].message.content)\n",
-    "\n",
-    "def llama_processor():\n",
-    "    ollama = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "    modleName = 'llama3.2'\n",
-    "    competitors.append(modleName)\n",
-    "    response_llama = ollama.chat.completions.create(\n",
-    "        messages=messages,\n",
-    "        model=modleName\n",
-    "    )\n",
-    "    answers.append(response_llama.choices[0].message.content)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Paraller execution of LLM calls"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "thread1 = Thread(target=gpt_mini_processor)\n",
-    "thread2 = Thread(target=gemini_processor)\n",
-    "thread3 = Thread(target=llama_processor)\n",
-    "\n",
-    "thread1.start()\n",
-    "thread2.start()\n",
-    "thread3.start()\n",
-    "\n",
-    "thread1.join()\n",
-    "thread2.join()\n",
-    "thread3.join()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(competitors)\n",
-    "print(answers)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for competitor, answer in zip(competitors, answers):\n",
-    "    print(f'Competitor:{competitor}\\n\\n{answer}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "together = ''\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f'# Response from competitor {index + 1}\\n\\n'\n",
-    "    together += answer + '\\n\\n'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(together)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Prompt to judge the LLM results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "to_judge = f'''You are judging a competition between {len(competitors)} competitors.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{challange}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "{together}\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\"\"\"\n",
-    "\n",
-    "'''"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "to_judge_message = [{'role':'user', 'content':to_judge}]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Execute o3-mini to analyze the LLM results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    messages=to_judge_message,\n",
-    "    model='o3-mini'\n",
-    ")\n",
-    "result = response.choices[0].message.content\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "results_dict = json.loads(result)\n",
-    "ranks = results_dict[\"results\"]\n",
-    "for index, result in enumerate(ranks):\n",
-    "    competitor = competitors[int(result)-1]\n",
-    "    print(f\"Rank {index+1}: {competitor}\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.10"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/1_lab2_Routing_Workflow.ipynb

@@ -1,514 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Judging and Routing — Optimizing Resource Usage by Evaluating Problem Complexity"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In the original Lab 2, we explored the **Orchestrator–Worker pattern**, where a planner sent the same question to multiple agents, and a judge assessed their responses to evaluate agent intelligence.\n",
-    "\n",
-    "In this notebook, we extend that design by adding multiple judges and a routing component to optimize model usage based on task complexity. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Imports and Environment Setup"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "load_dotenv(override=True)\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "if openai_api_key and google_api_key and deepseek_api_key:\n",
-    "    print(\"All keys were loaded successfully\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2\n",
-    "!ollama pull mistral"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Creating Models"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The notebook uses instances of GPT, Gemini and DeepSeek APIs, along with two local models served via Ollama: ```llama3.2```  and ```mistral```."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model_specs = {\n",
-    "    \"gpt-4o-mini\" : None,\n",
-    "    \"gemini-2.0-flash\": {\n",
-    "        \"api_key\" : google_api_key,\n",
-    "        \"url\" : \"https://generativelanguage.googleapis.com/v1beta/openai/\"\n",
-    "    },\n",
-    "    \"deepseek-chat\" : {\n",
-    "        \"api_key\" : deepseek_api_key,\n",
-    "        \"url\" : \"https://api.deepseek.com/v1\"\n",
-    "    },\n",
-    "    \"llama3.2\" : {\n",
-    "        \"api_key\" : \"ollama\",\n",
-    "        \"url\" : \"http://localhost:11434/v1\"\n",
-    "    },\n",
-    "    \"mistral\" : {\n",
-    "        \"api_key\" : \"ollama\",\n",
-    "        \"url\" : \"http://localhost:11434/v1\"\n",
-    "    }\n",
-    "}\n",
-    "\n",
-    "def create_model(model_name):\n",
-    "    spec = model_specs[model_name]\n",
-    "    if spec is None:\n",
-    "        return OpenAI()\n",
-    "    \n",
-    "    return OpenAI(api_key=spec[\"api_key\"], base_url=spec[\"url\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "orchestrator_model = \"gemini-2.0-flash\"\n",
-    "generator = create_model(orchestrator_model)\n",
-    "router = create_model(orchestrator_model)\n",
-    "\n",
-    "qa_models = {\n",
-    "    model_name : create_model(model_name) \n",
-    "    for model_name in model_specs.keys()\n",
-    "}\n",
-    "\n",
-    "judges = {\n",
-    "    model_name : create_model(model_name) \n",
-    "    for model_name, specs in model_specs.items() \n",
-    "    if not(specs) or specs[\"api_key\"] != \"ollama\"\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Orchestrator-Worker Workflow"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "First, we generate a question to evaluate the intelligence of each LLM."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs \"\n",
-    "request += \"to evaluate and rank them based on their intelligence. \" \n",
-    "request += \"Answer **only** with the question, no explanation or preamble.\"\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]\n",
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "response = generator.chat.completions.create(\n",
-    "    model=orchestrator_model,\n",
-    "    messages=messages,\n",
-    ")\n",
-    "eval_question = response.choices[0].message.content"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "display(Markdown(eval_question))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Task Parallelization"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now, having the question and all the models instantiated it's time to see what each model has to say about the complex task it was given."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "question = [{\"role\": \"user\", \"content\": eval_question}]\n",
-    "answers = []\n",
-    "competitors = []\n",
-    "\n",
-    "for name, model in qa_models.items():\n",
-    "    response = model.chat.completions.create(model=name, messages=question)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    competitors.append(name)\n",
-    "    answers.append(answer)\n",
-    "\n",
-    "answers"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "report = \"# Answer report for each of the 5 models\\n\\n\"\n",
-    "report += \"\\n\\n\".join([f\"## **Model: {model}**\\n\\n{answer}\" for model, answer in zip(competitors, answers)])\n",
-    "display(Markdown(report))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Synthetizer/Judge"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The Judge Agents ranks the LLM responses based on coherence and relevance to the evaluation prompt. Judges vote and the final LLM ranking is based on the aggregated ranking of all three judges."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from competitor {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\"\n",
-    "\n",
-    "together"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_prompt = f\"\"\"\n",
-    "                You are judging a competition between {len(competitors)} LLM competitors.\n",
-    "                Each model has been given this nuanced question to evaluate their intelligence:\n",
-    "\n",
-    "                {eval_question}\n",
-    "\n",
-    "                Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "                Respond with JSON, and only JSON, with the following format:\n",
-    "                {{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "                With 'best competitor number being ONLY the number', for instance:\n",
-    "                {{\"results\": [\"5\", \"2\", \"4\", ...]}}\n",
-    "                Here are the responses from each competitor:\n",
-    "\n",
-    "                {together}\n",
-    "\n",
-    "                Now respond with the JSON with the ranked order of the competitors, nothing else. Do NOT include MARKDOWN FORMATTING or CODE BLOCKS. ONLY the JSON\n",
-    "                \"\"\"\n",
-    "\n",
-    "judge_messages = [{\"role\": \"user\", \"content\": judge_prompt}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from collections import defaultdict\n",
-    "import re\n",
-    "\n",
-    "N = len(competitors)\n",
-    "scores = defaultdict(int)\n",
-    "for judge_name, judge in judges.items():\n",
-    "    response = judge.chat.completions.create(\n",
-    "        model=judge_name,\n",
-    "        messages=judge_messages,\n",
-    "    )\n",
-    "    response = response.choices[0].message.content\n",
-    "    response_json = re.findall(r'\\{.*?\\}', response)[0]\n",
-    "    results = json.loads(response_json)[\"results\"]\n",
-    "    ranks = [int(result) for result in results]\n",
-    "    print(f\"Judge {judge_name} ranking:\")\n",
-    "    for i, c in enumerate(ranks):\n",
-    "        model_name = competitors[c - 1]\n",
-    "        print(f\"#{i+1} : {model_name}\")\n",
-    "        scores[c - 1] += (N - i)\n",
-    "    print()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sorted_indices = sorted(scores, key=scores.get)\n",
-    "\n",
-    "# Convert to model names\n",
-    "ranked_model_names = [competitors[i] for i in sorted_indices]\n",
-    "\n",
-    "print(\"Final ranking from best to worst:\")\n",
-    "for i, name in enumerate(ranked_model_names[::-1], 1):\n",
-    "    print(f\"#{i}: {name}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Routing Workflow"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We now define a routing agent responsible for classifying task complexity and delegating the prompt to the most appropriate model."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def classify_question_complexity(question: str, routing_agent, routing_model) -> int:\n",
-    "    \"\"\"\n",
-    "    Ask an LLM to classify the question complexity from 1 (easy) to 5 (very hard).\n",
-    "    \"\"\"\n",
-    "    prompt = f\"\"\"\n",
-    "        You are a classifier responsible for assigning a complexity level to user questions, based on how difficult they would be for a language model to answer.\n",
-    "\n",
-    "        Please read the question below and assign a complexity score from 1 to 5:\n",
-    "\n",
-    "        - Level 1: Very simple factual or definitional question (e.g., “What is the capital of France?”)\n",
-    "        - Level 2: Slightly more involved, requiring basic reasoning or comparison\n",
-    "        - Level 3: Moderate complexity, requiring synthesis, context understanding, or multi-part answers\n",
-    "        - Level 4: High complexity, requiring abstract thinking, ethical judgment, or creative generation\n",
-    "        - Level 5: Extremely challenging, requiring deep reasoning, philosophical reflection, or long-term multi-step inference\n",
-    "\n",
-    "        Respond ONLY with a single integer between 1 and 5 that best reflects the complexity of the question.\n",
-    "\n",
-    "        Question:\n",
-    "        {question}\n",
-    "        \"\"\"\n",
-    "\n",
-    "    response = routing_agent.chat.completions.create(\n",
-    "        model=routing_model,\n",
-    "        messages=[{\"role\": \"user\", \"content\": prompt}]\n",
-    "    )\n",
-    "    try:\n",
-    "        return int(response.choices[0].message.content.strip())\n",
-    "    except Exception:\n",
-    "        return 3  # default to medium complexity on error\n",
-    "    \n",
-    "def route_question_to_model(question: str, models_by_rank, classifier_model=router, model_name=orchestrator_model):\n",
-    "    level = classify_question_complexity(question, classifier_model, model_name)\n",
-    "    selected_model_name = models_by_rank[level - 1]\n",
-    "    return selected_model_name"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "difficulty_prompts = [\n",
-    "    \"Generate a very basic, factual question that a small or entry-level language model could answer easily. It should require no reasoning, just direct knowledge lookup.\",\n",
-    "    \"Generate a slightly involved question that requires basic reasoning, comparison, or combining two known facts. Still within the grasp of small models but not purely factual.\",\n",
-    "    \"Generate a moderately challenging question that requires some synthesis of ideas, multi-step reasoning, or contextual understanding. A mid-tier model should be able to answer it with effort.\",\n",
-    "    \"Generate a difficult question involving abstract thinking, open-ended reasoning, or ethical tradeoffs. The question should challenge large models to produce thoughtful and coherent responses.\",\n",
-    "    \"Generate an extremely complex and nuanced question that tests the limits of current language models. It should require deep reasoning, long-term planning, philosophy, or advanced multi-domain knowledge.\"\n",
-    "]\n",
-    "def generate_question(level, generator=generator, generator_model=orchestrator_model):\n",
-    "    prompt = (\n",
-    "        f\"{difficulty_prompts[level - 1]}\\n\"\n",
-    "        \"Answer only with the question, no explanation.\"\n",
-    "    )\n",
-    "    messages = [{\"role\": \"user\", \"content\": prompt}]\n",
-    "    response = generator.chat.completions.create(\n",
-    "        model=generator_model,  # or your planner model\n",
-    "        messages=messages\n",
-    "    )\n",
-    "    \n",
-    "    return response.choices[0].message.content\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Testing Routing Workflow"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Finally, to test the routing workflow, we create a function that accepts a task complexity level and triggers the full routing process.\n",
-    "\n",
-    "*Note: A level-N prompt isn't always assigned to the Nth-most capable model due to the classifier's subjective decisions.*"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def test_generation_routing(level):\n",
-    "    question = generate_question(level=level)\n",
-    "    answer_model = route_question_to_model(question, ranked_model_names)\n",
-    "    messages = [{\"role\": \"user\", \"content\": question}]\n",
-    "\n",
-    "    response =qa_models[answer_model].chat.completions.create(\n",
-    "            model=answer_model,  # or your planner model\n",
-    "            messages=messages\n",
-    "        )\n",
-    "    print(f\"Question : {question}\")\n",
-    "    print(f\"Routed to {answer_model}\")\n",
-    "    display(Markdown(response.choices[0].message.content))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_generation_routing(level=1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_generation_routing(level=2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_generation_routing(level=3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_generation_routing(level=4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_generation_routing(level=5)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2-Evaluator-AnnpaS18.ipynb

@@ -1,474 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Important point - please read</h2>\n",
-    "            <span style=\"color:#ff7800;\">The way I collaborate with you may be different to other courses you've taken. I prefer not to type code while you watch. Rather, I execute Jupyter Labs, like this, and give you an intuition for what's going on. My suggestion is that you carefully execute this yourself, <b>after</b> watching the lecture. Add print statements to understand what's going on, and then come up with your own variations.<br/><br/>If you have time, I'd love it if you submit a PR for changes in the community_contributions folder - instructions in the resources. Also, if you have a Github account, use this to showcase your variations. Not only is this essential practice, but it demonstrates your skills to others, including perhaps future clients or employers...\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "competitors = []\n",
-    "answers = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The API we know well\n",
-    "\n",
-    "model_name = \"gpt-4o-mini\"\n",
-    "\n",
-    "response = openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Anthropic has a slightly different API, and Max Tokens is required\n",
-    "\n",
-    "model_name = \"claude-3-7-sonnet-latest\"\n",
-    "\n",
-    "claude = Anthropic()\n",
-    "response = claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "answer = response.content[0].text\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gemini = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "response = gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "deepseek = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "model_name = \"deepseek-chat\"\n",
-    "\n",
-    "response = deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "groq = OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "response = groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## For the next cell, we will use Ollama\n",
-    "\n",
-    "Ollama runs a local web service that gives an OpenAI compatible endpoint,  \n",
-    "and runs models locally using high performance C++ code.\n",
-    "\n",
-    "If you don't have Ollama, install it here by visiting https://ollama.com then pressing Download and following the instructions.\n",
-    "\n",
-    "After it's installed, you should be able to visit here: http://localhost:11434 and see the message \"Ollama is running\"\n",
-    "\n",
-    "You might need to restart Cursor (and maybe reboot). Then open a Terminal (control+\\`) and run `ollama serve`\n",
-    "\n",
-    "Useful Ollama commands (run these in the terminal, or with an exclamation mark in this notebook):\n",
-    "\n",
-    "`ollama pull <model_name>` downloads a model locally  \n",
-    "`ollama ls` lists all the models you've downloaded  \n",
-    "`ollama rm <model_name>` deletes the specified model from your downloads"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Super important - ignore me at your peril!</h2>\n",
-    "            <span style=\"color:#ff7800;\">The model called <b>llama3.3</b> is FAR too large for home computers - it's not intended for personal computing and will consume all your resources! Stick with the nicely sized <b>llama3.2</b> or <b>llama3.2:1b</b> and if you want larger, try llama3.1 or smaller variants of Qwen, Gemma, Phi or DeepSeek. See the <A href=\"https://ollama.com/models\">the Ollama models page</a> for a full list of models and sizes.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ollama = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "model_name = \"llama3.2\"\n",
-    "\n",
-    "response = ollama.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# So where are we?\n",
-    "\n",
-    "print(competitors)\n",
-    "print(answers)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# It's nice to know how to use \"zip\"\n",
-    "for competitor, answer in zip(competitors, answers):\n",
-    "    print(f\"Competitor: {competitor}\\n\\n{answer}\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Let's bring this together - note the use of \"enumerate\"\n",
-    "\n",
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from competitor {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(together)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge = f\"\"\"You are judging a competition between {len(competitors)} competitors.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "{together}\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(judge)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Judgement time!\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=judge_messages,\n",
-    ")\n",
-    "results = response.choices[0].message.content\n",
-    "print(results)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# OK let's turn this into results!\n",
-    "\n",
-    "results_dict = json.loads(results)\n",
-    "ranks = results_dict[\"results\"]\n",
-    "for index, result in enumerate(ranks):\n",
-    "    competitor = competitors[int(result)-1]\n",
-    "    print(f\"Rank {index+1}: {competitor}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Which pattern(s) did this use? Try updating this to add another Agentic design pattern.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">These kinds of patterns - to send a task to multiple models, and evaluate results,\n",
-    "            are common where you need to improve the quality of your LLM response. This approach can be universally applied\n",
-    "            to business projects where accuracy is critical.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2-judge-prompt-changed.ipynb

@@ -1,476 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Important point - please read</h2>\n",
-    "            <span style=\"color:#ff7800;\">The way I collaborate with you may be different to other courses you've taken. I prefer not to type code while you watch. Rather, I execute Jupyter Labs, like this, and give you an intuition for what's going on. My suggestion is that you carefully execute this yourself, <b>after</b> watching the lecture. Add print statements to understand what's going on, and then come up with your own variations.<br/><br/>If you have time, I'd love it if you submit a PR for changes in the community_contributions folder - instructions in the resources. Also, if you have a Github account, use this to showcase your variations. Not only is this essential practice, but it demonstrates your skills to others, including perhaps future clients or employers...\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "competitors = []\n",
-    "answers = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The API we know well\n",
-    "\n",
-    "model_name = \"gpt-4o-mini\"\n",
-    "\n",
-    "response = openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Anthropic has a slightly different API, and Max Tokens is required\n",
-    "\n",
-    "model_name = \"claude-3-7-sonnet-latest\"\n",
-    "\n",
-    "claude = Anthropic()\n",
-    "response = claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "answer = response.content[0].text\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gemini = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "response = gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "deepseek = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "model_name = \"deepseek-chat\"\n",
-    "\n",
-    "response = deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "groq = OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "response = groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## For the next cell, we will use Ollama\n",
-    "\n",
-    "Ollama runs a local web service that gives an OpenAI compatible endpoint,  \n",
-    "and runs models locally using high performance C++ code.\n",
-    "\n",
-    "If you don't have Ollama, install it here by visiting https://ollama.com then pressing Download and following the instructions.\n",
-    "\n",
-    "After it's installed, you should be able to visit here: http://localhost:11434 and see the message \"Ollama is running\"\n",
-    "\n",
-    "You might need to restart Cursor (and maybe reboot). Then open a Terminal (control+\\`) and run `ollama serve`\n",
-    "\n",
-    "Useful Ollama commands (run these in the terminal, or with an exclamation mark in this notebook):\n",
-    "\n",
-    "`ollama pull <model_name>` downloads a model locally  \n",
-    "`ollama ls` lists all the models you've downloaded  \n",
-    "`ollama rm <model_name>` deletes the specified model from your downloads"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Super important - ignore me at your peril!</h2>\n",
-    "            <span style=\"color:#ff7800;\">The model called <b>llama3.3</b> is FAR too large for home computers - it's not intended for personal computing and will consume all your resources! Stick with the nicely sized <b>llama3.2</b> or <b>llama3.2:1b</b> and if you want larger, try llama3.1 or smaller variants of Qwen, Gemma, Phi or DeepSeek. See the <A href=\"https://ollama.com/models\">the Ollama models page</a> for a full list of models and sizes.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ollama = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "model_name = \"llama3.2\"\n",
-    "\n",
-    "response = ollama.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# So where are we?\n",
-    "\n",
-    "print(competitors)\n",
-    "print(answers)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# It's nice to know how to use \"zip\"\n",
-    "for competitor, answer in zip(competitors, answers):\n",
-    "    print(f\"Competitor: {competitor}\\n\\n{answer}\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Let's bring this together - note the use of \"enumerate\"\n",
-    "\n",
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from competitor {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(together)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge = f\"\"\"You are judging a competition between {len(competitors)} competitors.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "Answer only the number for example\n",
-    "{{\"results\": [\"1\", \"2\", \"3\", ...]}}\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "{together}\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(judge)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Judgement time!\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=judge_messages,\n",
-    ")\n",
-    "results = response.choices[0].message.content\n",
-    "print(results)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# OK let's turn this into results!\n",
-    "\n",
-    "results_dict = json.loads(results)\n",
-    "ranks = results_dict[\"results\"]\n",
-    "for index, result in enumerate(ranks):\n",
-    "    competitor = competitors[int(result)-1]\n",
-    "    print(f\"Rank {index+1}: {competitor}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Which pattern(s) did this use? Try updating this to add another Agentic design pattern.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">These kinds of patterns - to send a task to multiple models, and evaluate results,\n",
-    "            are common where you need to improve the quality of your LLM response. This approach can be universally applied\n",
-    "            to business projects where accuracy is critical.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2-parallelization.ipynb

@@ -1,440 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Changes I've made with this lab.\n",
-    "1) Modified the original question to instead generate a range of questions, 12 of them.  These questions will be used to evaluate each LLM's reasoning, knowledge, creativity, and ability to handle nuanced scenarios.\n",
-    "2) I've changed this lab to run the queries in parallel.  Thanks GPT for helping with the code to do that.  :)\n",
-    "3) Instead of having one LLM rate all the responses, I have all of the LLM's rate each others work and then use a Borda Count to asign points to determine the winner."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "gemini_api_key = os.getenv('GEMINI_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if gemini_api_key:\n",
-    "    print(f\"Gemini API Key exists and begins {gemini_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Gemini API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"\"\"You are being evaluated for your reasoning, knowledge, creativity, and ability to handle nuanced scenarios. \n",
-    "Generate 12 questions that cover the following categories:\n",
-    "- Logical reasoning and problem solving\n",
-    "- Creative writing and storytelling\n",
-    "- Factual accuracy and knowledge recall\n",
-    "- Following instructions with strict constraints\n",
-    "- Multi-step planning and organization\n",
-    "- Ethical dilemmas and debatable issues\n",
-    "- Philosophical or abstract reasoning\n",
-    "- Summarization and explanation at different levels\n",
-    "- Translation and multilingual ability\n",
-    "- Roleplay or adaptive communication style\n",
-    "\n",
-    "Number each question from 1 to 12. \n",
-    "The result should be a balanced benchmark question set that fully tests an LLM’s capabilities.\n",
-    "\n",
-    "Important: Output only clean plain text. \n",
-    "Do not use any markup, formatting symbols, quotation marks, brackets, lists, or special characters \n",
-    "that could cause misinterpretation. Only provide plain text questions, one per line, numbered 1 to 20.\n",
-    "\"\"\"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Generate the questions.\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(question))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "competitors = []\n",
-    "answers = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ask the LLM's in Parallel\n",
-    "\n",
-    "import asyncio\n",
-    "\n",
-    "clients = {\n",
-    "    \"openai\": OpenAI(),\n",
-    "    \"claude\": Anthropic(),\n",
-    "    \"gemini\": OpenAI(api_key=gemini_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\"),\n",
-    "    \"deepseek\": OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\"),\n",
-    "    \"groq\": OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\"),\n",
-    "}\n",
-    "\n",
-    "# Get the answers from the LLM\n",
-    "async def call_llm(model_name, messages):\n",
-    "    try:\n",
-    "        if \"claude\" in model_name:\n",
-    "            response = await asyncio.to_thread(\n",
-    "                clients[\"claude\"].messages.create,\n",
-    "                model=model_name,\n",
-    "                messages=messages,\n",
-    "                max_tokens=3000,\n",
-    "            )\n",
-    "            answer = \"\".join([c.text for c in response.content if c.type == \"text\"])\n",
-    "        \n",
-    "        elif \"gpt-4o-mini\" in model_name:\n",
-    "            response = await asyncio.to_thread(\n",
-    "                clients[\"openai\"].chat.completions.create,\n",
-    "                model=model_name,\n",
-    "                messages=messages,\n",
-    "            )\n",
-    "            answer = response.choices[0].message.content\n",
-    "\n",
-    "        elif \"gemini\" in model_name:\n",
-    "            response = await asyncio.to_thread(\n",
-    "                clients[\"gemini\"].chat.completions.create,\n",
-    "                model=model_name,\n",
-    "                messages=messages,\n",
-    "            )\n",
-    "            answer = response.choices[0].message.content\n",
-    "\n",
-    "        elif \"deepseek\" in model_name:\n",
-    "            response = await asyncio.to_thread(\n",
-    "                clients[\"deepseek\"].chat.completions.create,\n",
-    "                model=model_name,\n",
-    "                messages=messages,\n",
-    "            )\n",
-    "            answer = response.choices[0].message.content\n",
-    "\n",
-    "        elif \"llama\" in model_name:\n",
-    "            response = await asyncio.to_thread(\n",
-    "                clients[\"groq\"].chat.completions.create,\n",
-    "                model=model_name,\n",
-    "                messages=messages,\n",
-    "            )\n",
-    "            answer = response.choices[0].message.content\n",
-    "\n",
-    "        return model_name, answer        \n",
-    "\n",
-    "    except Exception as e:\n",
-    "        print (f\"❌ Error: {str(e)}\")\n",
-    "        return model_name, \"I was not able to generate answers for any of the questions.\"\n",
-    "\n",
-    "\n",
-    "# send out the calls to the LLM to ask teh questions.\n",
-    "async def ask_questions_in_parallel(messages):\n",
-    "    competitor_models = [\n",
-    "        \"gpt-4o-mini\",\n",
-    "        \"claude-3-7-sonnet-latest\",\n",
-    "        \"gemini-2.0-flash\",\n",
-    "        \"deepseek-chat\",\n",
-    "        \"llama-3.3-70b-versatile\"\n",
-    "    ]\n",
-    "\n",
-    "    # create tasks to call the LLM's in parallel\n",
-    "    tasks = [call_llm(model, messages) for model in competitor_models]\n",
-    "\n",
-    "    answers = []\n",
-    "    competitors = []\n",
-    "\n",
-    "    # When we have an answer, we can process it.  No waiting.\n",
-    "    for task in asyncio.as_completed(tasks):\n",
-    "        model_name, answer = await task\n",
-    "        competitors.append(model_name)\n",
-    "        answers.append(answer)\n",
-    "        print(f\"\\n✅ Got response from {model_name}\")\n",
-    "\n",
-    "    return competitors, answers"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Fire off the ask to all the LLM's at once.  Parallelization...\n",
-    "competitors, answers = await ask_questions_in_parallel(messages)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#Look at the results\n",
-    "print (len(answers))\n",
-    "print (len(competitors))\n",
-    "print (competitors)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Let's bring this together - note the use of \"enumerate\"\n",
-    "\n",
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from competitor {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(together)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "judge = f\"\"\"You are judging a competition between {len(competitors)} competitors.\n",
-    "Each model has been given the folowing questions:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your task is to evaluate the overall strength of the arguments presented by each competitor. \n",
-    "Consider the following factors:\n",
-    "- Clarity: how clearly the ideas are communicated\n",
-    "- Relevance: how directly the response addresses the question\n",
-    "- Depth: the level of reasoning, insight, or supporting evidence provided\n",
-    "- Persuasiveness: how compelling or convincing the response is overall\n",
-    "Respond with JSON, and only JSON.\n",
-    "The output must be a single JSON array of competitor names, ordered from best to worst.\n",
-    "Do not include any keys, labels, or extra text.\n",
-    "\n",
-    "Example format:\n",
-    "[\"1\", \"3\", \"5\", \"2\", \"4\"]\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "{together}\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\n",
-    "Do not deviate from the json format as described above.  Do not include the term ranking in the final json\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(judge)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Have each LLM rate all of the results.\n",
-    "results = dict()\n",
-    "LLM_result = ''\n",
-    "\n",
-    "competitors, answers = await ask_questions_in_parallel(judge_messages)\n",
-    "\n",
-    "results = dict()\n",
-    "for index, each_competitor in enumerate(competitors):\n",
-    "    results[each_competitor] = answers[index].strip()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# See the results\n",
-    "print (len(answers))\n",
-    "results = dict()\n",
-    "for index, each_competitor in enumerate(competitors):\n",
-    "    results[each_competitor] = answers[index]\n",
-    "\n",
-    "print (results)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Lets convert these rankings into scores.  Borda Count - (1st gets 4, 2nd gets 3, etc.).\n",
-    "number_of_competitors = len(competitors)\n",
-    "scores = {}\n",
-    "\n",
-    "for rankings in results.values():\n",
-    "    print(rankings)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# # Borda count points (1st gets n-1, 2nd gets n-2, etc.)\n",
-    "num_competitors = len(competitors)\n",
-    "\n",
-    "competitor_dict = dict()\n",
-    "for index, each_competitor in enumerate(competitors):\n",
-    "    competitor_dict[each_competitor] = index + 1\n",
-    "\n",
-    "borda_scores_dict = dict()\n",
-    "for each_competitor in competitors:\n",
-    "    if each_competitor not in borda_scores_dict:\n",
-    "        borda_scores_dict[each_competitor] = 0\n",
-    "\n",
-    "for voter_llm, ranking_str in results.items():\n",
-    "    ranking_indices = json.loads(ranking_str)\n",
-    "    ranking_indices = [int(x) for x in ranking_indices]\n",
-    "\n",
-    "    # For each position in the ranking, award points\n",
-    "    for position, competitor_index in enumerate(ranking_indices):\n",
-    "        competitor_name = competitors[competitor_index - 1]\n",
-    "\n",
-    "        # Borda count points (1st gets n-1, 2nd gets n-2, etc.)\n",
-    "        points = num_competitors - 1 - position  \n",
-    "        borda_scores_dict[competitor_name] += points\n",
-    "    \n",
-    "sorted_results = sorted(borda_scores_dict.items(), key=lambda x: x[1], reverse=True)\n",
-    "\n",
-    "print(f\"{'Rank':<4} {'LLM':<30} {'Points':<3}\")\n",
-    "print(\"-\" * 50)\n",
-    "\n",
-    "for rank, (llm, points) in enumerate(sorted_results, 1):\n",
-    "    print(f\"{rank:<4} {llm:<30} {points:<8}\")\n",
-    "\n",
-    "print(\"\\nQuestions asked:\")\n",
-    "print(question)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_Execution_measurement.py

@@ -1,401 +0,0 @@
-import os
-import json
-import asyncio
-import concurrent.futures
-import time
-from typing import Dict, List, Tuple, Optional
-from dotenv import load_dotenv
-from openai import OpenAI
-
-load_dotenv(override=True)
-
-openai = OpenAI()
-competitors = []
-answers = []
-together = ""
-openai_api_key = os.getenv('OPENAI_API_KEY')
-anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')
-google_api_key = os.getenv('GOOGLE_API_KEY')
-deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')
-groq_api_key = os.getenv('GROQ_API_KEY')
-
-models_dict = {
-    'openai': {
-        'model': 'gpt-4o-mini',
-        'api_key': openai_api_key,
-        'base_url': None
-    },
-    'gemini': {
-        'model': 'gemini-2.0-flash',
-        'api_key': google_api_key,
-        'base_url': 'https://generativelanguage.googleapis.com/v1beta/openai/'
-    },
-    'groq': {
-        'model': 'llama-3.3-70b-versatile',
-        'api_key': groq_api_key,
-        'base_url': 'https://api.groq.com/openai/v1'
-    },
-    'ollama': {
-        'model': 'llama3.2',
-        'api_key': 'ollama',
-        'base_url': 'http://localhost:11434/v1'
-    }
-}
-
-def key_checker():
-
-    if openai_api_key:
-        print(f"OpenAI API Key exists and begins {openai_api_key[:8]}")
-    else:
-        print("OpenAI API Key not set")
-        
-    if anthropic_api_key:
-        print(f"Anthropic API Key exists and begins {anthropic_api_key[:7]}")
-    else:
-        print("Anthropic API Key not set (and this is optional)")
-
-    if google_api_key:
-        print(f"Google API Key exists and begins {google_api_key[:2]}")
-    else:
-        print("Google API Key not set (and this is optional)")
-
-    if deepseek_api_key:
-        print(f"DeepSeek API Key exists and begins {deepseek_api_key[:3]}")
-    else:
-        print("DeepSeek API Key not set (and this is optional)")
-
-    if groq_api_key:
-        print(f"Groq API Key exists and begins {groq_api_key[:4]}")
-    else:
-        print("Groq API Key not set (and this is optional)")
-
-def question_prompt_generator():
-    request = "Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. "
-    request += "Answer only with the question, no explanation."
-    messages = [{"role": "user", "content": request}]
-    return messages
-
-def generate_competition_question():
-    """
-    Generate a challenging question for the LLM competition
-    Returns the question text and formatted messages for LLM calls
-    """
-    print("Generating competition question...")
-    question_prompt = question_prompt_generator()
-    question = llm_caller(question_prompt)
-    question_messages = [{"role": "user", "content": question}]
-    print(f"Question: \n{question}")
-    return question, question_messages
-
-def llm_caller(messages):
-    response = openai.chat.completions.create(
-    model="gpt-4o-mini",
-    messages=messages,
-    )
-    return response.choices[0].message.content
-
-def llm_caller_with_model(messages, model_name, api_key, base_url):
-    llm = None
-
-    if base_url:
-        try:
-            llm = OpenAI(api_key=api_key, base_url=base_url)
-        except Exception as e:
-            print(f"Error creating OpenAI client: {e}")
-            return None
-    else:
-        try:
-            llm = OpenAI(api_key=api_key)
-        except Exception as e:
-            print(f"Error creating OpenAI client: {e}")
-            return None
-
-    response = llm.chat.completions.create(model=model_name, messages=messages)
-    return response.choices[0].message.content
-
-def get_single_model_answer(provider: str, details: Dict, question_messages: List[Dict]) -> Tuple[str, Optional[str]]:
-    """
-    Call a single model and return (provider, answer) or (provider, None) if failed.
-    This function is designed to be used with ThreadPoolExecutor.
-    """
-    print(f"Calling model {provider}...")
-    try:
-        answer = llm_caller_with_model(question_messages, details['model'], details['api_key'], details['base_url'])
-        print(f"Model {provider} was successfully called!")
-        return provider, answer
-    except Exception as e:
-        print(f"Model {provider} failed to call: {e}")
-        return provider, None
-
-def get_models_answers(question_messages):
-    """
-    Sequential version - kept for backward compatibility
-    """
-    for provider, details in models_dict.items():
-        print(f"Calling model {provider}...")
-        try:
-            answer = llm_caller_with_model(question_messages, details['model'], details['api_key'], details['base_url'])
-            print(f"Model {provider} was successful called!")
-        except Exception as e:
-            print(f"Model {provider} failed to call: {e}")
-            continue
-        competitors.append(provider)
-        answers.append(answer)
-
-def get_models_answers_parallel(question_messages, max_workers: int = 4):
-    """
-    Parallel version - calls all models simultaneously using ThreadPoolExecutor
-    """
-    print("Starting parallel execution of all models...")
-    
-    # Clear previous results
-    competitors.clear()
-    answers.clear()
-    
-    # Use ThreadPoolExecutor for parallel execution
-    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
-        # Submit all tasks
-        future_to_provider = {
-            executor.submit(get_single_model_answer, provider, details, question_messages): provider 
-            for provider, details in models_dict.items()
-        }
-        
-        # Collect results as they complete
-        for future in concurrent.futures.as_completed(future_to_provider):
-            provider, answer = future.result()
-            if answer is not None:  # Only add successful calls
-                competitors.append(provider)
-                answers.append(answer)
-    
-    print(f"Parallel execution completed. {len(competitors)} models responded successfully.")
-
-async def get_single_model_answer_async(provider: str, details: Dict, question_messages: List[Dict]) -> Tuple[str, Optional[str]]:
-    """
-    Async version of single model call - for even better performance
-    """
-    print(f"Calling model {provider} (async)...")
-    try:
-        # Run the synchronous call in a thread pool
-        loop = asyncio.get_event_loop()
-        answer = await loop.run_in_executor(
-            None, 
-            llm_caller_with_model, 
-            question_messages, 
-            details['model'], 
-            details['api_key'], 
-            details['base_url']
-        )
-        print(f"Model {provider} was successfully called!")
-        return provider, answer
-    except Exception as e:
-        print(f"Model {provider} failed to call: {e}")
-        return provider, None
-
-async def get_models_answers_async(question_messages):
-    """
-    Async version - calls all models simultaneously using asyncio
-    """
-    print("Starting async execution of all models...")
-    
-    # Clear previous results
-    competitors.clear()
-    answers.clear()
-    
-    # Create tasks for all models
-    tasks = [
-        get_single_model_answer_async(provider, details, question_messages)
-        for provider, details in models_dict.items()
-    ]
-    
-    # Wait for all tasks to complete
-    results = await asyncio.gather(*tasks, return_exceptions=True)
-    
-    # Process results
-    for result in results:
-        if isinstance(result, Exception):
-            print(f"Task failed with exception: {result}")
-            continue
-        provider, answer = result
-        if answer is not None:  # Only add successful calls
-            competitors.append(provider)
-            answers.append(answer)
-    
-    print(f"Async execution completed. {len(competitors)} models responded successfully.")
-
-def together_maker(answers):
-    together = ""
-    for index, answer in enumerate(answers):
-        together += f"# Response from competitor {index+1}\n\n"
-        together += answer + "\n\n"    
-    return together
-
-def judge_prompt_generator(competitors, question, together):
-    judge = f"""You are judging a competition between {len(competitors)} competitors.
-    Each model has been given this question:
-
-    {question}
-
-    Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.
-    Respond with JSON, and only JSON, with the following format:
-    {{"results": ["best competitor number", "second best competitor number", "third best competitor number", ...]}}
-
-    Here are the responses from each competitor:
-
-    {together}
-
-    Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks."""
-    return judge
-
-def judge_caller(judge_prompt, competitors):
-    print(f"Calling judge...")
-    judge_messages = [{"role": "user", "content": judge_prompt}]
-    results = llm_caller_with_model(judge_messages, "o3-mini", openai_api_key, None)
-    results_dict = json.loads(results)
-    ranks = results_dict["results"]
-    for index, result in enumerate(ranks):
-        competitor = competitors[int(result)-1]
-        print(f"Rank {index+1}: {competitor}")
-    return ranks
-
-def compare_execution_methods(question_messages, runs_per_method=1):
-    """
-    Compare performance of different execution methods
-    """
-    methods = ['sequential', 'parallel', 'async']
-    results = {}
-    
-    for method in methods:
-        print(f"\n{'='*50}")
-        print(f"Testing {method} execution method")
-        print(f"{'='*50}")
-        
-        method_times = []
-        
-        for run in range(runs_per_method):
-            print(f"\nRun {run + 1}/{runs_per_method}")
-            
-            # Clear previous results
-            competitors.clear()
-            answers.clear()
-            
-            start_time = time.time()
-            
-            if method == 'sequential':
-                get_models_answers(question_messages)
-            elif method == 'parallel':
-                get_models_answers_parallel(question_messages, max_workers=4)
-            elif method == 'async':
-                asyncio.run(get_models_answers_async(question_messages))
-            
-            execution_time = time.time() - start_time
-            method_times.append(execution_time)
-            print(f"Run {run + 1} completed in {execution_time:.2f} seconds")
-        
-        avg_time = sum(method_times) / len(method_times)
-        results[method] = {
-            'times': method_times,
-            'avg_time': avg_time,
-            'successful_models': len(competitors)
-        }
-        
-        print(f"\n{method.upper()} Results:")
-        print(f"  Average time: {avg_time:.2f} seconds")
-        print(f"  Successful models: {len(competitors)}")
-        print(f"  All times: {[f'{t:.2f}s' for t in method_times]}")
-    
-    # Print comparison summary
-    print(f"\n{'='*60}")
-    print("PERFORMANCE COMPARISON SUMMARY")
-    print(f"{'='*60}")
-    
-    for method, data in results.items():
-        print(f"{method.upper():>12}: {data['avg_time']:>6.2f}s avg, {data['successful_models']} models")
-    
-    # Calculate speedup
-    if 'sequential' in results:
-        seq_time = results['sequential']['avg_time']
-        print(f"\nSpeedup vs Sequential:")
-        for method, data in results.items():
-            if method != 'sequential':
-                speedup = seq_time / data['avg_time']
-                print(f"  {method.upper()}: {speedup:.2f}x faster")
-    
-    return results
-
-def run_llm_competition(question_messages, execution_method, question):
-    """
-    Run the LLM competition with the specified execution method
-    """
-    print(f"\nUsing {execution_method} execution method...")
-    start_time = time.time()
-
-    if execution_method == 'sequential':
-        get_models_answers(question_messages)
-    elif execution_method == 'parallel':
-        get_models_answers_parallel(question_messages, max_workers=4)
-    elif execution_method == 'async':
-        asyncio.run(get_models_answers_async(question_messages))
-    else:
-        raise ValueError(f"Unknown execution method: {execution_method}")
-
-    execution_time = time.time() - start_time
-    print(f"Execution completed in {execution_time:.2f} seconds")
-
-    together = together_maker(answers)
-    judge_prompt = judge_prompt_generator(competitors, question, together)
-    judge_caller(judge_prompt, competitors)
-    
-    return execution_time
-
-# Interactive execution method selection
-def get_execution_method():
-    """
-    Prompt user to select execution method
-    """
-    print("\n" + "="*60)
-    print("EXECUTION METHOD SELECTION")
-    print("="*60)
-    print("Choose how to execute the LLM calls:")
-    print("1. Sequential - Call models one after another (original method)")
-    print("2. Parallel   - Call all models simultaneously (recommended)")
-    print("3. Async      - Use async/await for maximum performance")
-    print("4. Compare    - Run all methods and compare performance")
-    print("="*60)
-    
-    while True:
-        try:
-            choice = input("Enter your choice (1-4): ").strip()
-            
-            if choice == '1':
-                return 'sequential'
-            elif choice == '2':
-                return 'parallel'
-            elif choice == '3':
-                return 'async'
-            elif choice == '4':
-                return 'compare'
-            else:
-                print("Invalid choice. Please enter 1, 2, 3, or 4.")
-                continue
-        except KeyboardInterrupt:
-            print("\nExiting...")
-            exit(0)
-        except EOFError:
-            print("\nExiting...")
-            exit(0)
-
-def main():
-    key_checker()
-    
-    # Get user's execution method choice
-    EXECUTION_METHOD = get_execution_method()
-    # Generate the competition question and get the question messages
-    question, question_messages = generate_competition_question()
-
-    if EXECUTION_METHOD == 'compare':
-        print("\nRunning performance comparison...")
-        compare_execution_methods(question_messages, runs_per_method=1)
-    else:
-     run_llm_competition(question_messages, EXECUTION_METHOD, question)
-
-main()

community_contributions/2_lab2_ReAct_Pattern.ipynb

@@ -1,289 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Important point - please read</h2>\n",
-    "            <span style=\"color:#ff7800;\">The way I collaborate with you may be different to other courses you've taken. I prefer not to type code while you watch. Rather, I execute Jupyter Labs, like this, and give you an intuition for what's going on. My suggestion is that you carefully execute this yourself, <b>after</b> watching the lecture. Add print statements to understand what's going on, and then come up with your own variations.<br/><br/>If you have time, I'd love it if you submit a PR for changes in the community_contributions folder - instructions in the resources. Also, if you have a Github account, use this to showcase your variations. Not only is this essential practice, but it demonstrates your skills to others, including perhaps future clients or employers...\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Which pattern(s) did this use? Try updating this to add another Agentic design pattern.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# ReAct Pattern"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import openai\n",
-    "import os\n",
-    "from dotenv import load_dotenv\n",
-    "import io\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "from openai import OpenAI\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "\n",
-    "# Request prompt\n",
-    "request = (\n",
-    "    \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "    \"Answer only with the question, no explanation.\"\n",
-    ")\n",
-    "\n",
-    "\n",
-    "\n",
-    "def generate_question(prompt: str) -> str:\n",
-    "    response = openai.chat.completions.create(\n",
-    "        model='gpt-4o-mini',\n",
-    "        messages=[{'role': 'user', 'content': prompt}]\n",
-    "    )\n",
-    "    question = response.choices[0].message.content\n",
-    "    return question\n",
-    "\n",
-    "def react_agent_decide_model(question: str) -> str:\n",
-    "    prompt = f\"\"\"\n",
-    "            You are an intelligent AI assistant tasked with evaluating which language model is most suitable to answer a given question.\n",
-    "\n",
-    "            Available models:\n",
-    "            - OpenAI: excels at reasoning and factual answers.\n",
-    "            - Claude: better for philosophical, nuanced, and ethical topics.\n",
-    "            - Gemini: good for concise and structured summaries.\n",
-    "            - Groq: good for creative or exploratory tasks.\n",
-    "            - DeepSeek: strong at coding, technical reasoning, and multilingual responses.\n",
-    "\n",
-    "            Here is the question to answer:\n",
-    "            \"{question}\"\n",
-    "\n",
-    "            ### Thought:\n",
-    "            Which model is best suited to answer this question, and why?\n",
-    "\n",
-    "            ### Action:\n",
-    "            Respond with only the model name you choose (e.g., \"Claude\").\n",
-    "                \"\"\"\n",
-    "\n",
-    "    response = openai.chat.completions.create(\n",
-    "        model=\"o3-mini\",\n",
-    "        messages=[{\"role\": \"user\", \"content\": prompt}]\n",
-    "    )\n",
-    "    model = response.choices[0].message.content.strip()\n",
-    "    return model\n",
-    "\n",
-    "def generate_answer_openai(prompt):\n",
-    "    answer = openai.chat.completions.create(\n",
-    "            model='gpt-4o-mini',\n",
-    "            messages=[{'role': 'user', 'content': prompt}]\n",
-    "        ).choices[0].message.content\n",
-    "    return answer\n",
-    "\n",
-    "def generate_answer_anthropic(prompt):\n",
-    "    anthropic = Anthropic(api_key=anthropic_api_key)\n",
-    "    model_name = \"claude-3-5-sonnet-20240620\"\n",
-    "    answer = anthropic.messages.create(\n",
-    "            model=model_name,\n",
-    "            messages=[{'role': 'user', 'content': prompt}],\n",
-    "            max_tokens=1000\n",
-    "        ).content[0].text\n",
-    "    return answer\n",
-    "\n",
-    "def generate_answer_deepseek(prompt):\n",
-    "    deepseek = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "    model_name = \"deepseek-chat\"    \n",
-    "    answer = deepseek.chat.completions.create(\n",
-    "            model=model_name,\n",
-    "            messages=[{'role': 'user', 'content': prompt}],\n",
-    "            base_url='https://api.deepseek.com/v1'\n",
-    "        ).choices[0].message.content\n",
-    "    return answer\n",
-    "\n",
-    "def generate_answer_gemini(prompt):\n",
-    "    gemini=OpenAI(base_url='https://generativelanguage.googleapis.com/v1beta/openai/',api_key=google_api_key)\n",
-    "    model_name = \"gemini-2.0-flash\"\n",
-    "    answer = gemini.chat.completions.create(\n",
-    "            model=model_name,\n",
-    "            messages=[{'role': 'user', 'content': prompt}],\n",
-    "        ).choices[0].message.content\n",
-    "    return answer\n",
-    "\n",
-    "def generate_answer_groq(prompt):\n",
-    "    groq=OpenAI(base_url='https://api.groq.com/openai/v1',api_key=groq_api_key)\n",
-    "    model_name=\"llama3-70b-8192\"\n",
-    "    answer = groq.chat.completions.create(\n",
-    "            model=model_name,\n",
-    "            messages=[{'role': 'user', 'content': prompt}],\n",
-    "            base_url=\"https://api.groq.com/openai/v1\"\n",
-    "        ).choices[0].message.content\n",
-    "    return answer\n",
-    "\n",
-    "def main():\n",
-    "    print(\"Generating question...\")\n",
-    "    question = generate_question(request)\n",
-    "    print(f\"\\n🧠 Question: {question}\\n\")\n",
-    "    selected_model = react_agent_decide_model(question)\n",
-    "    print(f\"\\n🔹 {selected_model}:\\n\")\n",
-    "    \n",
-    "    if selected_model.lower() == \"openai\":\n",
-    "        answer = generate_answer_openai(question)\n",
-    "    elif selected_model.lower() == \"deepseek\":\n",
-    "        answer = generate_answer_deepseek(question)\n",
-    "    elif selected_model.lower() == \"gemini\":\n",
-    "        answer = generate_answer_gemini(question)\n",
-    "    elif selected_model.lower() == \"groq\":\n",
-    "        answer = generate_answer_groq(question)\n",
-    "    elif selected_model.lower() == \"claude\":\n",
-    "        answer = generate_answer_anthropic(question)\n",
-    "    print(f\"\\n🔹 {selected_model}:\\n{answer}\\n\")\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "main()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">These kinds of patterns - to send a task to multiple models, and evaluate results,\n",
-    "            are common where you need to improve the quality of your LLM response. This approach can be universally applied\n",
-    "            to business projects where accuracy is critical.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_akash_parallelization.ipynb

@@ -1,295 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI, AsyncOpenAI\n",
-    "from IPython.display import Markdown, display\n",
-    "import asyncio\n",
-    "from functools import partial"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = AsyncOpenAI()\n",
-    "response = await openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from dataclasses import dataclass\n",
-    "\n",
-    "@dataclass\n",
-    "class LLMResource:\n",
-    "    api_key: str\n",
-    "    model: str\n",
-    "    url: str = None # optional otherwise NOone\n",
-    "\n",
-    "llm_resources = [\n",
-    "    LLMResource(api_key=openai_api_key, model=\"gpt-4o-mini\"),\n",
-    "    LLMResource(api_key=google_api_key, model=\"gemini-2.5-flash\", url=\"https://generativelanguage.googleapis.com/v1beta/openai/\"),\n",
-    "    LLMResource(api_key=groq_api_key, model=\"qwen/qwen3-32b\", url=\"https://api.groq.com/openai/v1\"),\n",
-    "    LLMResource(api_key=\"ollama\", model=\"deepseek-r1:1.5b\", url=\"http://localhost:11434/v1\" )\n",
-    "]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "\n",
-    "async def llm_call(key, model_name, url, messages) -> tuple:\n",
-    "    if url is None:\n",
-    "        llm = AsyncOpenAI(api_key=key)\n",
-    "    else: \n",
-    "        llm = AsyncOpenAI(base_url=url,api_key=key)\n",
-    "    \n",
-    "    response = await llm.chat.completions.create(\n",
-    "        model=model_name, messages=messages)\n",
-    "    \n",
-    "    answer = (model_name, response.choices[0].message.content)\n",
-    "\n",
-    "    return answer #returns tuple of modle and response from LLM\n",
-    "\n",
-    "llm_callable = partial(llm_call, messages=messages) #prefill with messages\n",
-    "# Always remember to do this!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#gather all responses concurrently\n",
-    "tasks = [llm_callable(res.api_key,res.model,res.url) for res in llm_resources]\n",
-    "results =  await asyncio.gather(*tasks)\n",
-    "together =  [f'Response from competitor {model}:{answer}' for model,answer in results]#gather results once all model finish running\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge = f\"\"\"You are judging a competition between {len(llm_resources)} competitors.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{request}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "{together} # all responses\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors name, nothing else. Do not include markdown formatting or code blocks.\"\"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(judge)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Judgement time!\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=judge_messages,\n",
-    ")\n",
-    "results = response.choices[0].message.content\n",
-    "print(results)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# OK let's turn this into results!\n",
-    "\n",
-    "results_dict = json.loads(results)\n",
-    "\n",
-    "ranks = results_dict[\"results\"]\n",
-    "\n",
-    "for index, result in enumerate(ranks):\n",
-    "    print(f\"Rank {index+1}: {result}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Which pattern(s) did this use? Try updating this to add another Agentic design pattern.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">These kinds of patterns - to send a task to multiple models, and evaluate results,\n",
-    "            are common where you need to improve the quality of your LLM response. This approach can be universally applied\n",
-    "            to business projects where accuracy is critical.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_async.ipynb

@@ -1,474 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "import asyncio\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI, AsyncOpenAI\n",
-    "from anthropic import AsyncAnthropic\n",
-    "from pydantic import BaseModel"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')\n",
-    "ANTHROPIC_API_KEY = os.getenv('ANTHROPIC_API_KEY')\n",
-    "GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')\n",
-    "DEEPSEEK_API_KEY = os.getenv('DEEPSEEK_API_KEY')\n",
-    "GROQ_API_KEY = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if OPENAI_API_KEY:\n",
-    "    print(f\"OpenAI API Key exists and begins {OPENAI_API_KEY[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if ANTHROPIC_API_KEY:\n",
-    "    print(f\"Anthropic API Key exists and begins {ANTHROPIC_API_KEY[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if GOOGLE_API_KEY:\n",
-    "    print(f\"Google API Key exists and begins {GOOGLE_API_KEY[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if DEEPSEEK_API_KEY:\n",
-    "    print(f\"DeepSeek API Key exists and begins {DEEPSEEK_API_KEY[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if GROQ_API_KEY:\n",
-    "    print(f\"Groq API Key exists and begins {GROQ_API_KEY[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(messages)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = AsyncOpenAI()\n",
-    "response = await openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Define Pydantic model for storing LLM results\n",
-    "class LLMResult(BaseModel):\n",
-    "    model: str\n",
-    "    answer: str\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "results: list[LLMResult] = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The API we know well\n",
-    "async def openai_answer() -> None:\n",
-    "\n",
-    "  if OPENAI_API_KEY is None:\n",
-    "    return None\n",
-    "  \n",
-    "  print(\"OpenAI starting!\")\n",
-    "  model_name = \"gpt-4o-mini\"\n",
-    "\n",
-    "  try:\n",
-    "    response = await openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with OpenAI: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"OpenAI done!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Anthropic has a slightly different API, and Max Tokens is required\n",
-    "\n",
-    "async def anthropic_answer() -> None:\n",
-    "\n",
-    "  if ANTHROPIC_API_KEY is None:\n",
-    "    return None\n",
-    "  \n",
-    "  print(\"Anthropic starting!\")\n",
-    "  model_name = \"claude-3-7-sonnet-latest\"\n",
-    "\n",
-    "  claude = AsyncAnthropic()\n",
-    "  try:\n",
-    "    response = await claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "    answer = response.content[0].text\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with Anthropic: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"Anthropic done!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def google_answer() -> None:\n",
-    "\n",
-    "  if GOOGLE_API_KEY is None:\n",
-    "    return None\n",
-    "  \n",
-    "  print(\"Google starting!\")\n",
-    "  model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "  gemini = AsyncOpenAI(api_key=GOOGLE_API_KEY, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "  try:\n",
-    "    response = await gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer =  response.choices[0].message.content\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with Google: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"Google done!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def deepseek_answer() -> None:\n",
-    "\n",
-    "  if DEEPSEEK_API_KEY is None:\n",
-    "    return None\n",
-    "  \n",
-    "  print(\"DeepSeek starting!\")\n",
-    "  model_name = \"deepseek-chat\"\n",
-    "\n",
-    "  deepseek = AsyncOpenAI(api_key=DEEPSEEK_API_KEY, base_url=\"https://api.deepseek.com/v1\")\n",
-    "  try:\n",
-    "    response = await deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with DeepSeek: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"DeepSeek done!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def groq_answer() -> None:\n",
-    "\n",
-    "  if GROQ_API_KEY is None:\n",
-    "    return None\n",
-    "  \n",
-    "  print(\"Groq starting!\")\n",
-    "  model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "  groq = AsyncOpenAI(api_key=GROQ_API_KEY, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "  try:\n",
-    "    response = await groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with Groq: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"Groq done!\")\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## For the next cell, we will use Ollama\n",
-    "\n",
-    "Ollama runs a local web service that gives an OpenAI compatible endpoint,  \n",
-    "and runs models locally using high performance C++ code.\n",
-    "\n",
-    "If you don't have Ollama, install it here by visiting https://ollama.com then pressing Download and following the instructions.\n",
-    "\n",
-    "After it's installed, you should be able to visit here: http://localhost:11434 and see the message \"Ollama is running\"\n",
-    "\n",
-    "You might need to restart Cursor (and maybe reboot). Then open a Terminal (control+\\`) and run `ollama serve`\n",
-    "\n",
-    "Useful Ollama commands (run these in the terminal, or with an exclamation mark in this notebook):\n",
-    "\n",
-    "`ollama pull <model_name>` downloads a model locally  \n",
-    "`ollama ls` lists all the models you've downloaded  \n",
-    "`ollama rm <model_name>` deletes the specified model from your downloads"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Super important - ignore me at your peril!</h2>\n",
-    "            <span style=\"color:#ff7800;\">The model called <b>llama3.3</b> is FAR too large for home computers - it's not intended for personal computing and will consume all your resources! Stick with the nicely sized <b>llama3.2</b> or <b>llama3.2:1b</b> and if you want larger, try llama3.1 or smaller variants of Qwen, Gemma, Phi or DeepSeek. See the <A href=\"https://ollama.com/models\">the Ollama models page</a> for a full list of models and sizes.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def ollama_answer() -> None:\n",
-    "  model_name = \"llama3.2\"\n",
-    "\n",
-    "  print(\"Ollama starting!\")\n",
-    "  ollama = AsyncOpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "  try:\n",
-    "    response = await ollama.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with Ollama: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"Ollama done!\") "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def gather_answers():\n",
-    "  tasks = [\n",
-    "    openai_answer(),\n",
-    "    anthropic_answer(),\n",
-    "    google_answer(),\n",
-    "    deepseek_answer(),\n",
-    "    groq_answer(),\n",
-    "    ollama_answer()\n",
-    "  ]\n",
-    "  await asyncio.gather(*tasks)\n",
-    "\n",
-    "await gather_answers()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "together = \"\"\n",
-    "competitors = []\n",
-    "answers = []\n",
-    "\n",
-    "for res in results:\n",
-    "    competitor = res.model\n",
-    "    answer = res.answer\n",
-    "    competitors.append(competitor)\n",
-    "    answers.append(answer)\n",
-    "    together += f\"# Response from competitor {competitor}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\"\n",
-    "\n",
-    "print(f\"Number of competitors: {len(results)}\")\n",
-    "print(together)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge = f\"\"\"You are judging a competition between {len(results)} competitors.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "{together}\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(judge)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Judgement time!\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=judge_messages,\n",
-    ")\n",
-    "judgement = response.choices[0].message.content\n",
-    "print(judgement)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# OK let's turn this into results!\n",
-    "\n",
-    "results_dict = json.loads(judgement)\n",
-    "ranks = results_dict[\"results\"]\n",
-    "for index, comp in enumerate(ranks):\n",
-    "    print(f\"Rank {index+1}: {comp}\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_async_with_reasons.ipynb

@@ -1,490 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This was derived from 2_lab2_async. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "import asyncio\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI, AsyncOpenAI\n",
-    "from anthropic import AsyncAnthropic\n",
-    "from pydantic import BaseModel"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')\n",
-    "ANTHROPIC_API_KEY = os.getenv('ANTHROPIC_API_KEY')\n",
-    "GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')\n",
-    "DEEPSEEK_API_KEY = os.getenv('DEEPSEEK_API_KEY')\n",
-    "GROQ_API_KEY = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if OPENAI_API_KEY:\n",
-    "    print(f\"OpenAI API Key exists and begins {OPENAI_API_KEY[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if ANTHROPIC_API_KEY:\n",
-    "    print(f\"Anthropic API Key exists and begins {ANTHROPIC_API_KEY[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if GOOGLE_API_KEY:\n",
-    "    print(f\"Google API Key exists and begins {GOOGLE_API_KEY[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if DEEPSEEK_API_KEY:\n",
-    "    print(f\"DeepSeek API Key exists and begins {DEEPSEEK_API_KEY[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if GROQ_API_KEY:\n",
-    "    print(f\"Groq API Key exists and begins {GROQ_API_KEY[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(messages)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = AsyncOpenAI()\n",
-    "response = await openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Define Pydantic model for storing LLM results\n",
-    "class LLMResult(BaseModel):\n",
-    "    model: str\n",
-    "    answer: str\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "results: list[LLMResult] = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The API we know well\n",
-    "async def openai_answer() -> None:\n",
-    "\n",
-    "  if OPENAI_API_KEY is None:\n",
-    "    return None\n",
-    "  \n",
-    "  print(\"OpenAI starting!\")\n",
-    "  model_name = \"gpt-4o-mini\"\n",
-    "\n",
-    "  try:\n",
-    "    response = await openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with OpenAI: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"OpenAI done!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Anthropic has a slightly different API, and Max Tokens is required\n",
-    "\n",
-    "async def anthropic_answer() -> None:\n",
-    "\n",
-    "  if ANTHROPIC_API_KEY is None:\n",
-    "    return None\n",
-    "  \n",
-    "  print(\"Anthropic starting!\")\n",
-    "  model_name = \"claude-3-7-sonnet-latest\"\n",
-    "\n",
-    "  claude = AsyncAnthropic()\n",
-    "  try:\n",
-    "    response = await claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "    answer = response.content[0].text\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with Anthropic: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"Anthropic done!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def google_answer() -> None:\n",
-    "\n",
-    "  if GOOGLE_API_KEY is None:\n",
-    "    return None\n",
-    "  \n",
-    "  print(\"Google starting!\")\n",
-    "  model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "  gemini = AsyncOpenAI(api_key=GOOGLE_API_KEY, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "  try:\n",
-    "    response = await gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer =  response.choices[0].message.content\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with Google: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"Google done!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def deepseek_answer() -> None:\n",
-    "\n",
-    "  if DEEPSEEK_API_KEY is None:\n",
-    "    return None\n",
-    "  \n",
-    "  print(\"DeepSeek starting!\")\n",
-    "  model_name = \"deepseek-chat\"\n",
-    "\n",
-    "  deepseek = AsyncOpenAI(api_key=DEEPSEEK_API_KEY, base_url=\"https://api.deepseek.com/v1\")\n",
-    "  try:\n",
-    "    response = await deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with DeepSeek: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"DeepSeek done!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def groq_answer() -> None:\n",
-    "\n",
-    "  if GROQ_API_KEY is None:\n",
-    "    return None\n",
-    "  \n",
-    "  print(\"Groq starting!\")\n",
-    "  model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "  groq = AsyncOpenAI(api_key=GROQ_API_KEY, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "  try:\n",
-    "    response = await groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with Groq: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"Groq done!\")\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## For the next cell, we will use Ollama\n",
-    "\n",
-    "Ollama runs a local web service that gives an OpenAI compatible endpoint,  \n",
-    "and runs models locally using high performance C++ code.\n",
-    "\n",
-    "If you don't have Ollama, install it here by visiting https://ollama.com then pressing Download and following the instructions.\n",
-    "\n",
-    "After it's installed, you should be able to visit here: http://localhost:11434 and see the message \"Ollama is running\"\n",
-    "\n",
-    "You might need to restart Cursor (and maybe reboot). Then open a Terminal (control+\\`) and run `ollama serve`\n",
-    "\n",
-    "Useful Ollama commands (run these in the terminal, or with an exclamation mark in this notebook):\n",
-    "\n",
-    "`ollama pull <model_name>` downloads a model locally  \n",
-    "`ollama ls` lists all the models you've downloaded  \n",
-    "`ollama rm <model_name>` deletes the specified model from your downloads"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Super important - ignore me at your peril!</h2>\n",
-    "            <span style=\"color:#ff7800;\">The model called <b>llama3.3</b> is FAR too large for home computers - it's not intended for personal computing and will consume all your resources! Stick with the nicely sized <b>llama3.2</b> or <b>llama3.2:1b</b> and if you want larger, try llama3.1 or smaller variants of Qwen, Gemma, Phi or DeepSeek. See the <A href=\"https://ollama.com/models\">the Ollama models page</a> for a full list of models and sizes.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def ollama_answer() -> None:\n",
-    "  model_name = \"llama3.2\"\n",
-    "\n",
-    "  print(\"Ollama starting!\")\n",
-    "  ollama = AsyncOpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "  try:\n",
-    "    response = await ollama.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    results.append(LLMResult(model=model_name, answer=answer))\n",
-    "  except Exception as e:\n",
-    "    print(f\"Error with Ollama: {e}\")\n",
-    "    return None\n",
-    "\n",
-    "  print(\"Ollama done!\") "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def gather_answers():\n",
-    "  tasks = [\n",
-    "    openai_answer(),\n",
-    "    anthropic_answer(),\n",
-    "    google_answer(),\n",
-    "    deepseek_answer(),\n",
-    "    groq_answer(),\n",
-    "    ollama_answer()\n",
-    "  ]\n",
-    "  await asyncio.gather(*tasks)\n",
-    "\n",
-    "await gather_answers()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "together = \"\"\n",
-    "competitors = []\n",
-    "answers = []\n",
-    "\n",
-    "for res in results:\n",
-    "    competitor = res.model\n",
-    "    answer = res.answer\n",
-    "    competitors.append(competitor)\n",
-    "    answers.append(answer)\n",
-    "    together += f\"# Response from competitor {competitor}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\"\n",
-    "\n",
-    "print(f\"Number of competitors: {len(results)}\")\n",
-    "print(together)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge = f\"\"\"You are judging a competition between {len(results)} competitors.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...],\n",
-    "\"explanations\": [\"explanation for each rank\", \"explanation for each rank\", \"explanation for each rank\", ...]}}\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "{together}\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(judge)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Judgement time!\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=judge_messages,\n",
-    ")\n",
-    "judgement = response.choices[0].message.content\n",
-    "print(judgement)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# OK let's turn this into results!\n",
-    "\n",
-    "results_dict = json.loads(judgement)\n",
-    "ranks = results_dict[\"results\"]\n",
-    "explanations = results_dict[\"explanations\"]\n",
-    "for index, comp in enumerate(ranks):\n",
-    "    print(f\"Rank {index+1}: {comp} \\n\\t{explanations[index]}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_doclee99_gpt5_improves_gemini.25flash.ipynb

@@ -1,620 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Important point - please read</h2>\n",
-    "            <span style=\"color:#ff7800;\">The way I collaborate with you may be different to other courses you've taken. I prefer not to type code while you watch. Rather, I execute Jupyter Labs, like this, and give you an intuition for what's going on. My suggestion is that you carefully execute this yourself, <b>after</b> watching the lecture. Add print statements to understand what's going on, and then come up with your own variations.<br/><br/>If you have time, I'd love it if you submit a PR for changes in the community_contributions folder - instructions in the resources. Also, if you have a Github account, use this to showcase your variations. Not only is this essential practice, but it demonstrates your skills to others, including perhaps future clients or employers...\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "competitors = []\n",
-    "answers = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The API we know well\n",
-    "\n",
-    "model_name = \"gpt-4o-mini\"\n",
-    "\n",
-    "response = openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Anthropic has a slightly different API, and Max Tokens is required\n",
-    "\n",
-    "model_name = \"claude-3-7-sonnet-latest\"\n",
-    "\n",
-    "claude = Anthropic()\n",
-    "response = claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "answer = response.content[0].text\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gemini = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "response = gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "deepseek = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "model_name = \"deepseek-chat\"\n",
-    "\n",
-    "response = deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "groq = OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "response = groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## For the next cell, we will use Ollama\n",
-    "\n",
-    "Ollama runs a local web service that gives an OpenAI compatible endpoint,  \n",
-    "and runs models locally using high performance C++ code.\n",
-    "\n",
-    "If you don't have Ollama, install it here by visiting https://ollama.com then pressing Download and following the instructions.\n",
-    "\n",
-    "After it's installed, you should be able to visit here: http://localhost:11434 and see the message \"Ollama is running\"\n",
-    "\n",
-    "You might need to restart Cursor (and maybe reboot). Then open a Terminal (control+\\`) and run `ollama serve`\n",
-    "\n",
-    "Useful Ollama commands (run these in the terminal, or with an exclamation mark in this notebook):\n",
-    "\n",
-    "`ollama pull <model_name>` downloads a model locally  \n",
-    "`ollama ls` lists all the models you've downloaded  \n",
-    "`ollama rm <model_name>` deletes the specified model from your downloads"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Super important - ignore me at your peril!</h2>\n",
-    "            <span style=\"color:#ff7800;\">The model called <b>llama3.3</b> is FAR too large for home computers - it's not intended for personal computing and will consume all your resources! Stick with the nicely sized <b>llama3.2</b> or <b>llama3.2:1b</b> and if you want larger, try llama3.1 or smaller variants of Qwen, Gemma, Phi or DeepSeek. See the <A href=\"https://ollama.com/models\">the Ollama models page</a> for a full list of models and sizes.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ollama = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "model_name = \"llama3.2\"\n",
-    "\n",
-    "response = ollama.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# So where are we?\n",
-    "\n",
-    "print(competitors)\n",
-    "print(answers)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# It's nice to know how to use \"zip\"\n",
-    "for competitor, answer in zip(competitors, answers):\n",
-    "    print(f\"Competitor: {competitor}\\n\\n{answer}\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Let's bring this together - note the use of \"enumerate\"\n",
-    "\n",
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from competitor {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# print(together)\n",
-    "display(Markdown(together))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge = f\"\"\"You are judging a competition between {len(competitors)} competitors.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "{together}\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(judge)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Judgement time!\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=judge_messages,\n",
-    ")\n",
-    "results = response.choices[0].message.content\n",
-    "print(results)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# OK let's turn this into results!\n",
-    "\n",
-    "results_dict = json.loads(results)\n",
-    "ranks = results_dict[\"results\"]\n",
-    "for index, result in enumerate(ranks):\n",
-    "    competitor = competitors[int(result)-1]\n",
-    "    print(f\"Rank {index+1}: {competitor}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Which pattern(s) did this use? Try updating this to add another Agentic design pattern.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Implement Evaluator-Optimizer workflow design pattern - An Optimizer LLM analyzes the response of the top-ranked competitor\n",
-    "# and creates a system prompt designed to improve the response. The system prompot is then\n",
-    "# sent back to the top-ranked competitor to deliver a new response.  \n",
-    "# The optimizer LLM then compares the new response to the old response and surmises\n",
-    "# what aspects of the system prompt may be responsible for the differences in the responses.\n",
-    "\n",
-    "\n",
-    "\n",
-    "# Get the top competitor (model name) and their response\n",
-    "top_rank_index = int(ranks[0]) - 1\n",
-    "top_competitor_name = competitors[top_rank_index]\n",
-    "top_competitor_response = answers[top_rank_index]\n",
-    "top_competitor_prompt = question\n",
-    "\n",
-    "# Compose a system prompt for GPT-5 to act as an expert evaluator of question quality and answer depth\n",
-    "system_prompt = (\n",
-    "    \"You are an expert evaluator of LLM prompt quality and answer depth. \"\n",
-    "    \"Your task is to analyze the comprehensiveness and depth of thought in the following answer, \"\n",
-    "    \"which was generated by a language model in response to a challenging question. \"\n",
-    "    \"Consider aspects such as completeness, insight, reasoning, and nuance. \"\n",
-    "    \"Provide a detailed analysis of the answer's strengths and weaknesses and store in the 'markdown_analysis' property.\"\n",
-    "    \"Generate a suggested system prompt that will improve the answer and store in the 'system_prompt' property.\"\n",
-    ")\n",
-    "\n",
-    "# Compose the user prompt for GPT-5\n",
-    "user_prompt = (\n",
-    "    f\"Prompt:\\n{top_competitor_prompt}\\n\\n\"\n",
-    "    f\"Answer:\\n{top_competitor_response}\\n\\n\"\n",
-    "    \"Please analyze the comprehensiveness and depth of thought of the above answer. \"\n",
-    "    \"Discuss its strengths and weaknesses in detail.\"\n",
-    ")\n",
-    "\n",
-    "# Call GPT-5 to perform the evaluation\n",
-    "gpt5 = OpenAI()\n",
-    "\n",
-    "# Define the tool schema\n",
-    "tools = [\n",
-    "    {\n",
-    "        \"type\": \"function\",\n",
-    "        \"function\": {\n",
-    "            \"name\": \"markdown_and_structured_data\",\n",
-    "            \"description\": \"Provide both markdown analysis and structured data\",\n",
-    "            \"parameters\": {\n",
-    "                \"type\": \"object\",\n",
-    "                \"properties\": {\n",
-    "                    \"markdown_analysis\": {\n",
-    "                        \"type\": \"string\",\n",
-    "                        \"description\": \"Detailed markdown analysis\"\n",
-    "                    },\n",
-    "                    \"system_prompt\": {\n",
-    "                        \"type\": \"string\"\n",
-    "                    }\n",
-    "                },\n",
-    "                \"required\": [\"markdown_analysis\", \"sentiment\", \"confidence\", \"key_phrases\"]\n",
-    "            }\n",
-    "        }\n",
-    "    }\n",
-    "]\n",
-    "\n",
-    "gpt5_response = gpt5.chat.completions.create(\n",
-    "    model=\"gpt-5\",\n",
-    "    messages=[\n",
-    "        {\"role\": \"system\", \"content\": system_prompt},\n",
-    "        {\"role\": \"user\", \"content\": user_prompt}\n",
-    "    ],\n",
-    "    tools=tools,\n",
-    "    tool_choice={\"type\": \"function\", \"function\": {\"name\": \"markdown_and_structured_data\"}}\n",
-    ")\n",
-    "\n",
-    "tool_call = gpt5_response.choices[0].message.tool_calls[0]\n",
-    "arguments = json.loads(tool_call.function.arguments)\n",
-    "\n",
-    "markdown_analysis = arguments[\"markdown_analysis\"]\n",
-    "system_prompt = arguments[\"system_prompt\"]\n",
-    "\n",
-    "\n",
-    "\n",
-    "\n",
-    "# Display the evaluation\n",
-    "from IPython.display import Markdown, display\n",
-    "display(Markdown(\"### GPT-5 Evaluation of Top Competitor's Answer\"))\n",
-    "display(Markdown(f\"Top Competitor: {top_competitor_name}\"))\n",
-    "display(Markdown(markdown_analysis))\n",
-    "display(Markdown(\"### Suggested System Prompt\"))\n",
-    "display(Markdown(system_prompt))\n",
-    "\n",
-    "\n",
-    "# The top competitor was gemini-2.0-flash, so send the original question and suggested system prompt to generate a new response\n",
-    "# Send the system_prompt and original question to gemini-2.0-flash to generate a new answer\n",
-    "\n",
-    "gemini_response = gemini.chat.completions.create(\n",
-    "    model=\"gemini-2.0-flash\",\n",
-    "    messages=[\n",
-    "        {\"role\": \"system\", \"content\": system_prompt},\n",
-    "        {\"role\": \"user\", \"content\": question}\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "new_answer = gemini_response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(\"### Gemini-2.0-Flash New Answer with Suggested System Prompt\"))\n",
-    "display(Markdown(new_answer))\n",
-    "\n",
-    "comparison_prompt = f\"\"\"You are an expert LLM evaluator. Compare the following two answers to the same question, where the only difference is that the second answer was generated using a system prompt suggested by you (GPT-5) after evaluating the first answer.\n",
-    "\n",
-    "Original Answer (from {top_competitor_name}):\n",
-    "{top_competitor_response}\n",
-    "\n",
-    "New Answer (from {top_competitor_name} with your system prompt):\n",
-    "{new_answer}\n",
-    "\n",
-    "System Prompt Used for New Answer:\n",
-    "{system_prompt}\n",
-    "\n",
-    "Please analyze:\n",
-    "- What are the key differences between the two answers?\n",
-    "- What aspects of the system prompt likely contributed to these differences?\n",
-    "- Did the system prompt improve the quality, accuracy, or style of the answer? How?\n",
-    "- Any remaining limitations or further suggestions.\n",
-    "\n",
-    "Provide a detailed, structured analysis.\n",
-    "\"\"\"\n",
-    "\n",
-    "gpt5_comparison_response = gpt5.chat.completions.create(\n",
-    "    model=\"gpt-5\",\n",
-    "    messages=[\n",
-    "        {\"role\": \"system\", \"content\": \"You are an expert LLM evaluator.\"},\n",
-    "        {\"role\": \"user\", \"content\": comparison_prompt}\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "comparison_analysis = gpt5_comparison_response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(\"### GPT-5 Analysis: Impact of System Prompt on Gemini-2.0-Flash's Answer\"))\n",
-    "display(Markdown(comparison_analysis))\n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">These kinds of patterns - to send a task to multiple models, and evaluate results,\n",
-    "            are common where you need to improve the quality of your LLM response. This approach can be universally applied\n",
-    "            to business projects where accuracy is critical.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_exercise.ipynb

@@ -1,336 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# From Judging to Synthesizing — Evolving Multi-Agent Patterns\n",
-    "\n",
-    "In the original 2_lab2.ipynb, we explored a powerful agentic design pattern: sending the same question to multiple large language models (LLMs), then using a separate “judge” agent to evaluate and rank their responses. This approach is valuable for identifying the single best answer among many, leveraging the strengths of ensemble reasoning and critical evaluation.\n",
-    "\n",
-    "However, selecting just one “winner” can leave valuable insights from other models untapped. To address this, I am shifting to a new agentic pattern in this notebook: the synthesizer/improver pattern. Instead of merely ranking responses, we will prompt a dedicated LLM to review all answers, extract the most compelling ideas from each, and synthesize them into a single, improved response. \n",
-    "\n",
-    "This approach aims to combine the collective intelligence of multiple models, producing an answer that is richer, more nuanced, and more robust than any individual response.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their collective intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "teammates = []\n",
-    "answers = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The API we know well\n",
-    "\n",
-    "model_name = \"gpt-4o-mini\"\n",
-    "\n",
-    "response = openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "teammates.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Anthropic has a slightly different API, and Max Tokens is required\n",
-    "\n",
-    "model_name = \"claude-3-7-sonnet-latest\"\n",
-    "\n",
-    "claude = Anthropic()\n",
-    "response = claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "answer = response.content[0].text\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "teammates.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gemini = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "response = gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "teammates.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "deepseek = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "model_name = \"deepseek-chat\"\n",
-    "\n",
-    "response = deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "teammates.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "groq = OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "response = groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "teammates.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# So where are we?\n",
-    "\n",
-    "print(teammates)\n",
-    "print(answers)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# It's nice to know how to use \"zip\"\n",
-    "for teammate, answer in zip(teammates, answers):\n",
-    "    print(f\"Teammate: {teammate}\\n\\n{answer}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Let's bring this together - note the use of \"enumerate\"\n",
-    "\n",
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from teammate {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(together)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "formatter = f\"\"\"You are taking the nost interesting ideas fron  {len(teammates)} teammates.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, select the most relevant ideas and make a report, including a title, subtitles to separate sections, and quoting the LLM providing the idea.\n",
-    "From that, you will create a new improved answer.\"\"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(formatter)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "formatter_messages = [{\"role\": \"user\", \"content\": formatter}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=formatter_messages,\n",
-    ")\n",
-    "results = response.choices[0].message.content\n",
-    "display(Markdown(results))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_exercise_BrettSanders_ChainOfThought.ipynb

@@ -1,241 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "raw",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
-   "source": [
-    "# Lab 2 Exercise - Extending the Patterns\n",
-    "\n",
-    "This notebook extends the original lab by adding the Chain of Thought pattern to enhance the evaluation process.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Import required packages\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Load environment variables\n",
-    "load_dotenv(override=True)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Initialize API clients\n",
-    "openai = OpenAI()\n",
-    "claude = Anthropic()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Original question generation\n",
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Get responses from multiple models\n",
-    "competitors = []\n",
-    "answers = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n",
-    "\n",
-    "# OpenAI\n",
-    "response = openai.chat.completions.create(model=\"gpt-4o-mini\", messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "competitors.append(\"gpt-4o-mini\")\n",
-    "answers.append(answer)\n",
-    "display(Markdown(answer))\n",
-    "\n",
-    "# Claude\n",
-    "response = claude.messages.create(model=\"claude-3-7-sonnet-latest\", messages=messages, max_tokens=1000)\n",
-    "answer = response.content[0].text\n",
-    "competitors.append(\"claude-3-7-sonnet-latest\")\n",
-    "answers.append(answer)\n",
-    "display(Markdown(answer))\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# NEW: Chain of Thought Evaluation\n",
-    "# First, let's create a detailed evaluation prompt that encourages step-by-step reasoning\n",
-    "\n",
-    "evaluation_prompt = f\"\"\"You are an expert evaluator of AI responses. Your task is to analyze and rank the following responses to this question:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Please follow these steps in your evaluation:\n",
-    "\n",
-    "1. For each response:\n",
-    "   - Identify the main arguments presented\n",
-    "   - Evaluate the clarity and coherence of the reasoning\n",
-    "   - Assess the depth and breadth of the analysis\n",
-    "   - Note any unique insights or perspectives\n",
-    "\n",
-    "2. Compare the responses:\n",
-    "   - How do they differ in their approach?\n",
-    "   - Which response demonstrates the most sophisticated understanding?\n",
-    "   - Which response provides the most practical and actionable insights?\n",
-    "\n",
-    "3. Provide your final ranking with detailed justification for each position.\n",
-    "\n",
-    "Here are the responses:\n",
-    "\n",
-    "{'\\\\n\\\\n'.join([f'Response {i+1} ({competitors[i]}):\\\\n{answer}' for i, answer in enumerate(answers)])}\n",
-    "\n",
-    "Please provide your evaluation in JSON format with the following structure:\n",
-    "{{\n",
-    "    \"detailed_analysis\": [\n",
-    "        {{\"competitor\": \"name\", \"strengths\": [], \"weaknesses\": [], \"unique_aspects\": []}},\n",
-    "        ...\n",
-    "    ],\n",
-    "    \"comparative_analysis\": \"detailed comparison of responses\",\n",
-    "    \"final_ranking\": [\"ranked competitor numbers\"],\n",
-    "    \"justification\": \"detailed explanation of the ranking\"\n",
-    "}}\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Get the detailed evaluation\n",
-    "evaluation_messages = [{\"role\": \"user\", \"content\": evaluation_prompt}]\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=evaluation_messages,\n",
-    ")\n",
-    "detailed_evaluation = response.choices[0].message.content\n",
-    "print(detailed_evaluation)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Parse and display the results in a more readable format\n",
-    "\n",
-    "# Clean up the JSON string by removing markdown code block markers\n",
-    "json_str = detailed_evaluation.replace(\"```json\", \"\").replace(\"```\", \"\").strip()\n",
-    "\n",
-    "evaluation_dict = json.loads(json_str)\n",
-    "\n",
-    "print(\"Detailed Analysis:\")\n",
-    "for analysis in evaluation_dict[\"detailed_analysis\"]:\n",
-    "    print(f\"\\nCompetitor: {analysis['competitor']}\")\n",
-    "    print(\"Strengths:\")\n",
-    "    for strength in analysis['strengths']:\n",
-    "        print(f\"- {strength}\")\n",
-    "    print(\"\\nWeaknesses:\")\n",
-    "    for weakness in analysis['weaknesses']:\n",
-    "        print(f\"- {weakness}\")\n",
-    "    print(\"\\nUnique Aspects:\")\n",
-    "    for aspect in analysis['unique_aspects']:\n",
-    "        print(f\"- {aspect}\")\n",
-    "\n",
-    "print(\"\\nComparative Analysis:\")\n",
-    "print(evaluation_dict[\"comparative_analysis\"])\n",
-    "\n",
-    "print(\"\\nFinal Ranking:\")\n",
-    "for i, rank in enumerate(evaluation_dict[\"final_ranking\"]):\n",
-    "    print(f\"{i+1}. {competitors[int(rank)-1]}\")\n",
-    "\n",
-    "print(\"\\nJustification:\")\n",
-    "print(evaluation_dict[\"justification\"])\n"
-   ]
-  },
-  {
-   "cell_type": "raw",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
-   "source": [
-    "## Pattern Analysis\n",
-    "\n",
-    "This enhanced version uses several agentic design patterns:\n",
-    "\n",
-    "1. **Multi-agent Collaboration**: Sending the same question to multiple LLMs\n",
-    "2. **Evaluation/Judgment Pattern**: Using one LLM to evaluate responses from others\n",
-    "3. **Parallel Processing**: Running multiple models simultaneously\n",
-    "4. **Chain of Thought**: Added a structured, step-by-step evaluation process that breaks down the analysis into clear stages\n",
-    "\n",
-    "The Chain of Thought pattern is particularly valuable here because it:\n",
-    "- Forces the evaluator to consider multiple aspects of each response\n",
-    "- Provides more detailed and structured feedback\n",
-    "- Makes the evaluation process more transparent and explainable\n",
-    "- Helps identify specific strengths and weaknesses in each response\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_llm_reviewer.ipynb

@@ -1,627 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This notebook extends the original by adding a reviewer pattern to evaluate the impact on model performance.\n",
-    "\n",
-    "In the new workflow, each model's answer is provided to a \"reviewer LLM\" who is prompted to \"Evaluate the response for clarity and strength of argument, and provide constructive suggestions for improving the answer.\" Each model is then given the chance to revise its answer based on the feedback but is also told, \"You are not required to take any of the feedback into account, but you want to win the competition.\"\n",
-    "\n",
-    "<table>\n",
-    "  <caption style=\"font-size: 1.2em; margin-bottom: 10px;\"><strong>Results for Representative Run</strong></caption>\n",
-    "  <thead>\n",
-    "    <tr>\n",
-    "      <th>Model</th>\n",
-    "      <th>Original Rank</th>\n",
-    "      <th>Exclusive Feedback</th>\n",
-    "      <th>With Feedback (all models)</th>\n",
-    "    </tr>\n",
-    "  </thead>\n",
-    "  <tbody>\n",
-    "    <tr>\n",
-    "      <td>gpt-4o-mini</td>\n",
-    "      <td>2</td>\n",
-    "      <td>3</td>\n",
-    "      <td>4</td>\n",
-    "    </tr>\n",
-    "    <tr>\n",
-    "      <td>claude-3-7-sonnet-latest</td>\n",
-    "      <td>6</td>\n",
-    "      <td>1</td>\n",
-    "      <td>1</td>\n",
-    "    </tr>\n",
-    "    <tr>\n",
-    "      <td>gemini-2.0-flash</td>\n",
-    "      <td>1</td>\n",
-    "      <td>1</td>\n",
-    "      <td>2</td>\n",
-    "    </tr>\n",
-    "    <tr>\n",
-    "      <td>deepseek-chat</td>\n",
-    "      <td>3</td>\n",
-    "      <td>2</td>\n",
-    "      <td>3</td>\n",
-    "    </tr>\n",
-    "    <tr>\n",
-    "      <td>llama-3.3-70b-versatile</td>\n",
-    "      <td>4</td>\n",
-    "      <td>3</td>\n",
-    "      <td>5</td>\n",
-    "    </tr>\n",
-    "    <tr>\n",
-    "      <td>llama3.2</td>\n",
-    "      <td>5</td>\n",
-    "      <td>4</td>\n",
-    "      <td>6</td>\n",
-    "    </tr>\n",
-    "  </tbody>\n",
-    "</table>\n",
-    "\n",
-    "The workflow is obviously non-deterministic and the results can vary greatly from run to run, but the introduction of a reviewer appeared to have a generaly positive impact on performance.  The table above shows the results for a representative run. It compares each model's rank versus the other models when it exclusively received feedback.  The table also shows the ranking when ALL models received feedback.  Exclusive use of feedback improved a model's ranking for five out of six models and decreased it for one model.\n",
-    "\n",
-    "Inspired by some other contributions, this worksheet also makes LLM calls asyncrhonously to reduce wait time."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "#!uv add prettytable\n",
-    "\n",
-    "import os\n",
-    "import asyncio\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI, AsyncOpenAI\n",
-    "from anthropic import AsyncAnthropic\n",
-    "from IPython.display import display\n",
-    "from pydantic import BaseModel, Field\n",
-    "from string import Template\n",
-    "from prettytable import PrettyTable\n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class LLMResult(BaseModel):\n",
-    "    model: str\n",
-    "    answer: str\n",
-    "    feedback: str | None =Field(\n",
-    "        default = None, \n",
-    "        description=\"Mutable field.  This will be set by the reviewer.\")\n",
-    "    revised_answer: str | None =Field(\n",
-    "        default = None, \n",
-    "        description=\"Mutable field.  This will be set by the answerer after the reviewer has provided feedback.\")\n",
-    "    original_rank: int | None =Field(\n",
-    "        default = None, \n",
-    "        description=\"Mutable field.  Rank when no feedback is used by any models.\")\n",
-    "    exclusive_feedback: str | None =Field(\n",
-    "        default = None, \n",
-    "        description=\"Mutable field.  Rank when only this model used feedback.\")\n",
-    "    revised_rank: int | None =Field(\n",
-    "        default = None, \n",
-    "        description=\"Mutable field.  Rank when all models used feedback.\")\n",
-    "\n",
-    "results : list[LLMResult] = []\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "competitors = []\n",
-    "answers = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The API we know well\n",
-    "\n",
-    "async def openai_answer(messages: list[dict[str, str]], model_name : str) -> str:\n",
-    "    openai = AsyncOpenAI()\n",
-    "    response = await openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    print(f\"{model_name} answer: {answer[:50]}...\")\n",
-    "    return answer\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Anthropic has a slightly different API, and Max Tokens is required\n",
-    "\n",
-    "async def claude_anthropic_answer(messages: list[dict[str, str]], model_name : str) -> str:\n",
-    "    claude = AsyncAnthropic()\n",
-    "    response = await claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "    answer = response.content[0].text\n",
-    "    print(f\"{model_name} answer: {answer[:50]}...\")\n",
-    "    return answer\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def gemini_google_answer(messages: list[dict[str, str]], model_name : str) -> str:     \n",
-    "    gemini = AsyncOpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "    response = await gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content.strip()\n",
-    "    print(f\"{model_name} answer: {answer[:50]}...\")\n",
-    "    return answer\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def deepseek_answer(messages: list[dict[str, str]], model_name : str) -> str:\n",
-    "    deepseek = AsyncOpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "    response = await deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    print(f\"{model_name} answer: {answer[:50]}...\")\n",
-    "    return answer\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def groq_answer(messages: list[dict[str, str]], model_name : str) -> str:\n",
-    "    groq = AsyncOpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "    response = await groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    print(f\"{model_name} answer: {answer[:50]}...\")\n",
-    "    return answer\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## For the next cell, we will use Ollama\n",
-    "\n",
-    "Ollama runs a local web service that gives an OpenAI compatible endpoint,  \n",
-    "and runs models locally using high performance C++ code.\n",
-    "\n",
-    "If you don't have Ollama, install it here by visiting https://ollama.com then pressing Download and following the instructions.\n",
-    "\n",
-    "After it's installed, you should be able to visit here: http://localhost:11434 and see the message \"Ollama is running\"\n",
-    "\n",
-    "You might need to restart Cursor (and maybe reboot). Then open a Terminal (control+\\`) and run `ollama serve`\n",
-    "\n",
-    "Useful Ollama commands (run these in the terminal, or with an exclamation mark in this notebook):\n",
-    "\n",
-    "`ollama pull <model_name>` downloads a model locally  \n",
-    "`ollama ls` lists all the models you've downloaded  \n",
-    "`ollama rm <model_name>` deletes the specified model from your downloads"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Super important - ignore me at your peril!</h2>\n",
-    "            <span style=\"color:#ff7800;\">The model called <b>llama3.3</b> is FAR too large for home computers - it's not intended for personal computing and will consume all your resources! Stick with the nicely sized <b>llama3.2</b> or <b>llama3.2:1b</b> and if you want larger, try llama3.1 or smaller variants of Qwen, Gemma, Phi or DeepSeek. See the <A href=\"https://ollama.com/models\">the Ollama models page</a> for a full list of models and sizes.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def ollama_answer(messages: list[dict[str, str]], model_name : str) -> str:\n",
-    "    ollama = AsyncOpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "    response = await ollama.chat.completions.create(model=model_name, messages=messages)\n",
-    "    answer = response.choices[0].message.content\n",
-    "    print(f\"{model_name} answer: {answer[:50]}...\")\n",
-    "    return answer\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "answerers  = [openai_answer, claude_anthropic_answer, gemini_google_answer, deepseek_answer, groq_answer, ollama_answer]\n",
-    "models = [\"gpt-4o-mini\", \"claude-3-7-sonnet-latest\", \"gemini-2.0-flash\", \"deepseek-chat\", \"llama-3.3-70b-versatile\", \"llama3.2\"]\n",
-    "\n",
-    "tasks = [ answerer(messages, model) for answerer, model in zip(answerers, models)]\n",
-    "answers : list[str] = await asyncio.gather(*tasks)\n",
-    "results : list[LLMResult] = [LLMResult(model=model, answer=answer) for model, answer in zip(models, answers)]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "answers "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "reviewer = f\"\"\"You are reviewing a submission for a writing competition.  The particpant has been given this question to answer:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your job is to evaluate the response for clarity and strength of argument, and provide constructive suggestions for improving the answer.\n",
-    "Limit your feedback to 200 words.\n",
-    "\n",
-    "Here is the particpant's answer:\n",
-    "{{answer}}\n",
-    "\"\"\"\n",
-    "\n",
-    "async def review_answer(answer : str) -> str:\n",
-    "    openai = AsyncOpenAI()\n",
-    "    reviewer_messages = [{\"role\": \"user\", \"content\": reviewer.format(answer=answer)}]\n",
-    "    reviewer_response = await openai.chat.completions.create(\n",
-    "        model=\"gpt-4o-mini\",\n",
-    "        messages=reviewer_messages,\n",
-    "    )\n",
-    "    feedback = reviewer_response.choices[0].message.content\n",
-    "    print(f\"feedback: {feedback[:50]}...\")\n",
-    "    return feedback"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import asyncio\n",
-    "\n",
-    "tasks = [review_answer(answer) for answer in answers]\n",
-    "feedback = await asyncio.gather(*tasks)\n",
-    "\n",
-    "for result, feedback in zip(results, feedback):\n",
-    "    result.feedback = feedback\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "revision_prompt = f\"\"\"You are revising a submission you wrote for a writing competition based on feedback from a reviewer.\n",
-    "\n",
-    "You are not required to take any of the feedback into account but you want to win the competition.\n",
-    "\n",
-    "The question was: \n",
-    "{question}\n",
-    "\n",
-    "The feedback was:\n",
-    "{{feedback}}\n",
-    "\n",
-    "And your original answer was:\n",
-    "{{answer}}\n",
-    "\n",
-    "Please return your revised answer and nothing else.\n",
-    "\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [{\"role\": \"user\", \"content\": revision_prompt.format(answer=answer, feedback=feedback)} for answer, feedback in zip(answers, feedback)]\n",
-    "tasks = [ answerer(messages, model) for answerer, model in zip(answerers, models)]\n",
-    "revised_answers = await asyncio.gather(*tasks)\n",
-    "\n",
-    "for revised_answer, result in zip(revised_answers, results):\n",
-    "    result.revised_answer = revised_answer\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# need to use Template because we are making a later substitution for \"together\"\n",
-    "judge = Template(f\"\"\"You are judging a competition between {len(results)} competitors.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "$together\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\"\"\")\n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def come_together(results : list[LLMResult], revised_entry : int | None ) -> list[dict[str, str]]:\n",
-    "    # include revised results for \"revised_entry\" or all entries if revise_entrys is None\n",
-    "    together = \"\"\n",
-    "    for index, result in enumerate(results):\n",
-    "        together += f\"# Response from competitor {index}\\n\\n\"\n",
-    "        together += result.answer if (index != revised_entry and revised_entry is not None) else result.revised_answer + \"\\n\\n\"\n",
-    "    return [{\"role\": \"user\", \"content\": judge.substitute(together=together)}]\n",
-    "\n",
-    "\n",
-    "# Judgement time!\n",
-    "async def judgement_time(results : list[LLMResult], revised_entry : int ) -> str:\n",
-    "    judge_messages = come_together(results, revised_entry)\n",
-    "\n",
-    "    openai = AsyncOpenAI()\n",
-    "    response = await openai.chat.completions.create(\n",
-    "        model=\"o3-mini\",\n",
-    "        messages=judge_messages,\n",
-    "    )\n",
-    "    results = response.choices[0].message.content\n",
-    "    results_dict = json.loads(results)\n",
-    "    results = {  int(model) : int(rank) +1 for rank, model in enumerate(results_dict[\"results\"]) }\n",
-    "    return results\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#evaluate the impact of feedback on model performance\n",
-    "\n",
-    "no_feedback = await judgement_time(results, -1)\n",
-    "with_feedback = await judgement_time(results, None)\n",
-    "\n",
-    "tasks = [ judgement_time(results, i) for i in range(len(results))]\n",
-    "model_spefic_feedback = await asyncio.gather(*tasks)\n",
-    "\n",
-    "for index, result in enumerate(results):\n",
-    "    result.original_rank = no_feedback[index]\n",
-    "    result.exclusive_feedback = model_spefic_feedback[index][index]\n",
-    "    result.revised_rank = with_feedback[index]\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "table = PrettyTable()\n",
-    "table.field_names = [\"Model\", \"Original Rank\", \"Exclusive Feedback\", \"With Feedback (all models)\"]\n",
-    "\n",
-    "for result in results:\n",
-    "    table.add_row([result.model, result.original_rank, result.exclusive_feedback, result.revised_rank])\n",
-    "\n",
-    "print(table)\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Which pattern(s) did this use? Try updating this to add another Agentic design pattern.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">These kinds of patterns - to send a task to multiple models, and evaluate results,\n",
-    "            are common where you need to improve the quality of your LLM response. This approach can be universally applied\n",
-    "            to business projects where accuracy is critical.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_moneek.ipynb

@@ -1,173 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "This program uses Evaluator Optimizer pattern to enhance generator's response in creating marketing content for smart keyboard."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Provide a short marketing content for XYZ keyboard. \"\n",
-    "request += \"It should be eagaging and talks about innovative features.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "marketing_statement= response.choices[0].message.content\n",
-    "print(marketing_statement)\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge = f\"\"\"### Instruction ###\n",
-    "You are an expert tech gadget analyst. Your task is to evaluate a marketing material based on several criteria.\n",
-    "Please be brief.\n",
-    "\n",
-    "### Ad to Evaluate ###\n",
-    "{marketing_statement}\n",
-    "\n",
-    "### Evaluation Criteria ###\n",
-    "Evaluate the statement based on how engaging it is.\n",
-    "\n",
-    "### Expected Output Format ###\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": {{\"statement\": \"{marketing_statement}\", \"engagability\": \"Comment on whether the content is engaging\", \"critique\": \"Offer a specific critique and suggest at least one way the recipe could be improved\", \"verdict\": \"This should have a value either 'accepted' or 'rejected' based on whether the statement requires improvement\"}}}}\n",
-    "\"\"\"\n",
-    "\n",
-    "print(judge)\n",
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]\n",
-    "\n",
-    "model_name = \"claude-3-7-sonnet-latest\"\n",
-    "claude = Anthropic()\n",
-    "response = claude.messages.create(model=model_name, messages=judge_messages, max_tokens=1000)\n",
-    "marketing_statement_feedback = response.content[0].text\n",
-    "\n",
-    "print(marketing_statement_feedback)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "results_dict = json.loads(marketing_statement_feedback)\n",
-    "feedback = results_dict[\"results\"]\n",
-    "print(feedback)\n",
-    "print(\"\\n\\n\")\n",
-    "display(Markdown(marketing_statement_feedback))\n",
-    "\n",
-    "print(f\"Marketing statement:\\n{feedback[\"statement\"]}\")\n",
-    "for key in feedback:\n",
-    "    if key == \"verdict\":\n",
-    "        if feedback[key] == \"accepted\":\n",
-    "            print(\"Marketing statement was accepted.\")\n",
-    "            break\n",
-    "        else:\n",
-    "            print(\"Marketing statement was rejected and requires revision. Please iterate over to call Generator and Evaluator for improvement\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_multi-evaluation-criteria.ipynb

@@ -1,506 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Important point - please read</h2>\n",
-    "            <span style=\"color:#ff7800;\">The way I collaborate with you may be different to other courses you've taken. I prefer not to type code while you watch. Rather, I execute Jupyter Labs, like this, and give you an intuition for what's going on. My suggestion is that you carefully execute this yourself, <b>after</b> watching the lecture. Add print statements to understand what's going on, and then come up with your own variations.<br/><br/>If you have time, I'd love it if you submit a PR for changes in the community_contributions folder - instructions in the resources. Also, if you have a Github account, use this to showcase your variations. Not only is this essential practice, but it demonstrates your skills to others, including perhaps future clients or employers...\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "competitors = []\n",
-    "answers = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The API we know well\n",
-    "\n",
-    "model_name = \"gpt-4o-mini\"\n",
-    "\n",
-    "response = openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Anthropic has a slightly different API, and Max Tokens is required\n",
-    "\n",
-    "model_name = \"claude-sonnet-4-latest\"\n",
-    "\n",
-    "claude = Anthropic()\n",
-    "response = claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "answer = response.content[0].text\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gemini = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "response = gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "deepseek = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "model_name = \"deepseek-chat\"\n",
-    "\n",
-    "response = deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "groq = OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "response = groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## For the next cell, we will use Ollama\n",
-    "\n",
-    "Ollama runs a local web service that gives an OpenAI compatible endpoint,  \n",
-    "and runs models locally using high performance C++ code.\n",
-    "\n",
-    "If you don't have Ollama, install it here by visiting https://ollama.com then pressing Download and following the instructions.\n",
-    "\n",
-    "After it's installed, you should be able to visit here: http://localhost:11434 and see the message \"Ollama is running\"\n",
-    "\n",
-    "You might need to restart Cursor (and maybe reboot). Then open a Terminal (control+\\`) and run `ollama serve`\n",
-    "\n",
-    "Useful Ollama commands (run these in the terminal, or with an exclamation mark in this notebook):\n",
-    "\n",
-    "`ollama pull <model_name>` downloads a model locally  \n",
-    "`ollama ls` lists all the models you've downloaded  \n",
-    "`ollama rm <model_name>` deletes the specified model from your downloads"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Super important - ignore me at your peril!</h2>\n",
-    "            <span style=\"color:#ff7800;\">The model called <b>llama3.3</b> is FAR too large for home computers - it's not intended for personal computing and will consume all your resources! Stick with the nicely sized <b>llama3.2</b> or <b>llama3.2:1b</b> and if you want larger, try llama3.1 or smaller variants of Qwen, Gemma, Phi or DeepSeek. See the <A href=\"https://ollama.com/models\">the Ollama models page</a> for a full list of models and sizes.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ollama = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "model_name = \"llama3\"\n",
-    "\n",
-    "response = ollama.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# So where are we?\n",
-    "\n",
-    "print(competitors)\n",
-    "print(answers)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# It's nice to know how to use \"zip\"\n",
-    "for competitor, answer in zip(competitors, answers):\n",
-    "    print(f\"Competitor: {competitor}\\n\\n{answer}\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for competitor, answer in zip(competitors, answers):\n",
-    "    display(Markdown(f\"# Competitor: {competitor}\\n\\n{answer}\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Let's bring this together - note the use of \"enumerate\"\n",
-    "\n",
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from competitor {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(together)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "evaluation_criteria = [\"Effectiveness in resolving the conflict\", \"Clarity of argument\", \"Creativity of solution\", \"Strength of argument\", \"conciseness\", \"applicability to a business context\"]\n",
-    "\n",
-    "judgements = []\n",
-    "\n",
-    "for evaluation_criterion in evaluation_criteria:\n",
-    "\n",
-    "  judgements.append (f\"\"\"You are judging a competition between {len(competitors)} competitors.\n",
-    "  Each model has been given this question:\n",
-    "\n",
-    "  {question}\n",
-    "\n",
-    "  Your job is to evaluate each response for {evaluation_criterion}, and rank them in order of best to worst.\n",
-    "  Respond with JSON, and only JSON, with the following format:\n",
-    "  {{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "\n",
-    "  Here are the responses from each competitor:\n",
-    "\n",
-    "  {together}\n",
-    "\n",
-    "  Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\"\"\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(judgements[1])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "judge_messages = []\n",
-    "for judgement in judgements:\n",
-    "    judge_messages.append ([{\"role\": \"user\", \"content\": judgement}])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "results = []\n",
-    "# Judgement time!\n",
-    "for judge_message in judge_messages:\n",
-    "  openai = OpenAI()\n",
-    "  response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=judge_message,\n",
-    "  )\n",
-    "  results.append (response.choices[0].message.content)\n",
-    "  print(results[0])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for result in results:\n",
-    "  print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# OK let's turn this into results!\n",
-    "\n",
-    "for result, evaluation_criterion in zip(results, evaluation_criteria):\n",
-    "    results_dict = json.loads(result)\n",
-    "    ranks = results_dict[\"results\"]\n",
-    "    display(Markdown(f\"### {evaluation_criterion}\"))\n",
-    "    for index, result in enumerate(ranks):\n",
-    "        competitor = competitors[int(result)-1]    \n",
-    "        display(Markdown(f\"Rank {index+1}: {competitor}\"))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Which pattern(s) did this use? Try updating this to add another Agentic design pattern.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">These kinds of patterns - to send a task to multiple models, and evaluate results,\n",
-    "            are common where you need to improve the quality of your LLM response. This approach can be universally applied\n",
-    "            to business projects where accuracy is critical.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.10"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_perplexity_support.ipynb

@@ -1,497 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Important point - please read</h2>\n",
-    "            <span style=\"color:#ff7800;\">The way I collaborate with you may be different to other courses you've taken. I prefer not to type code while you watch. Rather, I execute Jupyter Labs, like this, and give you an intuition for what's going on. My suggestion is that you carefully execute this yourself, <b>after</b> watching the lecture. Add print statements to understand what's going on, and then come up with your own variations.<br/><br/>If you have time, I'd love it if you submit a PR for changes in the community_contributions folder - instructions in the resources. Also, if you have a Github account, use this to showcase your variations. Not only is this essential practice, but it demonstrates your skills to others, including perhaps future clients or employers...\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "perplexity_api_key = os.getenv('PERPLEXITY_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")\n",
-    "\n",
-    "if perplexity_api_key:\n",
-    "    print(f\"Perplexity API Key exists and begins {perplexity_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Perplexity API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "competitors = []\n",
-    "answers = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The API we know well\n",
-    "\n",
-    "model_name = \"gpt-4o-mini\"\n",
-    "\n",
-    "response = openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Anthropic has a slightly different API, and Max Tokens is required\n",
-    "\n",
-    "model_name = \"claude-3-7-sonnet-latest\"\n",
-    "\n",
-    "claude = Anthropic()\n",
-    "response = claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "answer = response.content[0].text\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gemini = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "response = gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "deepseek = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "model_name = \"deepseek-chat\"\n",
-    "\n",
-    "response = deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "groq = OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "response = groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "perplexity = OpenAI(api_key=perplexity_api_key, base_url=\"https://api.perplexity.ai\")\n",
-    "model_name = \"sonar\"\n",
-    "\n",
-    "response = perplexity.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## For the next cell, we will use Ollama\n",
-    "\n",
-    "Ollama runs a local web service that gives an OpenAI compatible endpoint,  \n",
-    "and runs models locally using high performance C++ code.\n",
-    "\n",
-    "If you don't have Ollama, install it here by visiting https://ollama.com then pressing Download and following the instructions.\n",
-    "\n",
-    "After it's installed, you should be able to visit here: http://localhost:11434 and see the message \"Ollama is running\"\n",
-    "\n",
-    "You might need to restart Cursor (and maybe reboot). Then open a Terminal (control+\\`) and run `ollama serve`\n",
-    "\n",
-    "Useful Ollama commands (run these in the terminal, or with an exclamation mark in this notebook):\n",
-    "\n",
-    "`ollama pull <model_name>` downloads a model locally  \n",
-    "`ollama ls` lists all the models you've downloaded  \n",
-    "`ollama rm <model_name>` deletes the specified model from your downloads"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Super important - ignore me at your peril!</h2>\n",
-    "            <span style=\"color:#ff7800;\">The model called <b>llama3.3</b> is FAR too large for home computers - it's not intended for personal computing and will consume all your resources! Stick with the nicely sized <b>llama3.2</b> or <b>llama3.2:1b</b> and if you want larger, try llama3.1 or smaller variants of Qwen, Gemma, Phi or DeepSeek. See the <A href=\"https://ollama.com/models\">the Ollama models page</a> for a full list of models and sizes.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ollama = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "model_name = \"llama3.2\"\n",
-    "\n",
-    "response = ollama.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# So where are we?\n",
-    "\n",
-    "print(competitors)\n",
-    "print(answers)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# It's nice to know how to use \"zip\"\n",
-    "for competitor, answer in zip(competitors, answers):\n",
-    "    print(f\"Competitor: {competitor}\\n\\n{answer}\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Let's bring this together - note the use of \"enumerate\"\n",
-    "\n",
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from competitor {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(together)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge = f\"\"\"You are judging a competition between {len(competitors)} competitors.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "{together}\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(judge)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Judgement time!\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=judge_messages,\n",
-    ")\n",
-    "results = response.choices[0].message.content\n",
-    "print(results)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# OK let's turn this into results!\n",
-    "\n",
-    "results_dict = json.loads(results)\n",
-    "ranks = results_dict[\"results\"]\n",
-    "for index, result in enumerate(ranks):\n",
-    "    competitor = competitors[int(result)-1]\n",
-    "    print(f\"Rank {index+1}: {competitor}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Which pattern(s) did this use? Try updating this to add another Agentic design pattern.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">These kinds of patterns - to send a task to multiple models, and evaluate results,\n",
-    "            are common where you need to improve the quality of your LLM response. This approach can be universally applied\n",
-    "            to business projects where accuracy is critical.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_reflection_pattern.ipynb

@@ -1,311 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Week 1, Day 3\n",
-    "\n",
-    "Today we will work with lots of models! This is a way to get comfortable with APIs."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Important point - please read</h2>\n",
-    "            <span style=\"color:#ff7800;\">The way I collaborate with you may be different to other courses you've taken. I prefer not to type code while you watch. Rather, I execute Jupyter Labs, like this, and give you an intuition for what's going on. My suggestion is that you carefully execute this yourself, <b>after</b> watching the lecture. Add print statements to understand what's going on, and then come up with your own variations.<br/><br/>If you have time, I'd love it if you submit a PR for changes in the community_contributions folder - instructions in the resources. Also, if you have a Github account, use this to showcase your variations. Not only is this essential practice, but it demonstrates your skills to others, including perhaps future clients or employers...\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This version adds Reflection pattern where we ask each model to critique and improve its own answer."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Please come up with a challenging, nuanced question that I can ask a number of LLMs to evaluate their intelligence. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "competitors = []\n",
-    "answers = []\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gemini = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "response = gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "deepseek = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "model_name = \"deepseek-chat\"\n",
-    "\n",
-    "response = deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "groq = OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "response = groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Super important - ignore me at your peril!</h2>\n",
-    "            <span style=\"color:#ff7800;\">The model called <b>llama3.3</b> is FAR too large for home computers - it's not intended for personal computing and will consume all your resources! Stick with the nicely sized <b>llama3.2</b> or <b>llama3.2:1b</b> and if you want larger, try llama3.1 or smaller variants of Qwen, Gemma, Phi or DeepSeek. See the <A href=\"https://ollama.com/models\">the Ollama models page</a> for a full list of models and sizes.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Let's bring this together - note the use of \"enumerate\"\n",
-    "\n",
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from competitor {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge = f\"\"\"You are judging a competition between {len(competitors)} competitors.\n",
-    "Each model has been given this question:\n",
-    "\n",
-    "{question}\n",
-    "\n",
-    "Your job is to evaluate each response for clarity and strength of argument, and rank them in order of best to worst.\n",
-    "Respond with JSON, and only JSON, with the following format:\n",
-    "{{\"results\": [\"best competitor number\", \"second best competitor number\", \"third best competitor number\", ...]}}\n",
-    "\n",
-    "Here are the responses from each competitor:\n",
-    "\n",
-    "{together}\n",
-    "\n",
-    "Now respond with the JSON with the ranked order of the competitors, nothing else. Do not include markdown formatting or code blocks.\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Which pattern(s) did this use? Try updating this to add another Agentic design pattern.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. Ensemble (Model Competition) Pattern\n",
-    "Description: The same prompt/question is sent to multiple different LLMs (OpenAI, Anthropic, Ollama, etc.).\n",
-    "Purpose: To compare the quality, style, and content of responses from different models.\n",
-    "Where in notebook:\n",
-    "The code sends the same question to several models and collects their answers in the competitors and answers lists.\n",
-    "\n",
-    "2. Judging/Evaluator Pattern\n",
-    "Description: After collecting responses from all models, another LLM is used as a “judge” to evaluate and rank the responses.\n",
-    "Purpose: To automate the assessment of which model gave the best answer, based on clarity and strength of argument.\n",
-    "Where in notebook:\n",
-    "The judge prompt is constructed, and an LLM is asked to rank the responses in JSON format.\n",
-    "\n",
-    "3. Self-Improvement/Meta-Reasoning Pattern\n",
-    "Description: The system not only generates answers but also reflects on and evaluates its own outputs (or those of its peers).\n",
-    "Purpose: To iteratively improve or select the best output, often used in advanced agentic systems.\n",
-    "Where in notebook:\n",
-    "The “judge” LLM is an example of meta-reasoning, as it reasons about the quality of other LLMs’ outputs.\n",
-    "\n",
-    "4. Chain-of-Thought/Decomposition Pattern (to a lesser extent)\n",
-    "Description: Breaking down a complex task into subtasks (e.g., generate question → get answers → evaluate answers).\n",
-    "Purpose: To improve reliability and interpretability by structuring the workflow.\n",
-    "Where in notebook:\n",
-    "The workflow is decomposed into:\n",
-    "Generating a challenging question\n",
-    "Getting answers from multiple models\n",
-    "Judging the answers\n",
-    "\n",
-    "In short:\n",
-    "This notebook uses the Ensemble/Competition, Judging/Evaluator, and Meta-Reasoning agentic patterns, and also demonstrates a simple form of Decomposition by structuring the workflow into clear stages.\n",
-    "If you want to add more agentic patterns, you could try things like:\n",
-    "Reflexion (let models critique and revise their own answers)\n",
-    "Tool Use (let models call external tools or APIs)\n",
-    "Planning (let a model plan the steps before answering)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">These kinds of patterns - to send a task to multiple models, and evaluate results,\n",
-    "            are common where you need to improve the quality of your LLM response. This approach can be universally applied\n",
-    "            to business projects where accuracy is critical.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/2_lab2_reflection_pattern2.ipynb

@@ -1,999 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Welcome to the Second Lab - Exercise: Advanced Agentic Design Patterns\n",
-    "\n",
-    "This notebook extends the previous lab by adding the **Reflection Pattern** to improve response quality.\n",
-    "\n",
-    "### Patterns used in the original lab:\n",
-    "1. **Multi-Model Comparison Pattern** - Comparing multiple models\n",
-    "2. **Judge/Evaluator Pattern** - Evaluation by a judge model\n",
-    "\n",
-    "### New pattern added:\n",
-    "3. **Reflection Pattern** - Self-improvement of responses"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">New Pattern: Reflection</h2>\n",
-    "            <span style=\"color:#ff7800;\">The Reflection Pattern allows a model to critique and improve its own response. This is particularly useful for complex tasks requiring nuance and precision.</span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "OpenAI API Key exists and begins sk-1kYcH\n",
-      "Anthropic API Key exists and begins sk-ant-\n",
-      "Google API Key not set (and this is optional)\n",
-      "DeepSeek API Key not set (and this is optional)\n",
-      "Groq API Key not set (and this is optional)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Step 1: Generate Initial Question (Multi-Model Pattern)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Generated Question:\n",
-      "A wealthy philanthropist has developed a new drug that can cure a rare but fatal disease affecting a small population. However, the drug is expensive to produce and the philanthropist only has enough resources to manufacture a limited supply. At the same time, a competing pharmaceutical company has discovered the cure but plans to charge exorbitant prices, making it inaccessible for most patients. \n",
-      "\n",
-      "The philanthropist learns that if they invest their resources into manufacturing the drug, it can be distributed at a lower cost but only to a select few who are already on a waiting list, prioritizing those who are most likely to recover. Alternatively, the philanthropist could sell the formula to the competing company for a substantial profit, ensuring that a broader population can access the cure, albeit at high prices that many cannot afford.\n",
-      "\n",
-      "The dilemma: Should the philanthropist prioritize the immediate health of a few individuals by providing the cure at a lower cost, or should they consider the greater good by allowing the competitive company to distribute the cure to a wider audience at a higher price?\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Generate a challenging question for the models to answer\n",
-    "\n",
-    "request = \"Please come up with a challenging ethical dilemma that requires careful moral reasoning and consideration of multiple perspectives. \"\n",
-    "request += \"The dilemma should involve conflicting values and have no clear-cut answer. Answer only with the dilemma, no explanation.\"\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "\n",
-    "question = response.choices[0].message.content\n",
-    "print(\"Generated Question:\")\n",
-    "print(question)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Step 2: Get Initial Responses from Multiple Models"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_initial_response(client, model_name, question, is_anthropic=False):\n",
-    "    \"\"\"Get initial response from a model\"\"\"\n",
-    "    messages = [{\"role\": \"user\", \"content\": question}]\n",
-    "    \n",
-    "    if is_anthropic:\n",
-    "        response = client.messages.create(\n",
-    "            model=model_name, \n",
-    "            messages=messages, \n",
-    "            max_tokens=1000\n",
-    "        )\n",
-    "        return response.content[0].text\n",
-    "    else:\n",
-    "        response = client.chat.completions.create(\n",
-    "            model=model_name, \n",
-    "            messages=messages\n",
-    "        )\n",
-    "        return response.choices[0].message.content"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Configure clients\n",
-    "openai_client = OpenAI()\n",
-    "claude_client = Anthropic() if anthropic_api_key else None\n",
-    "gemini_client = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\") if google_api_key else None\n",
-    "deepseek_client = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\") if deepseek_api_key else None\n",
-    "groq_client = OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\") if groq_api_key else None"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "=== INITIAL RESPONSES ===\n",
-      "\n",
-      "**gpt-4o-mini:**\n"
-     ]
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "This ethical dilemma presents a challenging decision for the philanthropist, who must weigh the immediate health needs of a few individuals against the broader societal implications of drug distribution and access.\n",
-       "\n",
-       "### Option 1: Prioritizing Immediate Health\n",
-       "\n",
-       "If the philanthropist chooses to manufacture the drug and distribute it at a lower cost to those on the waiting list, they are directly addressing the pressing health needs of a select few individuals who are already vulnerable. This action prioritizes compassion and the moral obligation to help those who are suffering. By ensuring that the drug is available to those with the highest likelihood of recovery, the philanthropist demonstrates an ethical commitment to saving lives and reducing suffering in the short term.\n",
-       "\n",
-       "However, this approach has limitations. By distributing the drug to only a small number of patients, the philanthropist may overlook other individuals who could benefit from the cure. Additionally, this solution does not address the systemic issue of access to healthcare and affordable medications for the larger population suffering from the disease.\n",
-       "\n",
-       "### Option 2: Considering the Greater Good\n",
-       "\n",
-       "On the other hand, selling the formula to the competing pharmaceutical company for a substantial profit could lead to a wider distribution of the drug, although at a higher price point that may make it inaccessible to many patients. In this scenario, the philanthropist uses their financial gain to potentially invest in other healthcare initiatives or research, thus contributing to the long-term improvement of medical care or addressing related health issues.\n",
-       "\n",
-       "This choice raises ethical concerns regarding the prioritization of profit over compassion and the risk that many individuals will remain unable to afford the life-saving treatment. It also creates a tension between the ideals of philanthropy and the realities of the pharmaceutical industry, which often operates on profit motives rather than altruistic goals.\n",
-       "\n",
-       "### Balancing the Two Options\n",
-       "\n",
-       "A possible compromise could be for the philanthropist to negotiate a deal with the pharmaceutical company that ensures a tiered pricing structure, where those who can afford the drug pay more while discounts or alternative funding are provided for low-income patients. This could help bridge the gap between immediate health needs and wider access.\n",
-       "\n",
-       "Ultimately, the decision comes down to the philanthropist's values and vision for their impact on public health. Do they prioritize saving a few lives in the short term or seek a more sustainable, albeit imperfect, solution that aims at broader access over a longer timeframe? The complexity of the dilemma emphasizes the need for thoughtful deliberation on how best to serve both individual health needs and the greater public good."
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "==================================================\n",
-      "\n",
-      "**claude-3-7-sonnet-latest:**\n"
-     ]
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "# The Philanthropist's Dilemma\n",
-       "\n",
-       "This is a complex ethical dilemma that involves several important considerations:\n",
-       "\n",
-       "## Key Ethical Tensions\n",
-       "\n",
-       "- **Limited access at affordable prices** vs. **wider access at unaffordable prices**\n",
-       "- **Immediate relief for a few** vs. **potential long-term access for many**\n",
-       "- **Direct control over distribution** vs. **surrendering control to profit-motivated actors**\n",
-       "\n",
-       "## Considerations for Manufacturing the Drug Directly\n",
-       "\n",
-       "**Benefits:**\n",
-       "- Ensures the most vulnerable patients receive treatment based on medical need rather than ability to pay\n",
-       "- Maintains the philanthropist's ethical vision and control over distribution\n",
-       "- Sets a precedent for compassionate drug pricing\n",
-       "\n",
-       "**Drawbacks:**\n",
-       "- Limited overall reach due to resource constraints\n",
-       "- Potentially slower scaling of production\n",
-       "- Many patients may receive no treatment at all\n",
-       "\n",
-       "## Considerations for Selling to the Pharmaceutical Company\n",
-       "\n",
-       "**Benefits:**\n",
-       "- Potentially greater production capacity and distribution reach\n",
-       "- The philanthropist could use profits to subsidize costs for those who cannot afford it\n",
-       "- Might accelerate further research and development\n",
-       "\n",
-       "**Drawbacks:**\n",
-       "- Many patients would be excluded based on financial means\n",
-       "- Surrenders control over an essential medicine to profit-motivated decision-making\n",
-       "- Could establish a problematic precedent for pricing life-saving medications\n",
-       "\n",
-       "This dilemma reflects broader tensions in healthcare ethics between utilitarian approaches (helping the most people) and justice-based approaches (ensuring fair access based on need rather than wealth).\n",
-       "\n",
-       "There might be creative third options worth exploring, such as licensing agreements with price caps, creating a non-profit manufacturing entity, or partnering with governments to ensure broader affordable access."
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "==================================================\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Collect initial responses\n",
-    "initial_responses = {}\n",
-    "competitors = []\n",
-    "\n",
-    "models = [\n",
-    "    (\"gpt-4o-mini\", openai_client, False),\n",
-    "    (\"claude-3-7-sonnet-latest\", claude_client, True),\n",
-    "    (\"gemini-2.0-flash\", gemini_client, False),\n",
-    "    (\"deepseek-chat\", deepseek_client, False),\n",
-    "    (\"llama-3.3-70b-versatile\", groq_client, False),\n",
-    "]\n",
-    "\n",
-    "print(\"\\n=== INITIAL RESPONSES ===\\n\")\n",
-    "\n",
-    "for model_name, client, is_anthropic in models:\n",
-    "    if client:\n",
-    "        try:\n",
-    "            response = get_initial_response(client, model_name, question, is_anthropic)\n",
-    "            initial_responses[model_name] = response\n",
-    "            competitors.append(model_name)\n",
-    "            \n",
-    "            print(f\"**{model_name}:**\")\n",
-    "            display(Markdown(response))\n",
-    "            print(\"\\n\" + \"=\"*50 + \"\\n\")\n",
-    "        except Exception as e:\n",
-    "            print(f\"Error with {model_name}: {e}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Step 3: NEW PATTERN - Reflection Pattern"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def apply_reflection_pattern(client, model_name, original_question, initial_response, is_anthropic=False):\n",
-    "    \"\"\"Apply the Reflection Pattern to improve a response\"\"\"\n",
-    "    \n",
-    "    reflection_prompt = f\"\"\"\n",
-    "You previously received this question:\n",
-    "{original_question}\n",
-    "\n",
-    "Here was your initial response:\n",
-    "{initial_response}\n",
-    "\n",
-    "Now, as a critical expert, analyze your own response:\n",
-    "1. What are the strengths of this response?\n",
-    "2. What important perspectives are missing?\n",
-    "3. Are there any biases or blind spots in the analysis?\n",
-    "4. How could you improve this response?\n",
-    "\n",
-    "After this self-critique, provide an IMPROVED response that takes into account your observations.\n",
-    "\n",
-    "Response format:\n",
-    "## Self-Critique\n",
-    "[Your critical analysis of the initial response]\n",
-    "\n",
-    "## Improved Response\n",
-    "[Your revised and improved response]\n",
-    "\"\"\"\n",
-    "    \n",
-    "    messages = [{\"role\": \"user\", \"content\": reflection_prompt}]\n",
-    "    \n",
-    "    if is_anthropic:\n",
-    "        response = client.messages.create(\n",
-    "            model=model_name, \n",
-    "            messages=messages, \n",
-    "            max_tokens=1500\n",
-    "        )\n",
-    "        return response.content[0].text\n",
-    "    else:\n",
-    "        response = client.chat.completions.create(\n",
-    "            model=model_name, \n",
-    "            messages=messages\n",
-    "        )\n",
-    "        return response.choices[0].message.content"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "=== RESPONSES AFTER REFLECTION ===\n",
-      "\n",
-      "**gpt-4o-mini - After Reflection:**\n"
-     ]
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "## Self-Critique\n",
-       "1. **Strengths of this Response:**\n",
-       "   - The response thoroughly outlines both options available to the philanthropist, providing a balanced view of the ethical implications of each choice.\n",
-       "   - It acknowledges the immediate health needs of affected individuals as well as the broader societal implications of drug distribution.\n",
-       "   - It introduces a potential compromise solution, which adds depth to the analysis and suggests a more nuanced approach to the dilemma.\n",
-       "\n",
-       "2. **Important Perspectives Missing:**\n",
-       "   - The response does not adequately consider the potential operational and logistical challenges in manufacturing and distributing the drug at a lower cost, including regulatory hurdles and the scalability of production.\n",
-       "   - There is limited discussion on the emotional impact of the decision on the patients and their families, which could influence the philanthropist's considerations.\n",
-       "   - The perspective of other stakeholders, such as healthcare providers and ethicists, is not introduced.\n",
-       "\n",
-       "3. **Biases or Blind Spots in the Analysis:**\n",
-       "   - The response may lean towards prioritizing compassion over economic pragmatism, possibly downplaying the complexities involved in pharmaceutical economics and the realities that arise from selling to a corporation with profit motives.\n",
-       "   - It assumes a binary choice rather than considering other stakeholder impacts and longer-term systemic solutions.\n",
-       "\n",
-       "4. **How to Improve This Response:**\n",
-       "   - Include more contextual factors that might affect the decision, such as regulatory considerations, patient demographics, and healthcare infrastructure.\n",
-       "   - Expand on the emotional and psychological aspects of the decision-making process for both the philanthropist and the patients involved.\n",
-       "   - Address the potential for future societal implications if the competing company monopolizes the market after acquiring the formula.\n",
-       "\n",
-       "## Improved Response\n",
-       "This ethical dilemma presents the philanthropist with a complex decision regarding how best to utilize limited resources to maximize the benefit for individuals suffering from a rare but fatal disease. The two primary options – providing a low-cost supply to a select few or selling the formula for broader but costly distribution – both highlight significant ethical considerations.\n",
-       "\n",
-       "### Option 1: Prioritizing Immediate Health\n",
-       "By choosing to manufacture the drug at a lower cost for those on the waiting list, the philanthropist opts to directly address the urgent health needs of vulnerable individuals. This approach reflects a moral obligation to alleviate suffering and save lives in the short term. Prioritizing individuals with the highest likelihood of recovery can lead to tangible, immediate outcomes for those patients and their families.\n",
-       "\n",
-       "However, there are operational challenges associated with this choice. Limited production capabilities may mean that only a fraction of those in need can actually receive the drug, leaving many others without hope. Additionally, this decision doesn't resolve the systemic issues within healthcare, such as overall treatment accessibility and drug pricing, which may persist if not tackled holistically.\n",
-       "\n",
-       "### Option 2: Considering the Greater Good\n",
-       "Alternatively, selling the formula to the competing pharmaceutical company could result in wider distribution of the drug and potentially more patients benefiting from the cure, albeit at higher prices. This choice could finance further philanthropic efforts or investments in healthcare that might ultimately lead to broader long-term improvements in public health.\n",
-       "\n",
-       "However, ethical concerns arise when considering the high pricing of the cure. The decision may disproportionately disadvantage lower-income patients, perpetuating healthcare inequities. Furthermore, there is the risk that this choice could enable the pharmaceutical company to monopolize treatment options, further exploitation in the industry.\n",
-       "\n",
-       "### A Balanced Approach\n",
-       "To navigate this complex dilemma more thoughtfully, the philanthropist could explore a compromise by negotiating with the pharmaceutical company to establish a tiered pricing structure. This could create a system where the drug is offered at a reduced price for low-income patients, while ensuring sustainability for the company through higher prices for those who can afford them. Additionally, the philanthropist might advocate for a commitment from the company to invest in generics or alternative distribution methods to enhance accessibility.\n",
-       "\n",
-       "### Conclusion\n",
-       "The choice ultimately hinges on the philanthropist's values and vision for their impact on public health. This decision requires careful consideration of immediate health benefits, long-term accessibility, and the emotional ramifications for affected individuals. By weighing the implications of each option and considering collaborative solutions, the philanthropist can work towards an outcome that promotes both individual care and broader societal well-being."
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "==================================================\n",
-      "\n",
-      "**claude-3-7-sonnet-latest - After Reflection:**\n"
-     ]
-    },
-    {
-     "data": {
-      "text/markdown": [
-       "## Self-Critique\n",
-       "\n",
-       "### Strengths of the initial response:\n",
-       "- Well-structured analysis that clearly outlines the ethical tensions\n",
-       "- Presents balanced considerations for both options\n",
-       "- Mentions potential third options beyond the binary choice\n",
-       "- Identifies the broader ethical frameworks at play (utilitarian vs. justice-based approaches)\n",
-       "\n",
-       "### Missing perspectives:\n",
-       "1. **Stakeholder analysis**: The response lacks a thorough examination of all affected parties (patients, healthcare systems, future patients, etc.)\n",
-       "2. **Timeline considerations**: No discussion of short-term vs. long-term consequences beyond immediate access\n",
-       "3. **Public health impact**: Limited analysis of how each option affects overall public health outcomes\n",
-       "4. **Precedent-setting effects**: Inadequate exploration of how this decision might influence future pharmaceutical development and pricing\n",
-       "5. **Regulatory context**: No mention of potential government intervention, price controls, or other regulatory factors\n",
-       "6. **Global justice perspective**: No consideration of how this decision affects different regions/countries\n",
-       "\n",
-       "### Biases and blind spots:\n",
-       "1. **False dichotomy**: Despite mentioning \"third options,\" the analysis primarily treats this as a binary choice\n",
-       "2. **Western/developed-world bias**: Assumes a market-based healthcare system without considering different global contexts\n",
-       "3. **Individual-focused ethics**: Overemphasizes individual choice rather than institutional or systemic responsibilities\n",
-       "4. **Overly abstract**: The analysis lacks concrete examples or case studies that might inform the decision\n",
-       "5. **Neglect of power dynamics**: Doesn't address the power imbalance between corporations, individuals, and patients\n",
-       "\n",
-       "### Improvement opportunities:\n",
-       "1. Provide a more nuanced spectrum of options beyond the binary choice\n",
-       "2. Include more stakeholder perspectives, particularly patient voices\n",
-       "3. Consider real-world case studies of similar pharmaceutical dilemmas\n",
-       "4. Address systemic issues in drug development and pharmaceutical pricing\n",
-       "5. Explore collaborative approaches that leverage multiple institutions\n",
-       "6. Discuss intellectual property rights and their ethical implications\n",
-       "\n",
-       "## Improved Response\n",
-       "\n",
-       "# The Philanthropist's Dilemma: A Multidimensional Ethical Analysis\n",
-       "\n",
-       "This scenario presents not simply a binary choice but a complex ethical landscape involving multiple stakeholders, systemic factors, and competing values.\n",
-       "\n",
-       "## Stakeholder Analysis\n",
-       "\n",
-       "**Patients and families:**\n",
-       "- Those currently suffering need immediate access regardless of mechanism\n",
-       "- Future patients have interests in sustainable development of treatments\n",
-       "- Economic diversity among patients means affordability affects different groups unequally\n",
-       "\n",
-       "**Healthcare systems:**\n",
-       "- Must allocate limited resources across competing priorities\n",
-       "- High-priced drugs can strain budgets and force difficult coverage decisions\n",
-       "- Precedents set now affect future negotiations with pharmaceutical companies\n",
-       "\n",
-       "**Research community:**\n",
-       "- Incentives for developing treatments for rare diseases are influenced by such cases\n",
-       "- How intellectual property is handled affects future research priorities\n",
-       "\n",
-       "## Ethical Frameworks Worth Considering\n",
-       "\n",
-       "1. **Distributive justice**: Who should receive limited resources? What constitutes fair allocation?\n",
-       "2. **Rights-based approach**: Do patients have a right to life-saving medication regardless of cost?\n",
-       "3. **Consequentialist assessment**: Which option produces the best outcomes for the most people over time?\n",
-       "4. **Virtue ethics**: What would a virtuous philanthropist do in this situation?\n",
-       "5. **Global justice**: How does this decision affect healthcare equity across different regions?\n",
-       "\n",
-       "## Spectrum of Options\n",
-       "\n",
-       "Rather than two mutually exclusive choices, consider a spectrum of possibilities:\n",
-       "\n",
-       "1. **Direct manufacturing with tiered pricing**: Manufacture independently but implement income-based pricing to maximize access while maintaining sustainability\n",
-       "\n",
-       "2. **Conditional licensing**: License the formula with contractual price controls, distribution requirements, and accessibility guarantees\n",
-       "\n",
-       "3. **Public-private partnership**: Collaborate with governments, NGOs, and selected pharmaceutical partners to ensure broad, affordable access\n",
-       "\n",
-       "4. **Open-source approach**: Release the formula publicly with certain patent protections waived, while establishing a foundation to support manufacturing\n",
-       "\n",
-       "5. **Hybrid distribution model**: Manufacture for highest-need populations while licensing to reach others, using licensing revenues to subsidize direct manufacturing\n",
-       "\n",
-       "## Case Study Context\n",
-       "\n",
-       "Similar dilemmas have occurred with treatments for HIV/AIDS, hepatitis C, and rare genetic disorders. The outcomes suggest:\n",
-       "\n",
-       "- Maintaining some control over intellectual property while ensuring broad access often yields better public health outcomes than either extreme option\n",
-       "- Patient advocacy can significantly influence corporate behavior and pricing\n",
-       "- International differences in pricing and patent enforcement create complex dynamics\n",
-       "- Government intervention through negotiation, compulsory licensing, or regulation often becomes necessary\n",
-       "\n",
-       "## Systems-Level Considerations\n",
-       "\n",
-       "This dilemma exists within broader systemic issues:\n",
-       "\n",
-       "- The current pharmaceutical development model creates inherent tensions between innovation, access, and affordability\n",
-       "- Rare disease treatments highlight market failures in drug development\n",
-       "- Healthcare financing systems vary globally, affecting how we should evaluate \"accessibility\"\n",
-       "- Intellectual property regimes may require reform to better balance innovation incentives with public health needs\n",
-       "\n",
-       "## Recommended Approach\n",
-       "\n",
-       "The philanthropist should pursue a hybrid strategy that:\n",
-       "\n",
-       "1. Maintains sufficient control to ensure the most vulnerable patients receive treatment regardless of ability to pay\n",
-       "\n",
-       "2. Leverages partnerships with multiple entities (pharmaceutical companies, governments, NGOs) to maximize production scale and geographic reach\n",
-       "\n",
-       "3. Implements contractual safeguards on pricing, with particular attention to low and middle-income regions\n",
-       "\n",
-       "4. Establishes a patient assistance foundation using a portion of any licensing revenues\n",
-       "\n",
-       "5. Advocates for systemic reforms that would prevent such dilemmas in the future\n",
-       "\n",
-       "This approach recognizes that the philanthropist's responsibility extends beyond the immediate distribution decision to include consideration of precedent-setting effects, stakeholder equity, and systemic change—balancing immediate needs with long-term public health impact."
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "==================================================\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Apply Reflection Pattern\n",
-    "reflected_responses = {}\n",
-    "\n",
-    "print(\"\\n=== RESPONSES AFTER REFLECTION ===\\n\")\n",
-    "\n",
-    "for model_name, client, is_anthropic in models:\n",
-    "    if client and model_name in initial_responses:\n",
-    "        try:\n",
-    "            reflected = apply_reflection_pattern(\n",
-    "                client, model_name, question, \n",
-    "                initial_responses[model_name], is_anthropic\n",
-    "            )\n",
-    "            reflected_responses[model_name] = reflected\n",
-    "            \n",
-    "            print(f\"**{model_name} - After Reflection:**\")\n",
-    "            display(Markdown(reflected))\n",
-    "            print(\"\\n\" + \"=\"*50 + \"\\n\")\n",
-    "        except Exception as e:\n",
-    "            print(f\"Error with reflection for {model_name}: {e}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Step 4: Comparative Evaluation (Extended Judge Pattern)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def create_comparative_evaluation(question, initial_responses, reflected_responses):\n",
-    "    \"\"\"Create a comparative evaluation of responses before/after reflection\"\"\"\n",
-    "    \n",
-    "    evaluation_prompt = f\"\"\"\n",
-    "You are evaluating the effectiveness of the \"Reflection Pattern\" on the following question:\n",
-    "{question}\n",
-    "\n",
-    "For each model, you have:\n",
-    "1. An initial response\n",
-    "2. A response after self-reflection\n",
-    "\n",
-    "Analyze and compare:\n",
-    "- Depth of analysis\n",
-    "- Consideration of multiple perspectives\n",
-    "- Nuance and sophistication of reasoning\n",
-    "- Improvement brought by reflection\n",
-    "\n",
-    "MODELS TO EVALUATE:\n",
-    "\"\"\"\n",
-    "    \n",
-    "    for model_name in initial_responses:\n",
-    "        if model_name in reflected_responses:\n",
-    "            evaluation_prompt += f\"\"\"\n",
-    "## {model_name}\n",
-    "\n",
-    "### Initial response:\n",
-    "{initial_responses[model_name][:500]}...\n",
-    "\n",
-    "### Response after reflection:\n",
-    "{reflected_responses[model_name][:800]}...\n",
-    "\n",
-    "\"\"\"\n",
-    "    \n",
-    "    evaluation_prompt += \"\"\"\n",
-    "Respond with structured JSON:\n",
-    "{\n",
-    "    \"general_analysis\": \"Your analysis of the Reflection Pattern's effectiveness\",\n",
-    "    \"initial_ranking\": [\"best initially ranked model\", \"second\", \"third\"],\n",
-    "    \"post_reflection_ranking\": [\"best ranked model after reflection\", \"second\", \"third\"],\n",
-    "    \"most_improved\": \"Which model improved the most\",\n",
-    "    \"insights\": \"Insights about the usefulness of the Reflection Pattern\"\n",
-    "}\n",
-    "\"\"\"\n",
-    "    \n",
-    "    return evaluation_prompt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "=== FINAL EVALUATION ===\n",
-      "\n",
-      "```json\n",
-      "{\n",
-      "    \"general_analysis\": \"The Reflection Pattern effectively enhanced the depth of analysis and consideration of multiple perspectives in both models. However, the results differ in terms of sophistication and detail. The GPT-4 model provided initial observations that were relatively shallow but improved by incorporating logistical challenges and suggesting compromises during reflection. In contrast, Claude-3's initial response was more structured and sophisticated, covering a broader range of ethical frameworks, but still showed room for improvement regarding stakeholder analysis and long-term impacts.\",\n",
-      "    \"initial_ranking\": [\"claude-3-7-sonnet-latest\", \"gpt-4o-mini\"],\n",
-      "    \"post_reflection_ranking\": [\"claude-3-7-sonnet-latest\", \"gpt-4o-mini\"],\n",
-      "    \"most_improved\": \"gpt-4o-mini\",\n",
-      "    \"insights\": \"The Reflection Pattern revealed significant gaps in both models' initial analyses, encouraging deeper engagement with ethical implications and stakeholder considerations. It highlighted the importance of reflecting on logistical realities and the real-world impacts of decisions, marking it as a worthwhile practice for ethical dilemmas.\"\n",
-      "}\n",
-      "```\n",
-      "Could not parse JSON, raw output shown above\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Final evaluation\n",
-    "if initial_responses and reflected_responses:\n",
-    "    evaluation_prompt = create_comparative_evaluation(question, initial_responses, reflected_responses)\n",
-    "    \n",
-    "    judge_messages = [{\"role\": \"user\", \"content\": evaluation_prompt}]\n",
-    "    \n",
-    "    try:\n",
-    "        judge_response = openai_client.chat.completions.create(\n",
-    "            model=\"gpt-4o-mini\",\n",
-    "            messages=judge_messages,\n",
-    "        )\n",
-    "        \n",
-    "        evaluation_result = judge_response.choices[0].message.content\n",
-    "        print(\"\\n=== FINAL EVALUATION ===\\n\")\n",
-    "        print(evaluation_result)\n",
-    "        \n",
-    "        # Try to parse JSON for structured display\n",
-    "        try:\n",
-    "            eval_json = json.loads(evaluation_result)\n",
-    "            print(\"\\n=== STRUCTURED RESULTS ===\\n\")\n",
-    "            for key, value in eval_json.items():\n",
-    "                print(f\"{key.replace('_', ' ').title()}: {value}\")\n",
-    "        except:\n",
-    "            print(\"Could not parse JSON, raw output shown above\")\n",
-    "            \n",
-    "    except Exception as e:\n",
-    "        print(f\"Error during final evaluation: {e}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Simple Before/After Comparison"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "=== BEFORE vs AFTER COMPARISON ===\n",
-      "\n",
-      "\n",
-      "==================== GPT-4O-MINI ====================\n",
-      "\n",
-      "BEFORE REFLECTION:\n",
-      "--------------------------------------------------\n",
-      "This ethical dilemma presents a challenging decision for the philanthropist, who must weigh the immediate health needs of a few individuals against the broader societal implications of drug distribution and access.\n",
-      "\n",
-      "### Option 1: Prioritizing Immediate Health\n",
-      "\n",
-      "If the philanthropist chooses to manufa...\n",
-      "\n",
-      "AFTER REFLECTION:\n",
-      "--------------------------------------------------\n",
-      "This ethical dilemma presents the philanthropist with a complex decision regarding how best to utilize limited resources to maximize the benefit for individuals suffering from a rare but fatal disease. The two primary options – providing a low-cost supply to a select few or selling the formula for broader but costly distribution – both highlight significant ethical considerations.\n",
-      "\n",
-      "### Option 1: P...\n",
-      "\n",
-      "======================================================================\n",
-      "\n",
-      "\n",
-      "==================== CLAUDE-3-7-SONNET-LATEST ====================\n",
-      "\n",
-      "BEFORE REFLECTION:\n",
-      "--------------------------------------------------\n",
-      "# The Philanthropist's Dilemma\n",
-      "\n",
-      "This is a complex ethical dilemma that involves several important considerations:\n",
-      "\n",
-      "## Key Ethical Tensions\n",
-      "\n",
-      "- **Limited access at affordable prices** vs. **wider access at unaffordable prices**\n",
-      "- **Immediate relief for a few** vs. **potential long-term access for many...\n",
-      "\n",
-      "AFTER REFLECTION:\n",
-      "--------------------------------------------------\n",
-      "# The Philanthropist's Dilemma: A Multidimensional Ethical Analysis\n",
-      "\n",
-      "This scenario presents not simply a binary choice but a complex ethical landscape involving multiple stakeholders, systemic factors, and competing values.\n",
-      "\n",
-      "## Stakeholder Analysis\n",
-      "\n",
-      "**Patients and families:**\n",
-      "- Those currently suffering need immediate access regardless of mechanism\n",
-      "- Future patients have interests in sustainable d...\n",
-      "\n",
-      "======================================================================\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Display side-by-side comparison for each model\n",
-    "print(\"\\n=== BEFORE vs AFTER COMPARISON ===\\n\")\n",
-    "\n",
-    "for model_name in initial_responses:\n",
-    "    if model_name in reflected_responses:\n",
-    "        print(f\"\\n{'='*20} {model_name.upper()} {'='*20}\\n\")\n",
-    "        \n",
-    "        print(\"BEFORE REFLECTION:\")\n",
-    "        print(\"-\" * 50)\n",
-    "        print(initial_responses[model_name][:300] + \"...\")\n",
-    "        \n",
-    "        print(\"\\nAFTER REFLECTION:\")\n",
-    "        print(\"-\" * 50)\n",
-    "        # Extract just the \"Improved Response\" section if it exists\n",
-    "        reflected = reflected_responses[model_name]\n",
-    "        if \"## Improved Response\" in reflected:\n",
-    "            improved_section = reflected.split(\"## Improved Response\")[1].strip()\n",
-    "            print(improved_section[:400] + \"...\")\n",
-    "        else:\n",
-    "            print(reflected[:400] + \"...\")\n",
-    "        \n",
-    "        print(\"\\n\" + \"=\"*70 + \"\\n\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Pattern Analysis</h2>\n",
-    "            <span style=\"color:#ff7800;\">\n",
-    "            <b>Patterns used:</b><br/>\n",
-    "            1. <b>Multi-Model Comparison:</b> Comparing multiple models on the same task<br/>\n",
-    "            2. <b>Judge/Evaluator:</b> Using a model to evaluate performances<br/>\n",
-    "            3. <b>Reflection (NEW):</b> Self-critique and improvement of responses<br/><br/>\n",
-    "            <b>Possible experiments:</b><br/>\n",
-    "            - Iterate the Reflection Pattern multiple times<br/>\n",
-    "            - Add a \"Debate Pattern\" between models<br/>\n",
-    "            - Implement a \"Consensus Pattern\"\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial Applications</h2>\n",
-    "            <span style=\"color:#00bfff;\">\n",
-    "            The <b>Reflection Pattern</b> is particularly valuable for:<br/>\n",
-    "            • Improving quality of complex analyses<br/>\n",
-    "            • Reducing bias in AI recommendations<br/>\n",
-    "            • Creating self-improving systems<br/>\n",
-    "            • Developing more robust AI for critical decisions<br/><br/>\n",
-    "            Use cases: Strategic consulting, risk analysis, ethical evaluation, medical diagnosis\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Additional Pattern Ideas for Future Implementation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Exercise completed! Analyze the results to see the impact of the Reflection Pattern.\n"
-     ]
-    }
-   ],
-   "source": [
-    "# 1. Chain of Thought Pattern\n",
-    "\"\"\"\n",
-    "Add a pattern that asks models to show their reasoning step by step:\n",
-    "\n",
-    "def apply_chain_of_thought_pattern(client, question):\n",
-    "    prompt = f\\\"\n",
-    "    Question: {question}\n",
-    "    \n",
-    "    Please think through this step by step:\n",
-    "    Step 1: [Identify the key issues]\n",
-    "    Step 2: [Consider different perspectives]\n",
-    "    Step 3: [Evaluate potential consequences]\n",
-    "    Step 4: [Provide reasoned conclusion]\n",
-    "    \\\"\n",
-    "    return get_response(client, prompt)\n",
-    "\"\"\"\n",
-    "\n",
-    "# 2. Iterative Refinement Pattern\n",
-    "\"\"\"\n",
-    "Create a loop that progressively improves the response over multiple iterations:\n",
-    "\n",
-    "def iterative_refinement(client, question, iterations=3):\n",
-    "    response = get_initial_response(client, question)\n",
-    "    for i in range(iterations):\n",
-    "        critique_prompt = f\\\"Improve this response: {response}\\\"\n",
-    "        response = get_response(client, critique_prompt)\n",
-    "    return response\n",
-    "\"\"\"\n",
-    "\n",
-    "# 3. Debate Pattern\n",
-    "\"\"\"\n",
-    "Make two models debate their respective responses:\n",
-    "\n",
-    "def create_debate(client1, client2, question):\n",
-    "    response1 = get_response(client1, question)\n",
-    "    response2 = get_response(client2, question)\n",
-    "    \n",
-    "    debate_prompt1 = f\\\"Argue against this position: {response2}\\\"\n",
-    "    debate_prompt2 = f\\\"Argue against this position: {response1}\\\"\n",
-    "    \n",
-    "    counter1 = get_response(client1, debate_prompt1)\n",
-    "    counter2 = get_response(client2, debate_prompt2)\n",
-    "    \n",
-    "    return counter1, counter2\n",
-    "\"\"\"\n",
-    "\n",
-    "# 4. Consensus Building Pattern\n",
-    "\"\"\"\n",
-    "Attempt to create a consensus response based on all individual responses:\n",
-    "\n",
-    "def build_consensus(all_responses, question):\n",
-    "    consensus_prompt = f\\\"\n",
-    "    Original question: {question}\n",
-    "    \n",
-    "    Here are multiple expert responses:\n",
-    "    {all_responses}\n",
-    "    \n",
-    "    Create a consensus response that incorporates the best insights from all responses\n",
-    "    while resolving contradictions.\n",
-    "    \\\"\n",
-    "    return get_response(openai_client, consensus_prompt)\n",
-    "\"\"\"\n",
-    "\n",
-    "print(\"Exercise completed! Analyze the results to see the impact of the Reflection Pattern.\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

community_contributions/2_lab2_six-thinking-hats-simulator.ipynb

@@ -1,457 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Six Thinking Hats Simulator\n",
-    "\n",
-    "## Objective\n",
-    "This notebook implements a simulator of the Six Thinking Hats technique to evaluate and improve technological solutions. The simulator will:\n",
-    "\n",
-    "1. Use an LLM to generate an initial technological solution idea for a specific daily task in a company.\n",
-    "2. Apply the Six Thinking Hats methodology to analyze and improve the proposed solution.\n",
-    "3. Provide a comprehensive evaluation from different perspectives.\n",
-    "\n",
-    "## About the Six Thinking Hats Technique\n",
-    "\n",
-    "The Six Thinking Hats is a powerful technique developed by Edward de Bono that helps people look at problems and decisions from different perspectives. Each \"hat\" represents a different thinking approach:\n",
-    "\n",
-    "- **White Hat (Facts):** Focuses on available information, facts, and data.\n",
-    "- **Red Hat (Feelings):** Represents emotions, intuition, and gut feelings.\n",
-    "- **Black Hat (Critical):** Identifies potential problems, risks, and negative aspects.\n",
-    "- **Yellow Hat (Positive):** Looks for benefits, opportunities, and positive aspects.\n",
-    "- **Green Hat (Creative):** Encourages new ideas, alternatives, and possibilities.\n",
-    "- **Blue Hat (Process):** Manages the thinking process and ensures all perspectives are considered.\n",
-    "\n",
-    "In this simulator, we'll use these different perspectives to thoroughly evaluate and improve technological solutions proposed by an LLM."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = \"Generate a technological solution to solve a specific workplace challenge. Choose an employee role, in a specific industry, and identify a time-consuming or error-prone daily task they face. Then, create an innovative yet practical technological solution that addresses this challenge. Include what technologies it uses (AI, automation, etc.), how it integrates with existing systems, its key benefits, and basic implementation requirements. Keep your solution realistic with current technology. \"\n",
-    "request += \"Answer only with the question, no explanation.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "validation_prompt = f\"\"\"Validate and improve the following technological solution. For each iteration, check if the solution meets these criteria:\n",
-    "\n",
-    "1. Clarity:\n",
-    "   - Is the problem clearly defined?\n",
-    "   - Is the solution clearly explained?\n",
-    "   - Are the technical components well-described?\n",
-    "\n",
-    "2. Specificity:\n",
-    "   - Are there specific examples or use cases?\n",
-    "   - Are the technologies and tools specifically named?\n",
-    "   - Are the implementation steps detailed?\n",
-    "\n",
-    "3. Context:\n",
-    "   - Is the industry/company context clear?\n",
-    "   - Are the user roles and needs well-defined?\n",
-    "   - Is the current workflow/problem well-described?\n",
-    "\n",
-    "4. Constraints:\n",
-    "   - Are there clear technical limitations?\n",
-    "   - Are there budget/time constraints mentioned?\n",
-    "   - Are there integration requirements specified?\n",
-    "\n",
-    "If any of these criteria are not met, improve the solution by:\n",
-    "1. Adding missing details\n",
-    "2. Clarifying ambiguous points\n",
-    "3. Providing more specific examples\n",
-    "4. Including relevant constraints\n",
-    "\n",
-    "Here is the technological solution to validate and improve:\n",
-    "{question} \n",
-    "Provide an improved version that addresses any missing or unclear aspects. If this is the 5th iteration, return the final improved version without further changes.\n",
-    "\n",
-    "Response only with the Improved Solution:\n",
-    "[Your improved solution here]\"\"\"\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": validation_prompt}]\n",
-    "\n",
-    "response = openai.chat.completions.create(model=\"gpt-4o\", messages=messages)\n",
-    "question = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(question))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "In this section, we will ask each AI model to analyze a technological solution using the Six Thinking Hats methodology. Each model will:\n",
-    "\n",
-    "1. First generate a technological solution for a workplace challenge\n",
-    "2. Then analyze that solution using each of the Six Thinking Hats\n",
-    "\n",
-    "Each model will provide:\n",
-    "1. An initial technological solution\n",
-    "2. A structured analysis using all six thinking hats\n",
-    "3. A final recommendation based on the comprehensive analysis\n",
-    "\n",
-    "This approach will allow us to:\n",
-    "- Compare how different models apply the Six Thinking Hats methodology\n",
-    "- Identify patterns and differences in their analytical approaches\n",
-    "- Gather diverse perspectives on the same solution\n",
-    "- Create a rich, multi-faceted evaluation of each proposed technological solution\n",
-    "\n",
-    "The responses will be collected and displayed below, showing how each model applies the Six Thinking Hats methodology to evaluate and improve the proposed solutions."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "models = []\n",
-    "answers = []\n",
-    "combined_question = f\" Analyze the technological solution prposed in {question} using the Six Thinking Hats methodology. For each hat, provide a detailed analysis. Finally, provide a comprehensive recommendation based on all the above analyses.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": combined_question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# GPT thinking process\n",
-    "\n",
-    "model_name = \"gpt-4o\"\n",
-    "\n",
-    "\n",
-    "response = openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "models.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Claude thinking process\n",
-    "\n",
-    "model_name = \"claude-3-7-sonnet-latest\"\n",
-    "\n",
-    "claude = Anthropic()\n",
-    "response = claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "answer = response.content[0].text\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "models.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Gemini thinking process\n",
-    "\n",
-    "gemini = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "response = gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "models.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Deepseek thinking process\n",
-    "\n",
-    "deepseek = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "model_name = \"deepseek-chat\"\n",
-    "\n",
-    "response = deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "models.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Groq thinking process\n",
-    "\n",
-    "groq = OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "response = groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "models.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ollama thinking process\n",
-    "\n",
-    "ollama = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "model_name = \"llama3.2\"\n",
-    "\n",
-    "response = ollama.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "models.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for model, answer in zip(models, answers):\n",
-    "    print(f\"Model: {model}\\n\\n{answer}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Next Step: Solution Synthesis and Enhancement\n",
-    "\n",
-    "**Best Recommendation Selection and Extended Solution Development**\n",
-    "\n",
-    "After applying the Six Thinking Hats analysis to evaluate the initial technological solution from multiple perspectives, the simulator will:\n",
-    "\n",
-    "1. **Synthesize Analysis Results**: Compile insights from all six thinking perspectives (White, Red, Black, Yellow, Green, and Blue hats) to identify the most compelling recommendations and improvements.\n",
-    "\n",
-    "2. **Select Optimal Recommendation**: Using a weighted evaluation system that considers feasibility, impact, and alignment with organizational goals, the simulator will identify and present the single best recommendation that emerged from the Six Thinking Hats analysis.\n",
-    "\n",
-    "3. **Generate Extended Solution**: Building upon the selected best recommendation, the simulator will create a comprehensive, enhanced version of the original technological solution that incorporates:\n",
-    "  - Key insights from the critical analysis (Black Hat)\n",
-    "  - Positive opportunities identified (Yellow Hat)\n",
-    "  - Creative alternatives and innovations (Green Hat)\n",
-    "  - Factual considerations and data requirements (White Hat)\n",
-    "  - User experience and emotional factors (Red Hat)\n",
-    "\n",
-    "4. **Multi-Model Enhancement**: To further strengthen the solution, the simulator will leverage additional AI models or perspectives to provide supplementary recommendations that complement the Six Thinking Hats analysis, offering a more robust and well-rounded final technological solution.\n",
-    "\n",
-    "This step transforms the analytical insights into actionable improvements, delivering a refined solution that has been thoroughly evaluated and enhanced through structured critical thinking."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from model {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "import re\n",
-    "\n",
-    "print(f\"Each model has been given this technological solution to analyze: {question}\")\n",
-    "\n",
-    "# First, get the best individual response\n",
-    "judge_prompt = f\"\"\"\n",
-    "    You are judging the quality of {len(models)} responses.\n",
-    "    Evaluate each response based on:\n",
-    "    1. Clarity and coherence\n",
-    "    2. Depth of analysis\n",
-    "    3. Practicality of recommendations\n",
-    "    4. Originality of insights\n",
-    "    \n",
-    "    Rank the responses from best to worst.\n",
-    "    Respond with the model index of the best response, nothing else.\n",
-    "    \n",
-    "    Here are the responses:\n",
-    "    {answers}\n",
-    "    \"\"\"\n",
-    "    \n",
-    "# Get the best response\n",
-    "judge_response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=[{\"role\": \"user\", \"content\": judge_prompt}]\n",
-    ")\n",
-    "best_response = judge_response.choices[0].message.content\n",
-    "\n",
-    "print(f\"Best Response's Model: {models[int(best_response)]}\")\n",
-    "\n",
-    "synthesis_prompt = f\"\"\"\n",
-    "    Here is the best response's model index from the judge:\n",
-    "\n",
-    "    {best_response}\n",
-    "\n",
-    "    And here are the responses from all the models:\n",
-    "\n",
-    "    {together}\n",
-    "\n",
-    "    Synthesize the responses from the non-best models into one comprehensive answer that:\n",
-    "    1. Captures the best insights from each response that could add value to the best response from the judge\n",
-    "    2. Resolves any contradictions between responses before extending the best response\n",
-    "    3. Presents a clear and coherent final answer that is a comprehensive extension of the best response from the judge\n",
-    "    4. Maintains the same format as the original best response from the judge\n",
-    "    5. Compiles all additional recommendations mentioned by all models\n",
-    "\n",
-    "    Show the best response {answers[int(best_response)]} and then your synthesized response specifying which are additional recommendations to the best response:\n",
-    "    \"\"\"\n",
-    "\n",
-    "# Get the synthesized response\n",
-    "synthesis_response = claude.messages.create(\n",
-    "    model=\"claude-3-7-sonnet-latest\",\n",
-    "    messages=[{\"role\": \"user\", \"content\": synthesis_prompt}],\n",
-    "    max_tokens=10000\n",
-    ")\n",
-    "synthesized_answer = synthesis_response.content[0].text\n",
-    "\n",
-    "converted_answer = re.sub(r'\\\\[\\[\\]]', '$$', synthesized_answer)\n",
-    "display(Markdown(converted_answer))"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.10"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/3_lab3_groq_llama_generator_gemini_evaluator.ipynb

@@ -1,286 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Chat app with LinkedIn Profile Information - Groq LLama as Generator and Gemini as evaluator\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# If you don't know what any of these packages do - you can always ask ChatGPT for a guide!\n",
-    "\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from pypdf import PdfReader\n",
-    "from groq import Groq\n",
-    "import gradio as gr"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 59,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "load_dotenv(override=True)\n",
-    "groq = Groq()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 60,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "reader = PdfReader(\"me/My_LinkedIn.pdf\")\n",
-    "linkedin = \"\"\n",
-    "for page in reader.pages:\n",
-    "    text = page.extract_text()\n",
-    "    if text:\n",
-    "        linkedin += text"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(linkedin)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 61,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "with open(\"me/summary.txt\", \"r\", encoding=\"utf-8\") as f:\n",
-    "    summary = f.read()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 62,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "name = \"Maalaiappan Subramanian\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 63,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "system_prompt = f\"You are acting as {name}. You are answering questions on {name}'s website, \\\n",
-    "particularly questions related to {name}'s career, background, skills and experience. \\\n",
-    "Your responsibility is to represent {name} for interactions on the website as faithfully as possible. \\\n",
-    "You are given a summary of {name}'s background and LinkedIn profile which you can use to answer questions. \\\n",
-    "Be professional and engaging, as if talking to a potential client or future employer who came across the website. \\\n",
-    "If you don't know the answer, say so.\"\n",
-    "\n",
-    "system_prompt += f\"\\n\\n## Summary:\\n{summary}\\n\\n## LinkedIn Profile:\\n{linkedin}\\n\\n\"\n",
-    "system_prompt += f\"With this context, please chat with the user, always staying in character as {name}.\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "system_prompt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 65,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def chat(message, history):\n",
-    "    # Below line is to remove the metadata and options from the history\n",
-    "    history = [{k: v for k, v in item.items() if k not in ('metadata', 'options')} for item in history]\n",
-    "    messages = [{\"role\": \"system\", \"content\": system_prompt}] + history + [{\"role\": \"user\", \"content\": message}]\n",
-    "    response = groq.chat.completions.create(model=\"llama-3.3-70b-versatile\", messages=messages)\n",
-    "    return response.choices[0].message.content"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gr.ChatInterface(chat, type=\"messages\").launch()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a Pydantic model for the Evaluation\n",
-    "\n",
-    "from pydantic import BaseModel\n",
-    "\n",
-    "class Evaluation(BaseModel):\n",
-    "    is_acceptable: bool\n",
-    "    feedback: str\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 69,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "evaluator_system_prompt = f\"You are an evaluator that decides whether a response to a question is acceptable. \\\n",
-    "You are provided with a conversation between a User and an Agent. Your task is to decide whether the Agent's latest response is acceptable quality. \\\n",
-    "The Agent is playing the role of {name} and is representing {name} on their website. \\\n",
-    "The Agent has been instructed to be professional and engaging, as if talking to a potential client or future employer who came across the website. \\\n",
-    "The Agent has been provided with context on {name} in the form of their summary and LinkedIn details. Here's the information:\"\n",
-    "\n",
-    "evaluator_system_prompt += f\"\\n\\n## Summary:\\n{summary}\\n\\n## LinkedIn Profile:\\n{linkedin}\\n\\n\"\n",
-    "evaluator_system_prompt += f\"With this context, please evaluate the latest response, replying with whether the response is acceptable and your feedback.\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 70,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def evaluator_user_prompt(reply, message, history):\n",
-    "    user_prompt = f\"Here's the conversation between the User and the Agent: \\n\\n{history}\\n\\n\"\n",
-    "    user_prompt += f\"Here's the latest message from the User: \\n\\n{message}\\n\\n\"\n",
-    "    user_prompt += f\"Here's the latest response from the Agent: \\n\\n{reply}\\n\\n\"\n",
-    "    user_prompt += f\"Please evaluate the response, replying with whether it is acceptable and your feedback.\"\n",
-    "    return user_prompt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 71,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "gemini = OpenAI(\n",
-    "    api_key=os.getenv(\"GOOGLE_API_KEY\"), \n",
-    "    base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 72,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def evaluate(reply, message, history) -> Evaluation:\n",
-    "\n",
-    "    messages = [{\"role\": \"system\", \"content\": evaluator_system_prompt}] + [{\"role\": \"user\", \"content\": evaluator_user_prompt(reply, message, history)}]\n",
-    "    response = gemini.beta.chat.completions.parse(model=\"gemini-2.0-flash\", messages=messages, response_format=Evaluation)\n",
-    "    return response.choices[0].message.parsed"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 73,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def rerun(reply, message, history, feedback):\n",
-    "    # Below line is to remove the metadata and options from the history\n",
-    "    history = [{k: v for k, v in item.items() if k not in ('metadata', 'options')} for item in history]\n",
-    "    updated_system_prompt = system_prompt + f\"\\n\\n## Previous answer rejected\\nYou just tried to reply, but the quality control rejected your reply\\n\"\n",
-    "    updated_system_prompt += f\"## Your attempted answer:\\n{reply}\\n\\n\"\n",
-    "    updated_system_prompt += f\"## Reason for rejection:\\n{feedback}\\n\\n\"\n",
-    "    messages = [{\"role\": \"system\", \"content\": updated_system_prompt}] + history + [{\"role\": \"user\", \"content\": message}]\n",
-    "    response = groq.chat.completions.create(model=\"llama-3.3-70b-versatile\", messages=messages)\n",
-    "    return response.choices[0].message.content"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 74,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def chat(message, history):\n",
-    "    if \"personal\" in message:\n",
-    "        system = system_prompt + \"\\n\\nEverything in your reply needs to be in Gen Z language - \\\n",
-    "              it is mandatory that you respond only and entirely in Gen Z language\"\n",
-    "    else:\n",
-    "        system = system_prompt\n",
-    "    # Below line is to remove the metadata and options from the history\n",
-    "    history = [{k: v for k, v in item.items() if k not in ('metadata', 'options')} for item in history]\n",
-    "    messages = [{\"role\": \"system\", \"content\": system}] + history + [{\"role\": \"user\", \"content\": message}]\n",
-    "    response = groq.chat.completions.create(model=\"llama-3.3-70b-versatile\", messages=messages)\n",
-    "    reply =response.choices[0].message.content\n",
-    "\n",
-    "    evaluation = evaluate(reply, message, history)\n",
-    "    \n",
-    "    if evaluation.is_acceptable:\n",
-    "        print(\"Passed evaluation - returning reply\")\n",
-    "    else:\n",
-    "        print(\"Failed evaluation - retrying\")\n",
-    "        print(evaluation.feedback)\n",
-    "        reply = rerun(reply, message, history, evaluation.feedback)       \n",
-    "    return reply"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gr.ChatInterface(chat, type=\"messages\").launch()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.10"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/4_lab4_slack.ipynb

@@ -1,469 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## The first big project - Professionally You!\n",
-    "\n",
-    "### And, Tool use.\n",
-    "\n",
-    "### But first: introducing Slack\n",
-    "\n",
-    "Slack is a nifty tool for sending Push Notifications to your phone.\n",
-    "\n",
-    "It's super easy to set up and install!\n",
-    "\n",
-    "Simply visit https://api.slack.com and sign up for a free account, and create your new workspace and app.\n",
-    "\n",
-    "1. Create a Slack App:\n",
-    "- Go to the [Slack API portal](https://api.slack.com/apps) and click Create New App.\n",
-    "- Choose From scratch, provide an App Name (e.g., \"CustomerNotifier\"), and select the Slack workspace where you want to - install the app.\n",
-    "- Click Create App.\n",
-    "\n",
-    "2. Add Required Permissions (Scopes):\n",
-    "- Navigate to OAuth & Permissions in the left sidebar of your app’s management page.\n",
-    "- Under Bot Token Scopes, add the chat:write scope to allow your app to post messages. If you need to send direct messages (DMs) to users, also add im:write and users:read to fetch user IDs.\n",
-    "- If you plan to post to specific channels, ensure the app has permissions like channels:write or groups:write for public or private channels, respectively.\n",
-    "\n",
-    "3. Install the App to Your Workspace:\n",
-    "- In the OAuth & Permissions section, click Install to Workspace.\n",
-    "- Authorize the app, selecting the channel where it will post messages (if using incoming webhooks) or granting the necessary permissions.\n",
-    "- After installation, you’ll receive a Bot User OAuth Token (starts with xoxb-). Copy this token, as it will be used for - API authentication. Keep it secure and avoid hardcoding it in your source code.\n",
-    "\n",
-    "(This is so you could choose to organize your push notifications into different apps in the future.)\n",
-    "\n",
-    "4. Create a new private channel in slack App\n",
-    "- Opt to use Private Access\n",
-    "- After creating the private channel, type \"@<your bot name in step 1>\" to allow slack default bot to invite the bot into your chat\n",
-    "- Go to \"About\" of your private chat. Copy the channel Id at the bottom\n",
-    "\n",
-    "5. Install slack_sdk==3.35.0 into your env\n",
-    "```\n",
-    "uv pip install slack_sdk==3.35.0\n",
-    "```\n",
-    "\n",
-    "Add to your `.env` file:\n",
-    "```\n",
-    "SLACK_AGENT_CHANNEL_ID=put_your_user_token_here\n",
-    "SLACK_BOT_AGENT_OAUTH_TOKEN=put_the_oidc_token_here\n",
-    "```\n",
-    "\n",
-    "And install the Slack app on your phone."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# imports\n",
-    "\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "import json\n",
-    "import os\n",
-    "import requests\n",
-    "from pypdf import PdfReader\n",
-    "import gradio as gr\n",
-    "from slack_sdk import WebClient\n",
-    "from slack_sdk.errors import SlackApiError"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The usual start\n",
-    "\n",
-    "load_dotenv(override=True)\n",
-    "openai = OpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# For slack\n",
-    "\n",
-    "slack_channel_id:str = str(os.getenv(\"SLACK_AGENT_CHANNEL_ID\"))\n",
-    "slack_oauth_token = os.getenv(\"SLACK_BOT_AGENT_OAUTH_TOKEN\")\n",
-    "slack_client = WebClient(token=slack_oauth_token)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def push(message):\n",
-    "    print(f\"Push: {message}\")\n",
-    "    response = slack_client.chat_postMessage(\n",
-    "                    channel=slack_channel_id,\n",
-    "                    text=message\n",
-    "                )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "push(\"HEY!!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def record_user_details(email, name=\"Name not provided\", notes=\"not provided\"):\n",
-    "    push(f\"Recording interest from {name} with email {email} and notes {notes}\")\n",
-    "    return {\"recorded\": \"ok\"}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def record_unknown_question(question):\n",
-    "    push(f\"Recording {question} asked that I couldn't answer\")\n",
-    "    return {\"recorded\": \"ok\"}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "record_user_details_json = {\n",
-    "    \"name\": \"record_user_details\",\n",
-    "    \"description\": \"Use this tool to record that a user is interested in being in touch and provided an email address\",\n",
-    "    \"parameters\": {\n",
-    "        \"type\": \"object\",\n",
-    "        \"properties\": {\n",
-    "            \"email\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"The email address of this user\"\n",
-    "            },\n",
-    "            \"name\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"The user's name, if they provided it\"\n",
-    "            }\n",
-    "            ,\n",
-    "            \"notes\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"Any additional information about the conversation that's worth recording to give context\"\n",
-    "            }\n",
-    "        },\n",
-    "        \"required\": [\"email\"],\n",
-    "        \"additionalProperties\": False\n",
-    "    }\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "record_unknown_question_json = {\n",
-    "    \"name\": \"record_unknown_question\",\n",
-    "    \"description\": \"Always use this tool to record any question that couldn't be answered as you didn't know the answer\",\n",
-    "    \"parameters\": {\n",
-    "        \"type\": \"object\",\n",
-    "        \"properties\": {\n",
-    "            \"question\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"The question that couldn't be answered\"\n",
-    "            },\n",
-    "        },\n",
-    "        \"required\": [\"question\"],\n",
-    "        \"additionalProperties\": False\n",
-    "    }\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tools = [{\"type\": \"function\", \"function\": record_user_details_json},\n",
-    "        {\"type\": \"function\", \"function\": record_unknown_question_json}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tools"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This function can take a list of tool calls, and run them. This is the IF statement!!\n",
-    "\n",
-    "def handle_tool_calls(tool_calls):\n",
-    "    results = []\n",
-    "    for tool_call in tool_calls:\n",
-    "        tool_name = tool_call.function.name\n",
-    "        arguments = json.loads(tool_call.function.arguments)\n",
-    "        print(f\"Tool called: {tool_name}\", flush=True)\n",
-    "\n",
-    "        # THE BIG IF STATEMENT!!!\n",
-    "\n",
-    "        if tool_name == \"record_user_details\":\n",
-    "            result = record_user_details(**arguments)\n",
-    "        elif tool_name == \"record_unknown_question\":\n",
-    "            result = record_unknown_question(**arguments)\n",
-    "\n",
-    "        results.append({\"role\": \"tool\",\"content\": json.dumps(result),\"tool_call_id\": tool_call.id})\n",
-    "    return results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "globals()[\"record_unknown_question\"](\"this is a really hard question\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This is a more elegant way that avoids the IF statement.\n",
-    "\n",
-    "def handle_tool_calls(tool_calls):\n",
-    "    results = []\n",
-    "    for tool_call in tool_calls:\n",
-    "        tool_name = tool_call.function.name\n",
-    "        arguments = json.loads(tool_call.function.arguments)\n",
-    "        print(f\"Tool called: {tool_name}\", flush=True)\n",
-    "        tool = globals().get(tool_name)\n",
-    "        result = tool(**arguments) if tool else {}\n",
-    "        results.append({\"role\": \"tool\",\"content\": json.dumps(result),\"tool_call_id\": tool_call.id})\n",
-    "    return results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "reader = PdfReader(\"me/linkedin.pdf\")\n",
-    "linkedin = \"\"\n",
-    "for page in reader.pages:\n",
-    "    text = page.extract_text()\n",
-    "    if text:\n",
-    "        linkedin += text\n",
-    "\n",
-    "with open(\"me/summary.txt\", \"r\", encoding=\"utf-8\") as f:\n",
-    "    summary = f.read()\n",
-    "\n",
-    "name = \"Ed Donner\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "system_prompt = f\"You are acting as {name}. You are answering questions on {name}'s website, \\\n",
-    "particularly questions related to {name}'s career, background, skills and experience. \\\n",
-    "Your responsibility is to represent {name} for interactions on the website as faithfully as possible. \\\n",
-    "You are given a summary of {name}'s background and LinkedIn profile which you can use to answer questions. \\\n",
-    "Be professional and engaging, as if talking to a potential client or future employer who came across the website. \\\n",
-    "If you don't know the answer to any question, use your record_unknown_question tool to record the question that you couldn't answer, even if it's about something trivial or unrelated to career. \\\n",
-    "If the user is engaging in discussion, try to steer them towards getting in touch via email; ask for their email and record it using your record_user_details tool. \"\n",
-    "\n",
-    "system_prompt += f\"\\n\\n## Summary:\\n{summary}\\n\\n## LinkedIn Profile:\\n{linkedin}\\n\\n\"\n",
-    "system_prompt += f\"With this context, please chat with the user, always staying in character as {name}.\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def chat(message, history):\n",
-    "    messages = [{\"role\": \"system\", \"content\": system_prompt}] + history + [{\"role\": \"user\", \"content\": message}]\n",
-    "    done = False\n",
-    "    while not done:\n",
-    "\n",
-    "        # This is the call to the LLM - see that we pass in the tools json\n",
-    "\n",
-    "        response = openai.chat.completions.create(model=\"gpt-4o-mini\", messages=messages, tools=tools)\n",
-    "\n",
-    "        finish_reason = response.choices[0].finish_reason\n",
-    "        \n",
-    "        # If the LLM wants to call a tool, we do that!\n",
-    "         \n",
-    "        if finish_reason==\"tool_calls\":\n",
-    "            message = response.choices[0].message\n",
-    "            tool_calls = message.tool_calls\n",
-    "            results = handle_tool_calls(tool_calls)\n",
-    "            messages.append(message)\n",
-    "            messages.extend(results)\n",
-    "        else:\n",
-    "            done = True\n",
-    "    return response.choices[0].message.content"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gr.ChatInterface(chat, type=\"messages\").launch()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## And now for deployment\n",
-    "\n",
-    "This code is in `app.py`\n",
-    "\n",
-    "We will deploy to HuggingFace Spaces. Thank you student Robert M for improving these instructions.\n",
-    "\n",
-    "Before you start: remember to update the files in the \"me\" directory - your LinkedIn profile and summary.txt - so that it talks about you!  \n",
-    "Also check that there's no README file within the 1_foundations directory. If there is one, please delete it. The deploy process creates a new README file in this directory for you.\n",
-    "\n",
-    "1. Visit https://huggingface.co and set up an account  \n",
-    "2. From the Avatar menu on the top right, choose Access Tokens. Choose \"Create New Token\". Give it WRITE permissions.\n",
-    "3. Take this token and add it to your .env file: `HF_TOKEN=hf_xxx` and see note below if this token doesn't seem to get picked up during deployment  \n",
-    "4. From the 1_foundations folder, enter: `uv run gradio deploy` and if for some reason this still wants you to enter your HF token, then interrupt it with ctrl+c and run this instead: `uv run dotenv -f ../.env run -- uv run gradio deploy` which forces your keys to all be set as environment variables   \n",
-    "5. Follow its instructions: name it \"career_conversation\", specify app.py, choose cpu-basic as the hardware, say Yes to needing to supply secrets, provide your openai api key, your pushover user and token, and say \"no\" to github actions.  \n",
-    "\n",
-    "#### Extra note about the HuggingFace token\n",
-    "\n",
-    "A couple of students have mentioned the HuggingFace doesn't detect their token, even though it's in the .env file. Here are things to try:   \n",
-    "1. Restart Cursor   \n",
-    "2. Rerun load_dotenv(override=True) and use a new terminal (the + button on the top right of the Terminal)   \n",
-    "3. In the Terminal, run this before the gradio deploy: `$env:HF_TOKEN = \"hf_XXXX\"`  \n",
-    "Thank you James and Martins for these tips.  \n",
-    "\n",
-    "#### More about these secrets:\n",
-    "\n",
-    "If you're confused by what's going on with these secrets: it just wants you to enter the key name and value for each of your secrets -- so you would enter:  \n",
-    "`OPENAI_API_KEY`  \n",
-    "Followed by:  \n",
-    "`sk-proj-...`  \n",
-    "\n",
-    "And if you don't want to set secrets this way, or something goes wrong with it, it's no problem - you can change your secrets later:  \n",
-    "1. Log in to HuggingFace website  \n",
-    "2. Go to your profile screen via the Avatar menu on the top right  \n",
-    "3. Select the Space you deployed  \n",
-    "4. Click on the Settings wheel on the top right  \n",
-    "5. You can scroll down to change your secrets, delete the space, etc.\n",
-    "\n",
-    "#### And now you should be deployed!\n",
-    "\n",
-    "Here is mine: https://huggingface.co/spaces/ed-donner/Career_Conversation\n",
-    "\n",
-    "I just got a push notification that a student asked me how they can become President of their country 😂😂\n",
-    "\n",
-    "For more information on deployment:\n",
-    "\n",
-    "https://www.gradio.app/guides/sharing-your-app#hosting-on-hf-spaces\n",
-    "\n",
-    "To delete your Space in the future:  \n",
-    "1. Log in to HuggingFace\n",
-    "2. From the Avatar menu, select your profile\n",
-    "3. Click on the Space itself and select the settings wheel on the top right\n",
-    "4. Scroll to the Delete section at the bottom\n",
-    "5. ALSO: delete the README file that Gradio may have created inside this 1_foundations folder (otherwise it won't ask you the questions the next time you do a gradio deploy)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">• First and foremost, deploy this for yourself! It's a real, valuable tool - the future resume..<br/>\n",
-    "            • Next, improve the resources - add better context about yourself. If you know RAG, then add a knowledge base about you.<br/>\n",
-    "            • Add in more tools! You could have a SQL database with common Q&A that the LLM could read and write from?<br/>\n",
-    "            • Bring in the Evaluator from the last lab, and add other Agentic patterns.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">Aside from the obvious (your career alter-ego) this has business applications in any situation where you need an AI assistant with domain expertise and an ability to interact with the real world.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/4_lab4_spotify.ipynb

@@ -1,829 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Adding a Spotify Tool - Musically You!\n",
-    "\n",
-    "This version of the notebook introduces a Spotify tool that can query your listening history from Spotify to extend the domain of questions the chatbot can answer to include your musical tastes.\n",
-    "\n",
-    "Unfortunately, it's a bit of PITA to get acess and refresh tokens for Spotify.  The process requires connecting to an authentication end point while logged in to Spotify and then processing a callback.  To make this easier, instructions along with a small app that can be deployed to HuggingFace Spaces using Gradio are included at the end of this notebook. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## The first big project - Professionally You!\n",
-    "\n",
-    "### And, Tool use.\n",
-    "\n",
-    "### But first: introducing Pushover\n",
-    "\n",
-    "Pushover is a nifty tool for sending Push Notifications to your phone.\n",
-    "\n",
-    "It's super easy to set up and install!\n",
-    "\n",
-    "Simply visit https://pushover.net/ and click 'Login or Signup' on the top right to sign up for a free account, and create your API keys.\n",
-    "\n",
-    "Once you've signed up, on the home screen, click \"Create an Application/API Token\", and give it any name (like Agents) and click Create Application.\n",
-    "\n",
-    "Then add 2 lines to your `.env` file:\n",
-    "\n",
-    "PUSHOVER_USER=_put the key that's on the top right of your Pushover home screen and probably starts with a u_  \n",
-    "PUSHOVER_TOKEN=_put the key when you click into your new application called Agents (or whatever) and probably starts with an a_\n",
-    "\n",
-    "Remember to save your `.env` file, and run `load_dotenv(override=True)` after saving, to set your environment variables.\n",
-    "\n",
-    "Finally, click \"Add Phone, Tablet or Desktop\" to install on your phone."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# imports\n",
-    "\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "import json\n",
-    "import os\n",
-    "import requests\n",
-    "from pypdf import PdfReader\n",
-    "import gradio as gr"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The usual start\n",
-    "\n",
-    "load_dotenv(override=True)\n",
-    "openai = OpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# For pushover\n",
-    "\n",
-    "pushover_user = os.getenv(\"PUSHOVER_USER\")\n",
-    "pushover_token = os.getenv(\"PUSHOVER_TOKEN\")\n",
-    "pushover_url = \"https://api.pushover.net/1/messages.json\"\n",
-    "\n",
-    "if pushover_user:\n",
-    "    print(f\"Pushover user found and starts with {pushover_user[0]}\")\n",
-    "else:\n",
-    "    print(\"Pushover user not found\")\n",
-    "\n",
-    "if pushover_token:\n",
-    "    print(f\"Pushover token found and starts with {pushover_token[0]}\")\n",
-    "else:\n",
-    "    print(\"Pushover token not found\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def push(message):\n",
-    "    print(f\"Push: {message}\")\n",
-    "    payload = {\"user\": pushover_user, \"token\": pushover_token, \"message\": message}\n",
-    "    requests.post(pushover_url, data=payload)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def record_user_details(email, name=\"Name not provided\", notes=\"not provided\"):\n",
-    "    push(f\"Recording interest from {name} with email {email} and notes {notes}\")\n",
-    "    return {\"recorded\": \"ok\"}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def record_unknown_question(question):\n",
-    "    push(f\"Recording {question} asked that I couldn't answer\")\n",
-    "    return {\"recorded\": \"ok\"}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# For Spotify access token and refresh token\n",
-    "import base64\n",
-    "import time\n",
-    "import hashlib\n",
-    "import secrets\n",
-    "import urllib.parse\n",
-    "\n",
-    "spotify_client_id = os.getenv(\"SPOTIFY_CLIENT_ID\")\n",
-    "spotify_client_secret = os.getenv(\"SPOTIFY_CLIENT_SECRET\")\n",
-    "\n",
-    "if spotify_client_id:\n",
-    "    print(f\"Spotify client ID found and starts with {spotify_client_id[:4]}\")\n",
-    "else:\n",
-    "    print(\"Spotify client ID not found\")\n",
-    "\n",
-    "if spotify_client_secret:\n",
-    "    print(f\"Spotify client secret found and starts with {spotify_client_secret[:4]}\")\n",
-    "else:\n",
-    "    print(\"Spotify client secret not found\")\n",
-    "\n",
-    "spotify_access_token = os.getenv(\"SPOTIFY_ACCESS_TOKEN\")\n",
-    "spotify_refresh_token = os.getenv(\"SPOTIFY_REFRESH_TOKEN\")\n",
-    "\n",
-    "if spotify_access_token and spotify_refresh_token:\n",
-    "    # Set expiry to past to force refresh on first use\n",
-    "    spotify_token_expiry = time.time() - 60\n",
-    "    print(\"Spotify tokens loaded from environment!\")\n",
-    "    print(f\"Access token preview: {spotify_access_token[:20]}...\")\n",
-    "    print(f\"Refresh token preview: {spotify_refresh_token[:20]}...\")\n",
-    "else:\n",
-    "    print(\"No Spotify tokens found in environment. Run spotify_flask_auth.py to get them.\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_spotify_access_token():\n",
-    "    global spotify_access_token, spotify_refresh_token, spotify_token_expiry\n",
-    "    \n",
-    "    # Check if we have a valid cached token\n",
-    "    if spotify_access_token and time.time() < spotify_token_expiry:\n",
-    "        return spotify_access_token\n",
-    "    \n",
-    "\n",
-    "    auth_url = \"https://accounts.spotify.com/api/token\"\n",
-    "    \n",
-    "    credentials = f\"{spotify_client_id}:{spotify_client_secret}\"\n",
-    "    encoded_credentials = base64.b64encode(credentials.encode()).decode()\n",
-    "    \n",
-    "    headers = {\n",
-    "        \"Authorization\": f\"Basic {encoded_credentials}\",\n",
-    "        \"Content-Type\": \"application/x-www-form-urlencoded\"\n",
-    "    }\n",
-    "    \n",
-    "    data = {\n",
-    "        \"grant_type\": \"refresh_token\",\n",
-    "        \"refresh_token\": spotify_refresh_token\n",
-    "    }\n",
-    "    \n",
-    "    response = requests.post(auth_url, headers=headers, data=data)\n",
-    "    \n",
-    "    if response.status_code == 200:\n",
-    "        token_data = response.json()\n",
-    "        spotify_access_token = token_data[\"access_token\"]\n",
-    "        # Update refresh token if a new one is provided\n",
-    "        if \"refresh_token\" in token_data:\n",
-    "            spotify_refresh_token = token_data[\"refresh_token\"]\n",
-    "        # Set expiry time with a buffer\n",
-    "        spotify_token_expiry = time.time() + token_data[\"expires_in\"] - 300\n",
-    "        return spotify_access_token\n",
-    "    else:\n",
-    "        print(f\"Failed to refresh Spotify access token: {response.status_code}\")\n",
-    "        print(f\"Response: {response.text}\")\n",
-    "        return None\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_user_top_items(item_type=\"artists\", time_range=\"medium_term\", limit=10):\n",
-    "    \"\"\"\n",
-    "    Get the user's top artists or tracks from Spotify.\n",
-    "    \n",
-    "    Args:\n",
-    "        item_type: 'artists' or 'tracks'\n",
-    "        time_range: 'short_term' (4 weeks), 'medium_term' (6 months), 'long_term' (several years)\n",
-    "        limit: Number of items to return (1-50)\n",
-    "    \n",
-    "    Returns:\n",
-    "        Dictionary with top items data\n",
-    "    \"\"\"\n",
-    "    token = get_spotify_access_token()\n",
-    "    if not token:\n",
-    "        return {\"error\": \"Failed to get Spotify access token\"}\n",
-    "    \n",
-    "    # Make API request\n",
-    "    url = f\"https://api.spotify.com/v1/me/top/{item_type}\"\n",
-    "    headers = {\n",
-    "        \"Authorization\": f\"Bearer {token}\"\n",
-    "    }\n",
-    "    params = {\n",
-    "        \"time_range\": time_range,\n",
-    "        \"limit\": limit\n",
-    "    }\n",
-    "    \n",
-    "    response = requests.get(url, headers=headers, params=params)\n",
-    "    \n",
-    "    if response.status_code == 200:\n",
-    "        data = response.json()\n",
-    "        \n",
-    "        formatted_items = []\n",
-    "        for idx, item in enumerate(data.get(\"items\", []), 1):\n",
-    "            if item_type == \"artists\":\n",
-    "                formatted_items.append({\n",
-    "                    \"rank\": idx,\n",
-    "                    \"name\": item[\"name\"],\n",
-    "                    \"genres\": item.get(\"genres\", []),\n",
-    "                    \"popularity\": item.get(\"popularity\", 0),\n",
-    "                    \"spotify_url\": item[\"external_urls\"][\"spotify\"]\n",
-    "                })\n",
-    "            else:  # tracks\n",
-    "                formatted_items.append({\n",
-    "                    \"rank\": idx,\n",
-    "                    \"name\": item[\"name\"],\n",
-    "                    \"artist\": item[\"artists\"][0][\"name\"] if item.get(\"artists\") else \"Unknown\",\n",
-    "                    \"album\": item[\"album\"][\"name\"] if item.get(\"album\") else \"Unknown\",\n",
-    "                    \"popularity\": item.get(\"popularity\", 0),\n",
-    "                    \"spotify_url\": item[\"external_urls\"][\"spotify\"]\n",
-    "                })\n",
-    "        \n",
-    "        return {\n",
-    "            \"item_type\": item_type,\n",
-    "            \"time_range\": time_range,\n",
-    "            \"count\": len(formatted_items),\n",
-    "            \"items\": formatted_items\n",
-    "        }\n",
-    "    else:\n",
-    "        return {\"error\": f\"Failed to get top items: {response.status_code} - {response.text}\"}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# lets test the tool\n",
-    "get_user_top_items(item_type=\"artists\", time_range=\"medium_term\", limit=3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "record_user_details_json = {\n",
-    "    \"name\": \"record_user_details\",\n",
-    "    \"description\": \"Use this tool to record that a user is interested in being in touch and provided an email address\",\n",
-    "    \"parameters\": {\n",
-    "        \"type\": \"object\",\n",
-    "        \"properties\": {\n",
-    "            \"email\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"The email address of this user\"\n",
-    "            },\n",
-    "            \"name\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"The user's name, if they provided it\"\n",
-    "            }\n",
-    "            ,\n",
-    "            \"notes\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"Any additional information about the conversation that's worth recording to give context\"\n",
-    "            }\n",
-    "        },\n",
-    "        \"required\": [\"email\"],\n",
-    "        \"additionalProperties\": False\n",
-    "    }\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "get_user_top_items_json = {\n",
-    "    \"name\": \"get_user_top_items\",\n",
-    "    \"description\": \"Get the user's top artists or tracks from Spotify based on their listening history\",\n",
-    "    \"parameters\": {\n",
-    "        \"type\": \"object\",\n",
-    "        \"properties\": {\n",
-    "            \"item_type\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"Type of items to retrieve: 'artists' or 'tracks'\",\n",
-    "                \"enum\": [\"artists\", \"tracks\"]\n",
-    "            },\n",
-    "            \"time_range\": {\n",
-    "                \"type\": \"string\", \n",
-    "                \"description\": \"Time range for the data: 'short_term' (4 weeks), 'medium_term' (6 months), or 'long_term' (several years)\",\n",
-    "                \"enum\": [\"short_term\", \"medium_term\", \"long_term\"]\n",
-    "            },\n",
-    "            \"limit\": {\n",
-    "                \"type\": \"integer\",\n",
-    "                \"description\": \"Number of items to return (1-50)\",\n",
-    "                \"minimum\": 1,\n",
-    "                \"maximum\": 50\n",
-    "            }\n",
-    "        },\n",
-    "        \"required\": [\"item_type\", \"time_range\", \"limit\"],\n",
-    "        \"additionalProperties\": False\n",
-    "    }\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "record_unknown_question_json = {\n",
-    "    \"name\": \"record_unknown_question\",\n",
-    "    \"description\": \"Always use this tool to record any question that couldn't be answered as you didn't know the answer\",\n",
-    "    \"parameters\": {\n",
-    "        \"type\": \"object\",\n",
-    "        \"properties\": {\n",
-    "            \"question\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"The question that couldn't be answered\"\n",
-    "            },\n",
-    "        },\n",
-    "        \"required\": [\"question\"],\n",
-    "        \"additionalProperties\": False\n",
-    "    }\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tools = [{\"type\": \"function\", \"function\": record_user_details_json},\n",
-    "        {\"type\": \"function\", \"function\": record_unknown_question_json},\n",
-    "        {\"type\": \"function\", \"function\": get_user_top_items_json}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tools"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This function can take a list of tool calls, and run them. This is the IF statement!!\n",
-    "\n",
-    "def handle_tool_calls(tool_calls):\n",
-    "    results = []\n",
-    "    for tool_call in tool_calls:\n",
-    "        tool_name = tool_call.function.name\n",
-    "        arguments = json.loads(tool_call.function.arguments)\n",
-    "        print(f\"Tool called: {tool_name}\", flush=True)\n",
-    "\n",
-    "        # THE BIG IF STATEMENT!!!\n",
-    "\n",
-    "        if tool_name == \"record_user_details\":\n",
-    "            result = record_user_details(**arguments)\n",
-    "        elif tool_name == \"record_unknown_question\":\n",
-    "            result = record_unknown_question(**arguments)\n",
-    "        elif tool_name == \"get_user_top_items\":\n",
-    "            result = get_user_top_items(**arguments)\n",
-    "\n",
-    "        results.append({\"role\": \"tool\",\"content\": json.dumps(result),\"tool_call_id\": tool_call.id})\n",
-    "    return results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "globals()[\"record_unknown_question\"](\"this is a really hard question\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This is a more elegant way that avoids the IF statement.\n",
-    "\n",
-    "def handle_tool_calls(tool_calls):\n",
-    "    results = []\n",
-    "    for tool_call in tool_calls:\n",
-    "        tool_name = tool_call.function.name\n",
-    "        arguments = json.loads(tool_call.function.arguments)\n",
-    "        print(f\"Tool called: {tool_name}\", flush=True)\n",
-    "        tool = globals().get(tool_name)\n",
-    "        result = tool(**arguments) if tool else {}\n",
-    "        results.append({\"role\": \"tool\",\"content\": json.dumps(result),\"tool_call_id\": tool_call.id})\n",
-    "    return results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "reader = PdfReader(\"me/linkedin.pdf\")\n",
-    "linkedin = \"\"\n",
-    "for page in reader.pages:\n",
-    "    text = page.extract_text()\n",
-    "    if text:\n",
-    "        linkedin += text\n",
-    "\n",
-    "with open(\"me/summary.txt\", \"r\", encoding=\"utf-8\") as f:\n",
-    "    summary = f.read()\n",
-    "\n",
-    "name = \"Ed Donner\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# We've added a \"If they ask you about your tastes in music you can use your get_user_top_items tool...\" \n",
-    "\n",
-    "system_prompt = f\"You are acting as {name}. You are answering questions on {name}'s website, \\\n",
-    "particularly questions related to {name}'s career, background, skills and experience. \\\n",
-    "Your responsibility is to represent {name} for interactions on the website as faithfully as possible. \\\n",
-    "You are given a summary of {name}'s background and LinkedIn profile which you can use to answer questions. \\\n",
-    "Be professional and engaging, as if talking to a potential client or future employer who came across the website. \\\n",
-    "If they ask you about your tastes in music you can use your get_user_top_items tool to get information about your top artists and tracks. \\\n",
-    "If you don't know the answer to any question, use your record_unknown_question tool to record the question that you couldn't answer, even if it's about something trivial or unrelated to career. \\\n",
-    "If the user is engaging in discussion, try to steer them towards getting in touch via email; ask for their email and record it using your record_user_details tool. \"\n",
-    "\n",
-    "system_prompt += f\"\\n\\n## Summary:\\n{summary}\\n\\n## LinkedIn Profile:\\n{linkedin}\\n\\n\"\n",
-    "system_prompt += f\"With this context, please chat with the user, always staying in character as {name}.\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def chat(message, history):\n",
-    "    messages = [{\"role\": \"system\", \"content\": system_prompt}] + history + [{\"role\": \"user\", \"content\": message}]\n",
-    "    done = False\n",
-    "    while not done:\n",
-    "\n",
-    "        # This is the call to the LLM - see that we pass in the tools json\n",
-    "\n",
-    "        response = openai.chat.completions.create(model=\"gpt-4o-mini\", messages=messages, tools=tools)\n",
-    "\n",
-    "        finish_reason = response.choices[0].finish_reason\n",
-    "        \n",
-    "        # If the LLM wants to call a tool, we do that!\n",
-    "         \n",
-    "        if finish_reason==\"tool_calls\":\n",
-    "            message = response.choices[0].message\n",
-    "            tool_calls = message.tool_calls\n",
-    "            results = handle_tool_calls(tool_calls)\n",
-    "            messages.append(message)\n",
-    "            messages.extend(results)\n",
-    "        else:\n",
-    "            done = True\n",
-    "    return response.choices[0].message.content"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gr.ChatInterface(chat, type=\"messages\").launch()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## And now for deployment\n",
-    "\n",
-    "This code is in `app.py`\n",
-    "\n",
-    "We will deploy to HuggingFace Spaces.\n",
-    "\n",
-    "Before you start: remember to update the files in the \"me\" directory - your LinkedIn profile and summary.txt - so that it talks about you! Also change `self.name = \"Ed Donner\"` in `app.py`..  \n",
-    "\n",
-    "Also check that there's no README file within the 1_foundations directory. If there is one, please delete it. The deploy process creates a new README file in this directory for you.\n",
-    "\n",
-    "1. Visit https://huggingface.co and set up an account  \n",
-    "2. From the Avatar menu on the top right, choose Access Tokens. Choose \"Create New Token\". Give it WRITE permissions - it needs to have WRITE permissions! Keep a record of your new key.  \n",
-    "3. In the Terminal, run: `uv tool install 'huggingface_hub[cli]'` to install the HuggingFace tool, then `hf auth login` to login at the command line with your key. Afterwards, run `hf auth whoami` to check you're logged in  \n",
-    "4. Take your new token and add it to your .env file: `HF_TOKEN=hf_xxx` for the future\n",
-    "5. From the 1_foundations folder, enter: `uv run gradio deploy` \n",
-    "6. Follow its instructions: name it \"career_conversation\", specify app.py, choose cpu-basic as the hardware, say Yes to needing to supply secrets, provide your openai api key, your pushover user and token, and say \"no\" to github actions.  \n",
-    "\n",
-    "Thank you Robert, James, Martins, Andras and Priya for these tips.  \n",
-    "Please read the next 2 sections - how to change your Secrets, and how to redeploy your Space (you may need to delete the README.md that gets created in this 1_foundations directory).\n",
-    "\n",
-    "#### More about these secrets:\n",
-    "\n",
-    "If you're confused by what's going on with these secrets: it just wants you to enter the key name and value for each of your secrets -- so you would enter:  \n",
-    "`OPENAI_API_KEY`  \n",
-    "Followed by:  \n",
-    "`sk-proj-...`  \n",
-    "\n",
-    "And if you don't want to set secrets this way, or something goes wrong with it, it's no problem - you can change your secrets later:  \n",
-    "1. Log in to HuggingFace website  \n",
-    "2. Go to your profile screen via the Avatar menu on the top right  \n",
-    "3. Select the Space you deployed  \n",
-    "4. Click on the Settings wheel on the top right  \n",
-    "5. You can scroll down to change your secrets (Variables and Secrets section), delete the space, etc.\n",
-    "\n",
-    "#### And now you should be deployed!\n",
-    "\n",
-    "If you want to completely replace everything and start again with your keys, you may need to delete the README.md that got created in this 1_foundations folder.\n",
-    "\n",
-    "Here is mine: https://huggingface.co/spaces/ed-donner/Career_Conversation\n",
-    "\n",
-    "I just got a push notification that a student asked me how they can become President of their country 😂😂\n",
-    "\n",
-    "For more information on deployment:\n",
-    "\n",
-    "https://www.gradio.app/guides/sharing-your-app#hosting-on-hf-spaces\n",
-    "\n",
-    "To delete your Space in the future:  \n",
-    "1. Log in to HuggingFace\n",
-    "2. From the Avatar menu, select your profile\n",
-    "3. Click on the Space itself and select the settings wheel on the top right\n",
-    "4. Scroll to the Delete section at the bottom\n",
-    "5. ALSO: delete the README file that Gradio may have created inside this 1_foundations folder (otherwise it won't ask you the questions the next time you do a gradio deploy)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Spotify API Setup Instructions\n",
-    "\n",
-    "To use the Spotify tool in this notebook, you need will need to undergo a one-time setup process to obtain access and refresh tokens from Spotify.  This involve the following steps:\n",
-    "\n",
-    "1. **Create a Spotify App**:\n",
-    "   - Go to https://developer.spotify.com/dashboard\n",
-    "   - Click \"Create app\"\n",
-    "   - Fill in the app details\n",
-    "   - Set Redirect URI to: `https://your-username-your-space-name.hf.space/callback` (replace with your actual HuggingFace Space URL)\n",
-    "   - Save your Client ID and Client Secret\n",
-    "\n",
-    "2. **Add to your `.env` file**:\n",
-    "   ```\n",
-    "   SPOTIFY_CLIENT_ID=your_client_id_here\n",
-    "   SPOTIFY_CLIENT_SECRET=your_client_secret_here\n",
-    "   ```\n",
-    "\n",
-    "3. **Deploy and authenticate**:\n",
-    "   - Deploy the authentication app from the **Flask Authentication App for Spotify** cell below to HuggingFace Spaces\n",
-    "   - Visit your deployed app and click \"Authorize with Spotify\"\n",
-    "   - After authorizing, copy the tokens displayed\n",
-    "   - ONCE YOU HAVE HAVE OBTAINED YOUR ACCESS AND REFRESH TOKESNS YOU CAN DELETE THIS DEPLOYMENT\n",
-    "\n",
-    "4. **Add tokens to .env and reload**:\n",
-    "   ```\n",
-    "   SPOTIFY_ACCESS_TOKEN=your_access_token\n",
-    "   SPOTIFY_REFRESH_TOKEN=your_refresh_token\n",
-    "   ```\n",
-    "   Then run `load_dotenv(override=True)`\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Flask Authentication App for Spotify\n",
-    "\n",
-    "Deploy this code as `spotify_flask_auth.py` to HuggingFace Spaces using Gradio following the steps as above fro\n",
-    "app.py.  You need the following:\n",
-    "1. SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET defined in your environment\n",
-    "2. Need a requirements.txt with Flask listed as a dependency (no other dependencies are needed)\n",
-    "\n",
-    "```python\n",
-    "from flask import Flask, request, redirect, render_template_string\n",
-    "import requests\n",
-    "import base64\n",
-    "import os\n",
-    "from dotenv import load_dotenv\n",
-    "import urllib.parse\n",
-    "import secrets\n",
-    "import string\n",
-    "\n",
-    "load_dotenv(override=True)\n",
-    "\n",
-    "app = Flask(__name__)\n",
-    "app.secret_key = ''.join(secrets.choice(string.ascii_letters + string.digits) for _ in range(32))\n",
-    "\n",
-    "CLIENT_ID = os.getenv(\"SPOTIFY_CLIENT_ID\")\n",
-    "CLIENT_SECRET = os.getenv(\"SPOTIFY_CLIENT_SECRET\")\n",
-    "\n",
-    "REDIRECT_URI = f\"https://{os.getenv('SPACE_HOST')}/callback\"\n",
-    "SCOPE = \"user-top-read\"\n",
-    "tokens = {}\n",
-    "\n",
-    "# HTML template for the home page\n",
-    "HOME_TEMPLATE = \"\"\"\n",
-    "<!DOCTYPE html>\n",
-    "<html>\n",
-    "<head>\n",
-    "    <title>Spotify OAuth Helper</title>\n",
-    "</head>\n",
-    "<body>\n",
-    "    {% if has_credentials %}\n",
-    "        <div style=\"margin-bottom: 20px;\">\n",
-    "            <p>Make sure to add this redirect URI to your Spotify app settings:</p>\n",
-    "            <code>{{ redirect_uri }}</code>\n",
-    "        </div>\n",
-    "        <button onclick=\"window.open('https://accounts.spotify.com/authorize?client_id={{ client_id }}&response_type=code&redirect_uri={{ redirect_uri | urlencode }}&scope={{ scope | urlencode }}&show_dialog=true', '_blank')\">Authorize with Spotify</button>\n",
-    "    {% else %}\n",
-    "        <div>Missing Spotify credentials in .env file</div>\n",
-    "    {% endif %}\n",
-    "</body>\n",
-    "</html>\n",
-    "\"\"\"\n",
-    "\n",
-    "SUCCESS_TEMPLATE = \"\"\"\n",
-    "<!DOCTYPE html>\n",
-    "<html>\n",
-    "<head>\n",
-    "    <title>Spotify OAuth - Success!</title>\n",
-    "</head>\n",
-    "<body>\n",
-    "    <p>Authorization Complete</p>\n",
-    "    <h3>Add to your .env file:</h3>\n",
-    "    <pre>SPOTIFY_ACCESS_TOKEN={{ access_token }}\n",
-    "SPOTIFY_REFRESH_TOKEN={{ refresh_token }}</pre>\n",
-    "</body>\n",
-    "</html>\n",
-    "\"\"\"\n",
-    "\n",
-    "@app.route('/')\n",
-    "def home():\n",
-    "    error = request.args.get('error')\n",
-    "    has_credentials = CLIENT_ID and CLIENT_SECRET\n",
-    "    return render_template_string(HOME_TEMPLATE, error=error, has_credentials=has_credentials, redirect_uri=REDIRECT_URI, client_id=CLIENT_ID, scope=SCOPE)\n",
-    "\n",
-    "@app.route('/authorize')\n",
-    "def authorize():\n",
-    "    \"\"\"Redirect to Spotify authorization\"\"\"\n",
-    "    if not CLIENT_ID:\n",
-    "        return redirect('/?error=Missing SPOTIFY_CLIENT_ID')\n",
-    "    \n",
-    "    auth_url = \"https://accounts.spotify.com/authorize\"\n",
-    "    params = {\n",
-    "        \"client_id\": CLIENT_ID,\n",
-    "        \"response_type\": \"code\",\n",
-    "        \"redirect_uri\": REDIRECT_URI,\n",
-    "        \"scope\": SCOPE,\n",
-    "        \"show_dialog\": \"true\"\n",
-    "    }\n",
-    "    \n",
-    "    url = f\"{auth_url}?{urllib.parse.urlencode(params)}\"\n",
-    "    return redirect(url)\n",
-    "\n",
-    "@app.route('/callback')\n",
-    "def callback():\n",
-    "    \"\"\"Handle the OAuth callback\"\"\"\n",
-    "    error = request.args.get('error')\n",
-    "    if error:\n",
-    "        return redirect(f'/?error=Authorization failed: {error}')\n",
-    "    \n",
-    "    code = request.args.get('code')\n",
-    "    if not code:\n",
-    "        return redirect('/?error=No authorization code received')\n",
-    "    \n",
-    "    # Exchange code for tokens\n",
-    "    token_url = \"https://accounts.spotify.com/api/token\"\n",
-    "    \n",
-    "    credentials = f\"{CLIENT_ID}:{CLIENT_SECRET}\"\n",
-    "    encoded_credentials = base64.b64encode(credentials.encode()).decode()\n",
-    "    \n",
-    "    headers = {\n",
-    "        \"Authorization\": f\"Basic {encoded_credentials}\",\n",
-    "        \"Content-Type\": \"application/x-www-form-urlencoded\"\n",
-    "    }\n",
-    "    \n",
-    "    data = {\n",
-    "        \"grant_type\": \"authorization_code\",\n",
-    "        \"code\": code,\n",
-    "        \"redirect_uri\": REDIRECT_URI\n",
-    "    }\n",
-    "    \n",
-    "    response = requests.post(token_url, headers=headers, data=data)\n",
-    "    \n",
-    "    if response.status_code == 200:\n",
-    "        token_data = response.json()\n",
-    "        tokens['access_token'] = token_data['access_token']\n",
-    "        tokens['refresh_token'] = token_data['refresh_token']\n",
-    "        \n",
-    "        return render_template_string(\n",
-    "            SUCCESS_TEMPLATE,\n",
-    "            access_token=token_data['access_token'],\n",
-    "            refresh_token=token_data['refresh_token']\n",
-    "        )\n",
-    "    else:\n",
-    "        error_msg = response.json().get('error_description', 'Unknown error')\n",
-    "        return redirect(f'/?error=Token exchange failed: {error_msg}')\n",
-    "\n",
-    "if __name__ == '__main__':\n",
-    "    app.run(host='0.0.0.0', port=7860)\n",
-    "```\n",
-    "\n",
-    "**Deployment Instructions:**\n",
-    "1. You will need to provide `SPOTIFY_CLIENT_ID` and `SPOTIFY_CLIENT_SECRET` as secrets in HuggingFace Spaces\n",
-    "2. Create a `requirements.txt` file with a single entry: `Flask`\n",
-    "3. Deploy to HuggingFace Spaces using the instructions in the deployment section below"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">Aside from the obvious (your career alter-ego) this has business applications in any situation where you need an AI assistant with domain expertise and an ability to interact with the real world.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/4_lab4_with_telegram.ipynb

@@ -1,422 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Contributed by Faisal Alkheraiji\n",
-    "\n",
-    "LinkedIn: https://www.linkedin.com/in/faisalalkheraiji/\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## The first big project - Professionally You!\n",
-    "\n",
-    "### And, Tool use.\n",
-    "\n",
-    "### But first: introducing Telegram\n",
-    "\n",
-    "We need to do the following to get out Telegram chatbot working:\n",
-    "\n",
-    "1. Create new telegram bot using @BotFather.\n",
-    "2. Get our bot token.\n",
-    "3. Get your chat ID.\n",
-    "\n",
-    "For easy and quick tutorial, follow this great tutorial from our friend:\n",
-    "\n",
-    "https://chatgpt.com/share/686eccf4-34b0-8000-8f34-a3d9269e0578\n",
-    "\n",
-    "Then add 2 lines to your `.env` file:\n",
-    "\n",
-    "TELEGRAM*BOT_TOKEN=\\_your bot token*\n",
-    "\n",
-    "TELEGRAM*CHAT_ID=\\_your chat ID*\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# imports\n",
-    "\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "import json\n",
-    "import os\n",
-    "import requests\n",
-    "from pypdf import PdfReader\n",
-    "import gradio as gr"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The usual start\n",
-    "\n",
-    "load_dotenv(override=True)\n",
-    "openai = OpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Getting the Telegram bot token and chat ID from environment variables\n",
-    "# You can also replace these with your actual values directly\n",
-    "\n",
-    "TELEGRAM_BOT_TOKEN = os.getenv(\"TELEGRAM_BOT_TOKEN\", \"your_bot_token_here\")\n",
-    "TELEGRAM_CHAT_ID = os.getenv(\"TELEGRAM_CHAT_ID\", \"your_chat_id_here\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def send_telegram_message(text):\n",
-    "    url = f\"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage\"\n",
-    "    payload = {\"chat_id\": TELEGRAM_CHAT_ID, \"text\": text}\n",
-    "\n",
-    "    response = requests.post(url, data=payload)\n",
-    "\n",
-    "    if response.status_code == 200:\n",
-    "        # print(\"Message sent successfully!\")\n",
-    "        return {\"status\": \"success\", \"message\": text}\n",
-    "    else:\n",
-    "        # print(f\"Failed to send message. Status code: {response.status_code}\")\n",
-    "        # print(response.text)\n",
-    "        return {\"status\": \"error\", \"message\": response.text}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Example usage\n",
-    "send_telegram_message(\"Hello from python notebook !!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def record_user_details(email, name=\"Name not provided\", notes=\"not provided\"):\n",
-    "    send_telegram_message(\n",
-    "        f\"Recording interest from {name} with email {email} and notes {notes}\"\n",
-    "    )\n",
-    "    return {\"recorded\": \"ok\"}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def record_unknown_question(question):\n",
-    "    send_telegram_message(f\"Recording {question} asked that I couldn't answer\")\n",
-    "    return {\"recorded\": \"ok\"}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "record_user_details_json = {\n",
-    "    \"name\": \"record_user_details\",\n",
-    "    \"description\": \"Use this tool to record that a user is interested in being in touch and provided an email address\",\n",
-    "    \"parameters\": {\n",
-    "        \"type\": \"object\",\n",
-    "        \"properties\": {\n",
-    "            \"email\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"The email address of this user\",\n",
-    "            },\n",
-    "            \"name\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"The user's name, if they provided it\",\n",
-    "            },\n",
-    "            \"notes\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"Any additional information about the conversation that's worth recording to give context\",\n",
-    "            },\n",
-    "        },\n",
-    "        \"required\": [\"email\"],\n",
-    "        \"additionalProperties\": False,\n",
-    "    },\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "record_unknown_question_json = {\n",
-    "    \"name\": \"record_unknown_question\",\n",
-    "    \"description\": \"Always use this tool to record any question that couldn't be answered as you didn't know the answer\",\n",
-    "    \"parameters\": {\n",
-    "        \"type\": \"object\",\n",
-    "        \"properties\": {\n",
-    "            \"question\": {\n",
-    "                \"type\": \"string\",\n",
-    "                \"description\": \"The question that couldn't be answered\",\n",
-    "            },\n",
-    "        },\n",
-    "        \"required\": [\"question\"],\n",
-    "        \"additionalProperties\": False,\n",
-    "    },\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tools = [\n",
-    "    {\"type\": \"function\", \"function\": record_user_details_json},\n",
-    "    {\"type\": \"function\", \"function\": record_unknown_question_json},\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tools"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This function can take a list of tool calls, and run them. This is the IF statement!!\n",
-    "\n",
-    "\n",
-    "def handle_tool_calls(tool_calls):\n",
-    "    results = []\n",
-    "    for tool_call in tool_calls:\n",
-    "        tool_name = tool_call.function.name\n",
-    "        arguments = json.loads(tool_call.function.arguments)\n",
-    "        print(f\"Tool called: {tool_name}\", flush=True)\n",
-    "\n",
-    "        # THE BIG IF STATEMENT!!!\n",
-    "\n",
-    "        if tool_name == \"record_user_details\":\n",
-    "            result = record_user_details(**arguments)\n",
-    "        elif tool_name == \"record_unknown_question\":\n",
-    "            result = record_unknown_question(**arguments)\n",
-    "\n",
-    "        results.append(\n",
-    "            {\n",
-    "                \"role\": \"tool\",\n",
-    "                \"content\": json.dumps(result),\n",
-    "                \"tool_call_id\": tool_call.id,\n",
-    "            }\n",
-    "        )\n",
-    "    return results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "globals()[\"record_unknown_question\"](\"this is a really hard question\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This is a more elegant way that avoids the IF statement.\n",
-    "\n",
-    "\n",
-    "def handle_tool_calls(tool_calls):\n",
-    "    results = []\n",
-    "    for tool_call in tool_calls:\n",
-    "        tool_name = tool_call.function.name\n",
-    "        arguments = json.loads(tool_call.function.arguments)\n",
-    "        print(f\"Tool called: {tool_name}\", flush=True)\n",
-    "        tool = globals().get(tool_name)\n",
-    "        result = tool(**arguments) if tool else {}\n",
-    "        results.append(\n",
-    "            {\n",
-    "                \"role\": \"tool\",\n",
-    "                \"content\": json.dumps(result),\n",
-    "                \"tool_call_id\": tool_call.id,\n",
-    "            }\n",
-    "        )\n",
-    "    return results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "reader = PdfReader(\"../me/linkedin.pdf\")\n",
-    "linkedin = \"\"\n",
-    "for page in reader.pages:\n",
-    "    text = page.extract_text()\n",
-    "    if text:\n",
-    "        linkedin += text\n",
-    "\n",
-    "with open(\"../me/summary.txt\", \"r\", encoding=\"utf-8\") as f:\n",
-    "    summary = f.read()\n",
-    "\n",
-    "name = \"Ed Donner\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "system_prompt = f\"You are acting as {name}. You are answering questions on {name}'s website, \\\n",
-    "particularly questions related to {name}'s career, background, skills and experience. \\\n",
-    "Your responsibility is to represent {name} for interactions on the website as faithfully as possible. \\\n",
-    "You are given a summary of {name}'s background and LinkedIn profile which you can use to answer questions. \\\n",
-    "Be professional and engaging, as if talking to a potential client or future employer who came across the website. \\\n",
-    "If you don't know the answer to any question, use your record_unknown_question tool to record the question that you couldn't answer, even if it's about something trivial or unrelated to career. \\\n",
-    "If the user is engaging in discussion, try to steer them towards getting in touch via email; ask for their email and record it using your record_user_details tool. \"\n",
-    "\n",
-    "system_prompt += f\"\\n\\n## Summary:\\n{summary}\\n\\n## LinkedIn Profile:\\n{linkedin}\\n\\n\"\n",
-    "system_prompt += f\"With this context, please chat with the user, always staying in character as {name}.\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def chat(message, history):\n",
-    "    messages = (\n",
-    "        [{\"role\": \"system\", \"content\": system_prompt}]\n",
-    "        + history\n",
-    "        + [{\"role\": \"user\", \"content\": message}]\n",
-    "    )\n",
-    "    done = False\n",
-    "    while not done:\n",
-    "        # This is the call to the LLM - see that we pass in the tools json\n",
-    "\n",
-    "        response = openai.chat.completions.create(\n",
-    "            model=\"gpt-4o-mini\", messages=messages, tools=tools\n",
-    "        )\n",
-    "\n",
-    "        finish_reason = response.choices[0].finish_reason\n",
-    "\n",
-    "        # If the LLM wants to call a tool, we do that!\n",
-    "\n",
-    "        if finish_reason == \"tool_calls\":\n",
-    "            message = response.choices[0].message\n",
-    "            tool_calls = message.tool_calls\n",
-    "            results = handle_tool_calls(tool_calls)\n",
-    "            messages.append(message)\n",
-    "            messages.extend(results)\n",
-    "        else:\n",
-    "            done = True\n",
-    "    return response.choices[0].message.content"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gr.ChatInterface(chat, type=\"messages\").launch(inbrowser=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">• First and foremost, deploy this for yourself! It's a real, valuable tool - the future resume..<br/>\n",
-    "            • Next, improve the resources - add better context about yourself. If you know RAG, then add a knowledge base about you.<br/>\n",
-    "            • Add in more tools! You could have a SQL database with common Q&A that the LLM could read and write from?<br/>\n",
-    "            • Bring in the Evaluator from the last lab, and add other Agentic patterns.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../../assets/business.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">Commercial implications</h2>\n",
-    "            <span style=\"color:#00bfff;\">Aside from the obvious (your career alter-ego) this has business applications in any situation where you need an AI assistant with domain expertise and an ability to interact with the real world.\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/Business_Idea.ipynb

@@ -1,388 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Business idea generator and evaluator \n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Start with imports - ask ChatGPT to explain any package that you don't know\n",
-    "\n",
-    "import os\n",
-    "import json\n",
-    "from dotenv import load_dotenv\n",
-    "from openai import OpenAI\n",
-    "from anthropic import Anthropic\n",
-    "from IPython.display import Markdown, display"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Always remember to do this!\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Print the key prefixes to help with any debugging\n",
-    "\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')\n",
-    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
-    "deepseek_api_key = os.getenv('DEEPSEEK_API_KEY')\n",
-    "groq_api_key = os.getenv('GROQ_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set\")\n",
-    "    \n",
-    "if anthropic_api_key:\n",
-    "    print(f\"Anthropic API Key exists and begins {anthropic_api_key[:7]}\")\n",
-    "else:\n",
-    "    print(\"Anthropic API Key not set (and this is optional)\")\n",
-    "\n",
-    "if google_api_key:\n",
-    "    print(f\"Google API Key exists and begins {google_api_key[:2]}\")\n",
-    "else:\n",
-    "    print(\"Google API Key not set (and this is optional)\")\n",
-    "\n",
-    "if deepseek_api_key:\n",
-    "    print(f\"DeepSeek API Key exists and begins {deepseek_api_key[:3]}\")\n",
-    "else:\n",
-    "    print(\"DeepSeek API Key not set (and this is optional)\")\n",
-    "\n",
-    "if groq_api_key:\n",
-    "    print(f\"Groq API Key exists and begins {groq_api_key[:4]}\")\n",
-    "else:\n",
-    "    print(\"Groq API Key not set (and this is optional)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request = (\n",
-    "    \"Please generate three innovative business ideas aligned with the latest global trends. \"\n",
-    "    \"For each idea, include a brief description (2–3 sentences).\"\n",
-    ")\n",
-    "messages = [{\"role\": \"user\", \"content\": request}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "openai = OpenAI()\n",
-    "'''\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"gpt-4o-mini\",\n",
-    "    messages=messages,\n",
-    ")\n",
-    "question = response.choices[0].message.content\n",
-    "print(question)\n",
-    "'''"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "competitors = []\n",
-    "answers = []\n",
-    "#messages = [{\"role\": \"user\", \"content\": question}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# The API we know well\n",
-    "\n",
-    "model_name = \"gpt-4o-mini\"\n",
-    "\n",
-    "response = openai.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Anthropic has a slightly different API, and Max Tokens is required\n",
-    "\n",
-    "model_name = \"claude-3-7-sonnet-latest\"\n",
-    "\n",
-    "claude = Anthropic()\n",
-    "response = claude.messages.create(model=model_name, messages=messages, max_tokens=1000)\n",
-    "answer = response.content[0].text\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gemini = OpenAI(api_key=google_api_key, base_url=\"https://generativelanguage.googleapis.com/v1beta/openai/\")\n",
-    "model_name = \"gemini-2.0-flash\"\n",
-    "\n",
-    "response = gemini.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "deepseek = OpenAI(api_key=deepseek_api_key, base_url=\"https://api.deepseek.com/v1\")\n",
-    "model_name = \"deepseek-chat\"\n",
-    "\n",
-    "response = deepseek.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "groq = OpenAI(api_key=groq_api_key, base_url=\"https://api.groq.com/openai/v1\")\n",
-    "model_name = \"llama-3.3-70b-versatile\"\n",
-    "\n",
-    "response = groq.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!ollama pull llama3.2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ollama = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')\n",
-    "model_name = \"llama3.2\"\n",
-    "\n",
-    "response = ollama.chat.completions.create(model=model_name, messages=messages)\n",
-    "answer = response.choices[0].message.content\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "competitors.append(model_name)\n",
-    "answers.append(answer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# So where are we?\n",
-    "\n",
-    "print(competitors)\n",
-    "print(answers)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# It's nice to know how to use \"zip\"\n",
-    "for competitor, answer in zip(competitors, answers):\n",
-    "    print(f\"Competitor: {competitor}\\n\\n{answer}\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Let's bring this together - note the use of \"enumerate\"\n",
-    "\n",
-    "together = \"\"\n",
-    "for index, answer in enumerate(answers):\n",
-    "    together += f\"# Response from competitor {index+1}\\n\\n\"\n",
-    "    together += answer + \"\\n\\n\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(together)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge = f\"\"\"You are judging a competition between {len(competitors)} competitors.\n",
-    "Each model was asked to generate three innovative business ideas aligned with the latest global trends.\n",
-    "\n",
-    "Your job is to evaluate the likelihood of success for each idea on a scale from 0 to 100 percent. For each competitor, list the three percentages in the same order as their ideas.\n",
-    "\n",
-    "Respond only with JSON in this format:\n",
-    "{{\"results\": [\n",
-    "    {{\"competitor\": 1, \"success_chances\": [perc1, perc2, perc3]}},\n",
-    "    {{\"competitor\": 2, \"success_chances\": [perc1, perc2, perc3]}},\n",
-    "    ...\n",
-    "]}}\n",
-    "\n",
-    "Here are the ideas from each competitor:\n",
-    "\n",
-    "{together}\n",
-    "\n",
-    "Now respond with only the JSON, nothing else.\"\"\"\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(judge)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "judge_messages = [{\"role\": \"user\", \"content\": judge}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Judgement time!\n",
-    "\n",
-    "openai = OpenAI()\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"o3-mini\",\n",
-    "    messages=judge_messages,\n",
-    ")\n",
-    "results = response.choices[0].message.content\n",
-    "print(results)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Parse judge results JSON and display success probabilities\n",
-    "results_dict = json.loads(results)\n",
-    "for entry in results_dict[\"results\"]:\n",
-    "    comp_num = entry[\"competitor\"]\n",
-    "    comp_name = competitors[comp_num - 1]\n",
-    "    chances = entry[\"success_chances\"]\n",
-    "    print(f\"{comp_name}:\")\n",
-    "    for idx, perc in enumerate(chances, start=1):\n",
-    "        print(f\"  Idea {idx}: {perc}% chance of success\")\n",
-    "    print()\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

community_contributions/ChatBot_with_evaluator_and_notifier/README.md

@@ -1,97 +0,0 @@
-# Smart RAG Chatbot
-
-A conversational AI that answers questions from your documents first, then falls back to general knowledge when needed. Plus, it keeps you in the loop with smart notifications.
-
-## What it does
-
-Think of it as your personal AI assistant that:
-- **Knows your stuff** - Searches your documents first to answer questions
-- **Stays helpful** - Uses general AI knowledge when your docs don't have the answer  
-- **Keeps you informed** - Sends notifications when it goes beyond your knowledge base
-- **Remembers conversations** - Maintains chat history and user details
-
-## How it works
-
-1. User asks a question
-2. System searches your documents in `knowledge_base/`
-3. **Found answer?** → Uses your docs and responds
-4. **No answer?** → Uses general AI knowledge + sends you a notification
-5. **Small talk?** → Quick friendly response
-
-## Architecture
-
-```
-User Question → Search Your Docs → ChatGPT Response → Gemini Quality Check
-                     ↓                                        ↓
-              If no relevant docs                    If using general knowledge
-                     ↓                                        ↓
-              General AI Knowledge ← ← ← ← ← ← ← ← Pushover Notification
-```
-
-**Components:**
-- **ChromaDB + LangChain**: Stores and searches your documents
-- **ChatGPT**: Generates responses
-- **Gemini**: Checks response quality  
-- **Pushover**: Sends notifications
-- **Gradio**: Simple web interface
-
-## Quick Setup
-
-1. **Install dependencies:**
-```bash
-pip install -r requirements.txt
-```
-
-2. **Create `.env` file with your API keys:**
-```bash
-OPENAI_API_KEY=your_openai_key
-GOOGLE_API_KEY=your_gemini_key
-PUSHOVER_USER=your_pushover_user  # optional
-PUSHOVER_TOKEN=your_pushover_token  # optional
-```
-
-3. **Add your documents:**
-Drop your `.txt`, `.md`, or `.markdown` files into the `knowledge_base/` folder
-
-4. **Launch:**
-```bash
-python app.py
-```
-
-That's it! The web interface opens automatically.
-
-## Key Features
-
-- **Smart fallback**: Uses your docs first, general knowledge second
-- **Quality control**: Built-in evaluator ensures good responses
-- **Conversation memory**: Remembers chat history and user details
-- **Smart notifications**: Only alerts when using general knowledge
-- **Simple setup**: Just API keys and documents
-
-## File Structure
-
-```
-├── app.py              # Web interface
-├── controller.py       # Main logic
-├── rag.py             # Document search
-├── evaluator.py       # Quality checking
-├── tools.py           # Notifications
-├── knowledge_base/    # Your documents
-└── .env               # API keys
-```
-
-## Example Usage
-
-**Question about your docs:**
-```
-User: "What's our return policy?"
-Bot: [Searches your docs] → [Finds policy] → [Answers from your content]
-```
-
-**General question:**
-```
-User: "What is machine learning?"
-Bot: [No docs found] → [Uses AI knowledge] → [Sends notification] → [Helpful explanation]
-```
-
-Built with ChromaDB, LangChain, OpenAI, Gemini, and Gradio.

community_contributions/ChatBot_with_evaluator_and_notifier/app.py

@@ -1,30 +0,0 @@
-import gradio as gr
-from controller import ChatbotController
-
-controller = ChatbotController()
-
-def respond(user_msg, history, recorded_emails_state):
-    history.append({"role": "user", "content": user_msg})
-    reply, emails = controller.get_response(
-        message=user_msg,
-        history=history,
-        name=None,
-        email=None,
-        recorded_emails=set(recorded_emails_state or []),
-    )
-    history.append({"role": "assistant", "content": reply})
-    return history, history, list(emails)
-
-with gr.Blocks(title="RAG Chat") as demo:
-    chat = gr.Chatbot(type="messages", min_height=600, label="Assistant")
-    msg = gr.Textbox(label="Your message", placeholder="Type here…")
-    history_state = gr.State([])
-    processed_emails_state = gr.State([])
-    msg.submit(
-        respond,
-        inputs=[msg, history_state, processed_emails_state],
-        outputs=[chat, history_state, processed_emails_state],
-    )
-    msg.submit(lambda: "", None, msg)
-
-demo.launch(inbrowser=True)

community_contributions/ChatBot_with_evaluator_and_notifier/career_db/6aee01b9-a616-491d-a196-c857cd862793/data_level0.bin

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ea9ac6972cb4666769a17755f17c5727f676f11a742e9553bf3a21119ab54394
-size 167600

community_contributions/ChatBot_with_evaluator_and_notifier/career_db/6aee01b9-a616-491d-a196-c857cd862793/header.bin

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a0e81c3b22454233bc12d0762f06dcca48261a75231cf87c79b75e69a6c00150
-size 100

community_contributions/ChatBot_with_evaluator_and_notifier/career_db/6aee01b9-a616-491d-a196-c857cd862793/length.bin

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7a12e561363385e9dfeeab326368731c030ed4b374e7f5897ac819159d2884c5
-size 400

community_contributions/ChatBot_with_evaluator_and_notifier/career_db/chroma.sqlite3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:460534870e395f01413300a55f0ee89062d0ffa8102796eb6365b15c8c2b0063
-size 1597440

community_contributions/ChatBot_with_evaluator_and_notifier/chat.py

@@ -1,45 +0,0 @@
-import os
-import json
-from typing import List, Dict, Any
-from openai import OpenAI
-from dotenv import load_dotenv
-
-
-load_dotenv(override=True)
-
-MODEL = "gpt-4o-mini"
-
-
-class ChatGPTLLM:
-    def __init__(self, model: str = MODEL):
-        load_dotenv(override=True)
-        self.model = model
-        self.client = OpenAI()
-
-    def format_context_prompt(self, query: str, context: List[str]) -> str:
-        joined = "\n\n".join(context) if context else "(no context)"
-        return (
-            "You are a careful, concise assistant. Use ONLY the Context below.\n"
-            "If the answer is not present in the Context, reply exactly: I don't know.\n"
-            "Do not add external knowledge or speculate.\n\n"
-            f"Context:\n{joined}\n\n"
-            f"Question: {query}\n"
-            "Answer succinctly in 1-3 sentences."
-        )
-
-    def generate_response(self, query: str, context: List[str]) -> Dict[str, Any]:
-        try:
-            prompt = self.format_context_prompt(query, context)
-            messages = [
-                {"role": "system", "content": "Answer only from provided Context."},
-                {"role": "user", "content": prompt},
-            ]
-            resp = self.client.chat.completions.create(
-                model=self.model,
-                messages=messages
-            )
-            content = resp.choices[0].message.content
-            return {"text": content or "", "raw": json.loads(resp.model_dump_json())}
-        except Exception as e:
-            print(f"[llm1] error: {e}")
-            return {"error": str(e), "text": ""}

community_contributions/ChatBot_with_evaluator_and_notifier/controller.py

@@ -1,304 +0,0 @@
-import os
-import re
-from typing import List, Tuple, Set
-from dotenv import load_dotenv
-from langchain_openai import ChatOpenAI
-from langchain.schema import SystemMessage, HumanMessage, AIMessage
-from rag import get_retriever, ingest as ingest_docs
-from evaluator import GeminiEvaluator
-from tools import notify
-
-OPENAI_MODEL = os.environ.get("OPENAI_MODEL", "gpt-4o-mini")
-DISCLAIMER = "This info does not exist in our DB, but according to your input this is your output: "
-
-# --- Cursor Implementation Prompt: Minimal LLM and Evaluator functions ---
-
-def LLM(user_input, db_retrieved, history):
-    """
-    Builds a comprehensive prompt using user input, retrieved context, and chat history,
-    then calls the OpenAI chat model (via LangChain ChatOpenAI) to generate a response.
-    """
-    load_dotenv(override=True)
-    model = os.environ.get("OPENAI_MODEL", "gpt-4o-mini")
-    llm = ChatOpenAI(model=model, temperature=0.2)
-
-    context_text = "\n\n".join(db_retrieved if isinstance(db_retrieved, list) else [str(db_retrieved)])
-    history_text = str(history or [])
-    system = (
-        "Answer using ONLY the provided DB retrieval and keep consistency with the chat history. "
-        "If the retrieval does not contain the answer, reply: I am unsure."
-    )
-    user = (
-        f"This is the user input: {user_input}\n\n"
-        f"This is the db_retrieval: {context_text}\n\n"
-        f"This is the history of chat: {history_text}\n\n"
-        "Based on these, generate a comprehensive response that answers the user's question using the retrieved context and maintaining consistency with chat history."
-    )
-    reply = llm.invoke([SystemMessage(content=system), HumanMessage(content=user)]).content
-    return reply.strip() if reply else ""
-
-
-def _token_set(text: str) -> set:
-    t = (text or "").lower()
-    t = re.sub(r"[^a-z0-9\s]", " ", t)
-    return {w for w in t.split() if w}
-
-
-def Evaluator(user_input, db_retrieved, llm_response, history):
-    """
-    Simple, deterministic evaluator returning metric scores and a pass/fail decision.
-    Uses lexical overlap heuristics; values are in [0,1].
-    """
-    db_text = "\n\n".join(db_retrieved if isinstance(db_retrieved, list) else [str(db_retrieved)])
-    q_set = _token_set(user_input)
-    db_set = _token_set(db_text)
-    r_set = _token_set(llm_response)
-    h_text = str(history or [])
-    h_set = _token_set(h_text)
-
-    def jaccard(a: set, b: set) -> float:
-        if not a or not b:
-            return 0.0
-        inter = len(a & b)
-        union = len(a | b)
-        return inter / union if union else 0.0
-
-    relevance = jaccard(q_set, r_set)
-    accuracy = jaccard(db_set, r_set)
-    consistency = 1.0 if jaccard(h_set, r_set) >= 0.1 or not h_set else jaccard(h_set, r_set)
-    completeness = min(1.0, (len(llm_response) / 300.0)) if accuracy >= 0.2 else 0.3
-    faithfulness = accuracy
-
-    overall = max(0.0, min(1.0, 0.3 * relevance + 0.3 * accuracy + 0.15 * completeness + 0.15 * consistency + 0.1 * faithfulness))
-    passed = overall >= 0.7
-
-    feedback_parts = []
-    if relevance < 0.5:
-        feedback_parts.append("Improve focus on the user's question.")
-    if accuracy < 0.5:
-        feedback_parts.append("Cite or use details from the retrieved context more precisely.")
-    if completeness < 0.7:
-        feedback_parts.append("Add missing details supported by context.")
-    if consistency < 0.6:
-        feedback_parts.append("Ensure alignment with prior conversation.")
-    if faithfulness < 0.7:
-        feedback_parts.append("Avoid claims not supported by retrieved context.")
-    if not feedback_parts:
-        feedback_parts.append("Good response: relevant, accurate, and grounded.")
-
-    return {
-        "relevance": round(relevance, 3),
-        "accuracy": round(accuracy, 3),
-        "completeness": round(completeness, 3),
-        "consistency": round(consistency, 3),
-        "faithfulness": round(faithfulness, 3),
-        "overall": round(overall, 3),
-        "passed": passed,
-        "feedback": " ".join(feedback_parts),
-    }
-
-class ChatbotController:
-    def __init__(self):
-        load_dotenv(override=True)
-        self.llm = ChatOpenAI(model=OPENAI_MODEL, temperature=0.2)
-        self.evaluator = GeminiEvaluator()
-        self._smalltalk_patterns = [
-            (re.compile(r"^(hi|hello|hey|yo)\b", re.I), "Hello! How can I help today?"),
-            (re.compile(r"how\s+are\s+you\b", re.I), "I'm doing well, thanks for asking. How can I help?"),
-            (re.compile(r"(good\s+(morning|afternoon|evening))\b", re.I), "Hello! How can I help?"),
-            (re.compile(r"\b(thank(s)?|thanks a lot|ty)\b", re.I), "You're welcome!"),
-            (re.compile(r"\b(bye|goodbye|see\s+you)\b", re.I), "Goodbye!"),
-            (re.compile(r"tell\s+me\s+a\s+joke", re.I), "Why did the developer go broke? Because they used up all their cache."),
-            (re.compile(r"\b(help|what\s+can\s+you\s+do)\b", re.I), "I can answer questions based on our knowledge base or just chat!"),
-        ]
-
-    def ingest(self, data_dir: str = None) -> str:
-        return ingest_docs(data_dir) if data_dir else ingest_docs()
-
-    def _extract_emails(self, text: str) -> Set[str]:
-        return set(re.findall(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}", text or ""))
-
-    def _extract_name(self, text: str) -> str | None:
-        t = (text or "").strip()
-        m = re.search(r"\bmy name is\s+([A-Z][a-zA-Z'.-]{1,40}(\s+[A-Z][a-zA-Z'.-]{1,40}){0,2})\b", t, re.I)
-        if m:
-            return m.group(1).strip()
-        m = re.search(r"\bi am\s+([A-Z][a-zA-Z'.-]{1,40}(\s+[A-Z][a-zA-Z'.-]{1,40}){0,2})\b", t, re.I)
-        if m:
-            return m.group(1).strip()
-        m = re.search(r"\bthis is\s+([A-Z][a-zA-Z'.-]{1,40}(\s+[A-Z][a-zA-Z'.-]{1,40}){0,2})\b", t, re.I)
-        if m:
-            return m.group(1).strip()
-        return None
-
-    def _extract_emails_from_conversation(self, current_message: str, history: List[dict]) -> Set[str]:
-        all_emails = set()
-        
-        # Extract from current message
-        all_emails.update(self._extract_emails(current_message))
-        
-        # Extract from chat history (user messages only)
-        for msg in (history or []):
-            if msg.get("role") == "user":
-                content = msg.get("content", "")
-                all_emails.update(self._extract_emails(content))
-        
-        return all_emails
-
-    def _extract_name_from_conversation(self, current_message: str, history: List[dict]) -> str | None:
-        # First try current message
-        name = self._extract_name(current_message)
-        if name:
-            return name
-        
-        # Then search through chat history (user messages only, most recent first)
-        for msg in reversed(history or []):
-            if msg.get("role") == "user":
-                content = msg.get("content", "")
-                name = self._extract_name(content)
-                if name:
-                    return name
-        
-        return None
-
-    def _build_prompt(self, q, hits) -> Tuple[str, str]:
-        ctx = "\n\n".join([f"[Doc {i+1}]\n{d.page_content}" for i, d in enumerate(hits)])
-        sys = (
-            "You are a concise assistant. Answer ONLY using the provided Context. "
-            "If the Context does not contain the answer, reply exactly: 'I am unsure'. "
-            "Do not invent facts or pull from outside knowledge."
-        )
-        prompt = (
-            f"User Question:\n{q}\n\n"
-            f"Context (Top {len(hits)}):\n{ctx}\n\n"
-            "Provide a short, direct answer grounded in the Context."
-        )
-        return sys, prompt
-
-    def _build_conversation_with_history(self, current_message: str, history: List[dict], include_context: bool = False, context_chunks: List[str] = None):
-        messages = []
-        
-        if include_context and context_chunks:
-            # RAG mode with context
-            ctx = "\n\n".join([f"[Doc {i+1}]\n{chunk}" for i, chunk in enumerate(context_chunks)])
-            system_msg = (
-                "You are a helpful assistant. Use the provided Context to answer questions accurately. "
-                "If the Context doesn't contain the answer, say 'I am unsure'. "
-                "Maintain conversation continuity and refer to previous messages when relevant.\n\n"
-                f"Context:\n{ctx}"
-            )
-        else:
-            # General mode without context
-            system_msg = (
-                "You are a helpful, practical, and concise assistant. "
-                "Maintain conversation continuity and refer to previous messages when relevant."
-            )
-        
-        messages.append(SystemMessage(content=system_msg))
-        
-        # Add recent history (last 10 messages to avoid token limits)
-        recent_history = (history or [])[-10:] if history else []
-        for msg in recent_history:
-            role = msg.get("role", "")
-            content = msg.get("content", "")
-            if role == "user":
-                messages.append(HumanMessage(content=content))
-            elif role == "assistant":
-                messages.append(AIMessage(content=content))
-        
-        # Add current message
-        messages.append(HumanMessage(content=current_message))
-        
-        return messages
-
-    def _smalltalk_reply(self, text: str):
-        s = (text or "").strip()
-        if not s:
-            return None
-        for pattern, reply in self._smalltalk_patterns:
-            if pattern.search(s):
-                return reply
-        return None
-
-    def _is_conversational(self, text: str) -> bool:
-        t = (text or "").strip().lower()
-        conversational_phrases = [
-            "how are you",
-            "what's up",
-            "whats up",
-            "tell me a joke",
-            "what do you think",
-            "your opinion",
-            "talk to me",
-            "let's chat",
-            "lets chat",
-            "who are you",
-            "help",
-            "thank you",
-            "thanks",
-            "good morning",
-            "good evening",
-        ]
-        return any(p in t for p in conversational_phrases)
-
-    def get_response(self, message: str, history: List[dict], name: str = None, email: str = None, recorded_emails: Set[str] = None):
-        quick = self._smalltalk_reply(message)
-        if quick is not None:
-            ans = quick
-            found_emails = self._extract_emails_from_conversation(message, history)
-            if email:
-                found_emails.add(email)
-            seen = recorded_emails or set()
-            new_seen = seen | found_emails
-            return ans or "Hello!", new_seen
-        retriever = get_retriever()
-        hits = retriever.get_relevant_documents(message)
-        context_chunks = [d.page_content for d in hits]
-        
-        # Check if context is actually relevant using a quick relevance test
-        if context_chunks:
-            context_text = " ".join(context_chunks)
-            relevance_prompt = f"Does this context contain information relevant to answering: '{message}'?\nContext: {context_text[:500]}...\nAnswer only YES or NO."
-            relevance_check = self.llm.invoke([HumanMessage(content=relevance_prompt)]).content.strip().upper()
-            context_is_relevant = "YES" in relevance_check
-        else:
-            context_is_relevant = False
-            
-        if not context_chunks or not context_is_relevant:
-            # No RAG support or irrelevant context → allow general LLM answer with history
-            messages = self._build_conversation_with_history(message, history, include_context=False)
-            ans = self.llm.invoke(messages).content.strip()
-            decision = self.evaluator.evaluate_no_context(message, ans)
-            # Mark this as needing notification since we used general LLM knowledge
-            decision["used_general_knowledge"] = True
-        else:
-            # RAG response with history
-            messages = self._build_conversation_with_history(message, history, include_context=True, context_chunks=context_chunks)
-            ans = self.llm.invoke(messages).content.strip()
-            decision = self.evaluator.evaluate_response(message, context_chunks, ans)
-            decision["used_general_knowledge"] = False
-        found_emails = self._extract_emails_from_conversation(message, history)
-        if email:
-            found_emails.add(email)
-        found_name = name or self._extract_name_from_conversation(message, history)
-        seen = recorded_emails or set()
-        new_seen = seen | found_emails
-        # Check if we used general knowledge and should send notification
-        if decision.get("used_general_knowledge") and ans and ans.lower() != "i am unsure":
-            if self._is_conversational(message):
-                return ans, new_seen
-            fields = []
-            if found_name:
-                fields.append(f"name={found_name}")
-            if found_emails:
-                fields.append(f"emails={','.join(sorted(found_emails))}")
-            meta = (" | ".join(fields) + " | ") if fields else ""
-            title = "RAG missing knowledge"
-            message_payload = f"{meta}question={message}"
-            notify(title, message_payload)
-            return ans, new_seen
-        
-        if decision.get("decision") == "APPROVED":
-            return ans or "i am unsure", new_seen
-        
-        return "Insufficient support in our DB.", new_seen

community_contributions/ChatBot_with_evaluator_and_notifier/evaluator.py

@@ -1,108 +0,0 @@
-from pydantic import BaseModel, Field, ValidationError
-from openai import OpenAI
-from dotenv import load_dotenv
-import os
-import json
-from typing import List, Dict, Any
-
-
-GEMINI_MODEL = "gemini-2.0-flash"
-
-
-class GeminiEvaluator:
-    def __init__(self, model: str = GEMINI_MODEL):
-        load_dotenv(override=True)
-        google_api_key = os.getenv('GOOGLE_API_KEY')
-        self.client = OpenAI(api_key=google_api_key, base_url="https://generativelanguage.googleapis.com/v1beta/openai/")
-        self.model = model
-
-    def create_evaluation_prompt(self, query: str, context: List[str], response: str) -> str:
-        ctx = "\n- " + "\n- ".join(context) if context else "(no context retrieved)"
-        return (
-            "You are a strict evaluator. Decide if the Response is supported by the Context.\n"
-            "Rules:\n"
-            "- If the key facts of the Response are not present in the Context and Context is empty, mark REJECTED and set has_external_info=True.\n"
-            "- If partially supported but missing crucial facts, mark REJECTED.\n"
-            "- Otherwise APPROVED.\n"
-            "Return ONLY a compact JSON with keys: decision, confidence, reason, has_external_info.\n"
-            "Respond with JSON only, no prose.\n\n"
-            f"Context:\n{ctx}\n\n"
-            f"Query: {query}\n"
-            f"Response: {response}\n"
-        )
-
-    def evaluate_response(self, query: str, context: List[str], llm_response: str) -> Dict[str, Any]:
-        try:
-            prompt = self.create_evaluation_prompt(query, context, llm_response)
-            messages = [
-                {"role": "system", "content": "Return strict JSON only."},
-                {"role": "user", "content": prompt},
-            ]
-            resp = self.client.chat.completions.create(model=self.model, messages=messages, temperature=0)
-            text = resp.choices[0].message.content or "{}"
-            start = text.find("{")
-            end = text.rfind("}")
-            blob = text[start:end+1] if start != -1 and end != -1 else "{}"
-            data = json.loads(blob)
-
-            class EvaluationResult(BaseModel):
-                decision: str = Field(pattern=r"^(APPROVED|REJECTED)$")
-                confidence: int = Field(ge=0, le=100)
-                reason: str
-                has_external_info: bool = False
-
-            try:
-                # normalize decision before validation
-                if "decision" in data:
-                    data["decision"] = str(data["decision"]).upper()
-                validated = EvaluationResult(**{
-                    "decision": data.get("decision", "REJECTED"),
-                    "confidence": int(data.get("confidence", 50)),
-                    "reason": data.get("reason", ""),
-                    "has_external_info": bool(data.get("has_external_info", False)),
-                })
-                return validated.model_dump()
-            except ValidationError as ve:
-                print(f"[evaluator] validation error: {ve}")
-                return {"decision": "REJECTED", "confidence": 0, "reason": "validation_error", "has_external_info": False}
-        except Exception as e:
-            print(f"[evaluator] error: {e}")
-            return {"decision": "REJECTED", "confidence": 0, "reason": str(e), "has_external_info": False}
-
-    def evaluate_no_context(self, query: str, llm_response: str) -> Dict[str, Any]:
-        try:
-            prompt = (
-                "You are a strict evaluator. There is NO database context for this query.\n"
-                "Evaluate how well the Response addresses the Query in terms of relevance, helpfulness and clarity.\n"
-                "Return ONLY JSON with keys: decision (APPROVED|REJECTED), confidence (0-100), reason, has_external_info (true).\n\n"
-                f"Query: {query}\n"
-                f"Response: {llm_response}\n"
-            )
-            messages = [
-                {"role": "system", "content": "Return strict JSON only."},
-                {"role": "user", "content": prompt},
-            ]
-            resp = self.client.chat.completions.create(model=self.model, messages=messages, temperature=0)
-            text = resp.choices[0].message.content or "{}"
-            start = text.find("{")
-            end = text.rfind("}")
-            blob = text[start:end+1] if start != -1 and end != -1 else "{}"
-            data = json.loads(blob)
-
-            def _coerce_conf(v):
-                try:
-                    return max(0, min(100, int(float(v))))
-                except Exception:
-                    return 50
-
-            decision = str(data.get("decision", "APPROVED")).upper()
-            return {
-                "decision": "APPROVED" if decision == "APPROVED" else "REJECTED",
-                "confidence": _coerce_conf(data.get("confidence", 75)),
-                "reason": data.get("reason", "no_context"),
-                "has_external_info": True,
-            }
-        except Exception as e:
-            # Heuristic fallback when model errors
-            rel = 1.0 if (query and llm_response and query.split()[0].lower() in (llm_response or "").lower()) else 0.5
-            return {"decision": "APPROVED" if rel >= 0.5 else "REJECTED", "confidence": int(rel * 100), "reason": "fallback_no_context", "has_external_info": True}

community_contributions/ChatBot_with_evaluator_and_notifier/knowledge_base/summary.txt

@@ -1,499 +0,0 @@
-San José State University
-
-Former name	Minns' Evening Normal School (1857–1862)
-California State Normal School (1862–1921)
-San Jose State Teachers College (1921–1935)
-San Jose State College (1935–1972)
-California State University, San Jose (1972–1974)
-Motto	"Powering Silicon Valley"
-Type	Public research university
-Established	1857; 168 years ago
-Founder	George W. Minns
-Parent institution	California State University
-Accreditation	WSCUC
-Academic affiliations	
-USUSpace-grant
-Endowment	$242 million (2024–25)[1]
-Budget	$481.8 million (2023–24)[2]
-President	Cynthia Teniente-Matson
-Provost	Vincent Del Casino[3]
-Academic staff	2,177 (Fall 2024)[4]
-Administrative staff	1,424 (Fall 2022)[4]
-Students	37,661 (Fall 2024)[5]
-Undergraduates	27,354 (Fall 2024)[5]
-Postgraduates	5,468 (Fall 2024)[5]
-Location	San Jose, California, U.S.
-37°20′07″N 121°52′53″W
-Campus	Large city[6], 154 acres (62 ha) on main campus and 62 acres (25 ha) on south campus
-Newspaper	The Spartan Daily
-Colors	Blue and gold[7]
-   
-Nickname	Spartans
-Sporting affiliations	
-NCAA Division I FBS - Mountain WestWACMPSFWCC
-Mascot	Sammy Spartan
-Website	www.sjsu.edu Edit this at Wikidata
-
-Map
-Wikimedia | © OpenStreetMap
-Show zoomed in
-Show zoomed midway
-Show zoomed out
-Show all
-California Historical Landmark
-Official name	First Normal School in California (San Jose State College)
-Designated	1/6/1949
-Reference no.	417[8]
-San José State University (San Jose State or SJSU) is a public research university in San Jose, California. Established in 1857 as the state's first normal school, it is the oldest public university in the western United States[9] and is the founding campus of the California State University system.[10][11]
-
-Located in downtown San Jose, San Jose State's main campus spans 154 acres (62 ha), or roughly 19 square blocks. It is accredited by the WASC Senior College and University Commission[12] and is classified among "R2: High Research Spending and Doctorate Production".[13] It is a federally-designated Hispanic-Serving Institution as well as an Asian American and Native American Pacific Islander-Serving Institution.[14]
-
-SJSU comprises nine academic colleges, who offer over 250 undergraduate and graduate degree programs.[15] Its enrollment is about 37,000 students annually, including around 28,000 undergraduate and 9,000 graduate and professional students.[5] As of fall 2022, graduate student enrollment, Asian, and international student enrollments at SJSU were the highest of any campus in the CSU system.[5]
-
-San Jose State's sports teams compete as the Spartans in the NCAA Division I Mountain West Conference and have won 10 team national championships and 50 individual national championships. SJSU athletes have competed in every Olympics since 1948 and have amassed 21 medals.[16]
-
-History
-Main article: History of San Jose State University
-
-Dashaway Hall, one of six sites in San Francisco that housed the State Normal School before a permanent location was chosen in San Jose.[17]
-Establishment
-After a private normal school closed in San Francisco after only one year, politicians John Swett and Henry B. Janes sought to establish a normal school for San Francisco's public school system, and approached George W. Minns to be the principal for the nascent institution[18][19] The normal school began operations in 1857 and became known as the Minns Evening Normal School. Classes were only held once a week, and only graduated 54 female students across its existence, however the program proved to be enough of a success for increased funding to be approved.[10]
-
-In 1861, after the continued success of the Evening School, a committee was formed to create a report on the merits of fully funding a state normal school and presented its report to the California State Legislator in January 1862. On May 2, 1862, the California State Senate elected to fund a state normal school and to appoint a board of trustees.[20] The California State Normal School was then opened on July 21, 1862.[21]
-
-Despite continued success, with increasing enrollment and funding, the California State Normal School quickly began to hold contention with the San Francisco Board of Education, which poached students and withheld sufficient school facilities.[22] Because of these issues, the Normal School moved sites six times while in San Francisco, citing noise complaints, sanitary concerns, and lack of access to proper facilities and materials.[23]
-
-In 1868, more serious talks of finding a permanent location for the Normal School began, with a general consensus that the school needed to cut ties with the San Francisco Board of Education and move out of San Francisco. After it became public that the Normal School was looking to move for a permanent location, several cities put in bids to home the school, however after the San Jose Railroad Company paid to have the entire student and faculty body tour the city and potential locations for the school, San Jose became the preferred site.[24] The school moved to San Jose in 1871 and was given Washington Square Park at S. 4th and San Carlos Streets, where the campus remains to this day.[25]
-
-
-The first building on Washington Square, which was destroyed in a fire in 1880.
-The first building on Washington Square was opened in 1871 and fully completed in 1876, however in 1880 the building was destroyed in a fire. After its destruction, Principal Charles H. Allen journeyed to Sacramento to request the California State Legislator for emergency funds for a new building. This caused significant debate in the senate about the effectiveness of the school and if it would be better served elsewhere. The California State Senate voted to move the school to Los Angeles, but was ultimately kept in San Jose after objections by the California State Assembly.[26] The legislature ultimately settled to give partial emergency funds to the school for the construction of a new building, which finished construction in 1881.[citation needed]
-
-
-Initially built to replace the building that was destroyed in 1880, the second State Normal School Building was destroyed in the 1906 San Francisco Earthquake[27]
-
-The California State Normal School Bell, forged in 1881, still graces the San Jose campus.
-As a part of the construction of the new building, a large bell was forged to commemorate the school. The bell cost $1,200 ($39,099 in 2024),[28] and was inscribed with the words "California State Normal School, A.D. 1881," and would sound on special occasions until 1946 when the college obtained new chimes.[29] The original bell appears on the SJSU campus to this day and is still associated with various student traditions and rituals.[citation needed]
-
-Immediately after the failed attempt to move State Normal School to Los Angeles, California State Senator J.P. West sponsored a bill to create a "Branch State Normal School" in Los Angeles. The bill was passed by both houses, and opened in August 1882. The southern branch campus remained under administrative control of the San Jose campus until 1887.[30] In 1919, the school became the southern branch of the University of California, and later became the University of California, Los Angeles.[31][32]
-
-20th Century
-In 1921, the California State Normal School changed its name to the State Teachers College at San Jose.[citation needed]
-
-In 1922, the State Teachers College at San Jose adopted the Spartans as the school's official mascot and nickname. Mascots and nicknames prior to 1922 included the Daniels, the Teachers, the Pedagogues, the Normals and the Normalites.[citation needed]
-
-In 1930, the Justice Studies Department was founded as a two-year police science degree program. It holds the distinction of offering the first policing degree in the United States. A stone monument and plaque are displayed close to the site of the original police school near Tower Hall.[33]
-
-In 1935, the State Teachers Colleges became the California State Colleges, and the school's name was changed again, this time to San Jose State College.[citation needed]
-
-In 1942, the old gym (now named Yoshihiro Uchida Hall, after SJSU judo coach Yosh Uchida) was used to register and collect Japanese Americans before sending them to internment camps. Uchida's own family members were interred at some of these camps.[34]
-
-In 1963, in an effort to save Tower Hall from demolition, SJSU students and alumni organized testimonials before the State College Board of Trustees, sent telegrams and provided signed petitions. As a result of those efforts, the tower, a principal campus landmark and SJSU icon, was refurbished and reopened in 1966. The tower was again renovated and restored in 2007. Tower Hall is registered with the California Office of Historic Preservation.[35][36]
-
-During the 1960s and early 1970s, San Jose State College witnessed a rise in political activism and civic awareness among its student body, including major student protests against the Vietnam War. One of the largest campus protests took place in 1967 when Dow Chemical Company — a major manufacturer of napalm used in the war — came to campus to conduct job recruiting. An estimated 3,000 students and bystanders surrounded the 7th Street administration building, and more than 200 students and teachers lay down on the ground in front of the recruiters.[37]
-
-In 1972, upon meeting criteria established by the board of trustees and the Coordinating Council for Higher Education, SJSC was granted university status, and the name was changed to California State University, San Jose.[38] However, in 1974, the California legislature voted to change the school's name to San José State University.[38]
-
-In 1982, the English department began sponsoring the annual Bulwer-Lytton Fiction Contest.[39]
-
-In 1985, the CADRE Laboratory for New Media was established. It is believed to be the second oldest media lab of its kind in the United States.[40]
-
-In 1999, San Jose State and the City of San Jose agreed to combine their main libraries to form a joint city-university library located on campus, the first known collaboration of this type in the United States. The combined library faced opposition, with critics stating the two libraries have very different objectives and that the project would be too expensive. Despite opposition, the $177 million project proceeded, and the Dr. Martin Luther King Jr. Library opened on time and on budget in 2003. The library has won several national awards since its initial opening.[41]
-
-21st Century
-During its 2006–07 fiscal year, SJSU received a record $50+ million in private gifts and $84 million in capital campaign contributions.[42]
-
-In 2008, SJSU received a CASE WealthEngine Award in recognition of raising over $100 million. SJSU was one of approximately 50 institutions nationwide honored by CASE in 2008 for overall performance in educational fundraising.[43]
-
-In October 2010, SJSU President Don Kassing publicly launched SJSU's first-ever comprehensive capital fundraising campaign dubbed "Acceleration: the Campaign for San Jose State University."[44] The original goal of the multi-year campaign was to raise $150 million but was later increased to $200 million because of the rapid success of the campaign. The campaign would eventually exceed its goal one year earlier than anticipated, raising more than $208 million by 2013.[45]
-
-In 2012, the NASA Ames Research Center in Mountain View, California, awarded SJSU $73.3 million to participate in the development of systems for improving the safety and efficiency of air and space travel. NASA scientists, SJSU faculty and graduate students worked collaboratively on this effort. The grant was the largest federal award in SJSU history.[46]
-
-University principals and presidents
-Main article: List of presidents of San Jose State University
-Thirty-two people have led San Jose State since its founding including 8 principals, 15 presidents, 5 acting presidents, and 4 interim presidents.[47]
-
-Principals	Presidents
-#	Name	Years served	#	Name	Years served	#	Name	Years served	#	Name	Years served
-1	George W. Minns	1857–1862	9	James McNaughton	1899–1900	19	Hobert W. BurnsA	1969–1970	26	Don W. KassingT	2010–2011
-2	Ahira Holmes	1862–1865	10	Morris Elmer Dailey	1900–1918	20	John H. Bunzel	1970–1978	28	Mohammad Qayoumi	2011–2015
-1	George W. Minns	1865–1866	11	Lewis Ben WilsonA	1919–1920	21	Gail Fullerton	1978–1991	29	Susan W. MartinT	2015–2016
-3	Henry P. Carlton	1866–1867	12	William Webb Kemp	1920–1923	22	J. Handel EvansA	1991–1994	30	Mary A. Papazian	2016–2021
-4	George E. Tait	1867–1868	13	Alexander Richard HeronA	1923–1923	23	Robert L. Caret	1995–2003	31	Stephen PerezT	2022–2023
-3	Henry P. Carlton	1868–1868	14	Edwin Reagan Snyder	1923–1925	24	Joseph N. CrowleyT	2003–2004	32	Cynthia Teniente-Matson	2023–Present
-5	William T. Lucky	1868–1873	15	Herman F. MinssenA	1923–1927	25	Paul Yu	2004–2004	
-6	Charles H. Allen	1873–1889	16	Thomas William MacQuarrie	1927–1952	26	Don W. KassingT	2004–2005
-7	Charles W. Childs	1889–1896	17	John T. Wahlquist	1952–1964	26	Don W. Kassing	2005–2008
-8	Ambrose Randall	1896–1899	18	Robert D. Clark	1964–1969	27	Jon Whitmore	2008–2010
-A = Acting President T = Interim President
-Campus
-
-Built in 1910, Tower Hall is the oldest structure on the SJSU campus.
-
-The Central Classroom Building is the third oldest structure on campus.
-See also: Tower Hall
-The SJSU main campus comprises approximately 55 buildings situated on a rectangular, 154-acre (62.3 ha) area in downtown San Jose. The campus is bordered by San Fernando Street to the north, San Salvador Street to the south, South 4th Street to the west, and South 10th Street to the east. The south campus, which is home to many of the school's athletics facilities, is located approximately 1.5 miles (2.4 kilometres) south of the main campus on South 7th Street.[citation needed]
-
-California State Normal School did not receive a permanent home until it moved from San Francisco to San Jose in 1871. The original California State Normal School campus in San Jose consisted of several rectangular, wooden buildings with a central grass quadrangle. The wooden buildings were destroyed by fire in 1880 and were replaced by interconnected stone and masonry structures of roughly the same configuration in 1881.[citation needed]
-
-These buildings were declared unsafe following the 1906 San Francisco earthquake and were being torn down when an aftershock of the magnitude that was predicted to destroy the buildings occurred and no damage was observed. Accordingly, demolition was stopped, and the portions of the buildings still standing were subsequently transformed into four halls: Tower Hall, Morris Dailey Auditorium, Washington Square Hall and Dwight Bentel Hall. These four structures remain standing to this day and are the oldest buildings on campus.[citation needed]
-
-Beginning in the fall of 1994, the on-campus segments of San Carlos Street, 7th Street and 9th Street were closed to automobile traffic and converted to pedestrian walkways and green belts within the campus. San Carlos Street was renamed Paseo de San Carlos, 7th Street became Paseo de César Chávez, and 9th Street is now called the Ninth Street Plaza. The project was completed in 1996.[citation needed]
-
-Completed in 1999, the Business Classroom Project was a $16 million renovation of the James F. Boccardo Business Education Center. The $1.5 million Heritage Gateway project was completed in the same year. The privately funded project featured construction of eight oversized gateways around the main campus perimeter.[citation needed]
-
-In the fall of 2000, the SJSU Police Department, which is part of the larger California State University Police Department, opened a new on-campus, multi-level facility on 7th Street.[citation needed]
-
-The $177 million Dr. Martin Luther King Jr. Library, which opened its doors on August 1, 2003, won the Library Journal's 2004 Library of the Year award, the publication's highest honor.[48] The King Library represents the first collaboration of its kind between a university and a major U.S. city. The library is eight stories high, has 475,000 square feet (44,100 m2) of floor space, and houses approximately 1.3 million volumes.[49] San Jose's first public library occupied the same site from 1901 to 1936, and SJSU's Wahlquist Library occupied the site from 1961 to 2000.[citation needed]
-
-In 2007, a $2 million renovation of Tower Hall was completed. Tower Hall is among the oldest and most recognizable buildings on campus. It was registered as an official California Historical Landmark in 1949.[50] The building was rededicated in 1910 after numerous campus structures were either destroyed or heavily damaged in the 1906 earthquake. Tower Hall, Morris Dailey Auditorium, Washington Square Hall and Dwight Bentel Hall are the four oldest buildings on campus.[51]
-
-The Diaz Compean Student Union is a four-story, stand-alone facility that features a food court, the Spartan Bookstore, a multi-level study area, ballrooms, a bowling alley, music room and large game room. In September 2010, a $90 million expansion and renovation of the student union commenced. The project added approximately 100,000 square feet (9,300 m2) including construction of new ballrooms, food court, theater, meeting rooms and student program spaces. The expansion phase of the project was completed in June 2014. The renovation phase of the project was completed in August 2015.[52]
-
-Construction of a new, three-story, 52,000-square-foot (4,800 m2) on-campus health center at 7th Street and Paseo de San Carlos was completed in March 2015. The building houses the Student Health Center, Student Affairs office, Counseling Services and Wellness Center. The project was completed at a cost of over $36 million.[52][53][54]
-
-In August 2015, a $55 million renovation of the Spartan Complex was completed.[52] The Spartan Complex houses open recreation spaces, gymnasiums, an indoor aquatics center, the kinesiology department, weight rooms, locker rooms, dance and judo studios, and other classroom space. The primary project objectives were to expand existing structures, upgrade the structures to make them compliant with current building codes, correct ADA deficiencies, remove hazardous materials and correct fire safety deficiencies.[citation needed]
-
-Residence halls
-
-One of three Campus Village student residence buildings towers over the southeast corner of the SJSU main campus. A total of seven residences halls provide on-campus housing for 4,458 students.
-The SJSU on-campus housing community comprises seven residence halls, which can accommodate a combined total of 4,458 students. When the third phase of the Campus Village is completed, SJSU's total on-campus student housing capacity should increase from 4,458 to 4,928. The projected total cost for this project is approximately $334 million.[55]
-
-In January 2023, the California State University Board of Trustees approved a public-private partnership between SJSU and local investors that will allow the former Alfred E. Alquist state office building site to be transformed into new housing for SJSU faculty, staff, and graduate students.[56] Located one block west of the SJSU main campus, the 1.6-acre (0.65 ha) parcel will be the site of approximately 1,000 new housing rental units. Up to half of those units will be reserved for graduate students.[57] The new housing development will comprise one or more high-rise structures up to 300 feet (91.4 m) tall. The estimated total cost of the project is $750 million.[58] The project's design phase is projected to be completed by early 2024. Construction is projected to begin in late 2024 and be completed in 2027.[59]
-
-Additional on-campus facilities
-
-The Arch of Dignity, Equality and Justice, 2008 by Judy Baca, on the Paseo de César Chávez.
-SJSU is home to the 10,000-square-foot (930 m2), three-story Nuclear Science Facility. It is the only nuclear science facility of its kind in the California State University system.[60]
-
-Located on the main campus, the Provident Credit Union Event Center seats approximately 5,000 people for athletic events and over 6,500 for concerts.[citation needed]
-
-A new student recreation and aquatic center opened in April 2019. At a cost of $132 million, the new facility houses multiple gymnasiums, basketball courts, multiple weight and fitness centers, exercise rooms, rock climbing wall, indoor track, indoor soccer fields, and competition and recreation pools with support spaces. The new facility is located on the main campus at the corner of 7th Street and San Carlos on the site of the old aquatic center, which was demolished in 2017.[52]
-
-Construction of a new interdisciplinary science building broke ground in April 2019. At a projected cost of $181 million, the new facility will house teaching labs, research labs, faculty offices, a dean's suite and interdisciplinary spaces totaling 164,000 square feet (15,200 m2). The project site is located on the southwest quadrant of campus just north of Duncan Hall. The new building was completed in 2023.[61]
-
-South Campus
-
-A 2017 view of South Campus, stretching from the parking lot west of CEFCU Stadium to the golf course.
-SJSU's South Campus is located in the Spartan Keyes neighborhood, just south of Downtown San Jose. Many of SJSU's athletics facilities, including CEFCU Stadium (formerly known as Spartan Stadium) and the Spartan Golf Complex, along with the athletics department administrative offices and multiple training, practice and competition facilities, are located on the 62-acre (25.1 ha) south campus approximately 1.5 miles (2.4 kilometres) south of the main campus near 7th Street. The south campus also is home to student overflow parking. Shuttle buses run between the main campus and south campus every 10 to 15 minutes Monday through Thursday.[citation needed]
-
-In April 2014, a new $76 million master plan to renovate the entire South Campus was unveiled. The estimated cost was later increased to $150 million. The plan called for construction of a golf training facility, new baseball and softball stadiums, new outdoor recreation and intramural facility, new soccer and tennis facilities, three beach volleyball courts, a new multilevel parking garage, a new track and field facility, and a football stadium addition and renovation. The new golf, soccer and tennis facilities opened in 2017. The new softball facility opened in 2018, and the beach volleyball courts were completed in 2019. The intramural facility and parking garage were completed in 2021 along with the first phase of a new baseball facility.[citation needed]
-
-In August 2023, the first phase of the football stadium project was completed at an approximate cost of $70 million.[62] Known as the Spartan Athletics Center, the 55,000 square-foot, multi-story facility houses a new football operations center, locker rooms, offices, meeting and training rooms and a sports medicine center.[63] The facility also includes soccer team offices and locker rooms, as well as dining and hospitality facilities, event spaces and premium viewing areas.[64] Phase II, which is tentatively slated to include installation of premium spectator seating on the stadium's east side, remains in the planning stages as of 2023.[citation needed]
-
-Remaining South Campus projects are either under construction or still in the planning stages, as of 2023.[65]
-
-Off-campus facilities
-SJSU Simpkins International House (360 S. 11th Street, San Jose) provides housing for domestic as well as international students of the university. International House (also known as I-House) is a co-ed residence facility for 70 U.S. and international students attending San José State University. The building has served as a residence hall since 1980, and offers cultural exchanges for U.S. students as well as residents from abroad.[citation needed]
-
-The SJSU Department of Aviation and Technology maintains a 6,000-square-foot (560 m2) academic facility at the Reid-Hillview Airport.[citation needed]
-
-SJSU manages the Moss Landing Marine Laboratories (MLML) in Moss Landing, California, at Monterey Bay. MLML is a cooperative research facility of seven CSU campuses. Construction of an aquaculture laboratory at the MLML site was completed in August 2014. The building project included construction of a 1,400-square-foot (130 m2) aquaculture lab building and installation of a 1,584-square-foot (147.2 m2) tank slab area. The project was made possible by grants from the Packard Foundation.[52][66]
-
-SJSU International and Extended Studies facility (384 S. 2nd Street, San Jose). This off-campus classroom building houses SJSU's International Gateway Programs, a collection of classes geared toward introducing international students to the English language and American culture.[67]
-
-University Club (408 S. 8th Street, San Jose), is a 16-room, multi-level dining, special events, and bed-and-breakfast style residence facility for faculty, staff, visiting scholars and graduate students of the university. This building is currently occupied by Alpha Omicron Pi sorority in agreement with the university.[citation needed]
-
-Known simply as North Fourth Street (210 N. 4th Street, San Jose), this four-story facility houses the Global Studies Institute, Governmental and External Affairs, International and Extended Studies, the Mineta Transportation Institute, the Processed Foods Institute, and the SJSU Research Foundation.[citation needed]
-
-Organization
-
-The Boccardo Business Complex at the Lucas College and Graduate School of Business.
-As a member institution of the California State University System, San Jose State falls under the jurisdiction of the California State University Board of Trustees and the chancellor of the California State University.[citation needed]
-
-The chief executive of San José State University is the university president. On November 2022, the California State University Board of Trustees named Cynthia Teniente-Matson as the new SJSU president. Teniente-Matson previously served as the president of Texas A&M University–San Antonio and began her tenure at San Jose State on January 16th, 2023.[68]
-
-The university is organized into nine colleges:
-
-Lucas College and Graduate School of Business[69]
-Connie L. Lurie College of Education[70]
-Charles W. Davidson College of Engineering[71]
-College of Graduate Studies[72]
-College of Health and Human Sciences (formerly the College of Applied Sciences and Arts)[73]
-College of Humanities and the Arts[74]
-College of Information, Data & Society (formerly the College of Professional and Global Education)[75]
-College of Science[76]
-College of Social Sciences[77]
-Additionally, SJSU has seven focused schools:
-
-School of Art and Design[78]
-Lucas College and Graduate School of Business[79]
-School of Information[80]
-School of Journalism and Mass Communications[81]
-School of Music and Dance[82]
-The Valley Foundation School of Nursing[83]
-School of Social Work[84]
-Academics
-
-The Dr. Martin Luther King Jr. Library houses over 1.6 million volumes.
-As of spring 2023, San José State University offered 150 bachelor's degree programs, 95 master's degrees, 5 doctoral degrees, 11 different credential programs, and 42 certificates.[15] SJSU is accredited by the Western Association of Schools and Colleges (WASC).[12]
-
-SJSU's doctoral degree offerings include a Ph.D. program in library and information science offered jointly through Manchester Metropolitan University in Manchester, England,[85] a doctor of audiology (Au.D.), an Ed.D. program in educational leadership, a doctor of nursing practice (DNP), and an occupational therapy doctorate (OTD).[15]
-
-As of fall 2024, the university's Charles W. Davidson College of Engineering, with 7,133 undergraduate and graduate students, was the largest college on campus.[86] SJSU's Lucas College and Graduate School of Business was the second largest college on campus with a total enrollment of 6,745 undergraduate and graduate students.[86] The university's College of Social Sciences, with 5,442 undergraduate and graduate students, was the third-largest college at SJSU.[86] Enrollment wise, the Lucas College of Business is among the largest business schools in the country.[87] It is accredited by the Association to Advance Collegiate Schools of Business (AACSB) at both the graduate and undergraduate levels.[88]
-
-Rankings
-Academic rankings
-Master's
-Washington Monthly[89]	30
-Regional
-U.S. News & World Report[90]	4
-National
-Forbes[91]	87
-WSJ/College Pulse[92]	16
-Global
-THE[93]	1001–1200
-U.S. News & World Report[94]	1624
-2024–2025 USNWR Rankings Regional Universities in the West[95]
-Most Innovative Schools	3
-Top Public Schools	3
-Best Colleges for Veterans	3
-Top Performers on Social Mobility	12
-Best Value Schools	11
-Best Undergraduate Engineering Programs	15 (At schools where doctorate not offered)
-Computer Engineering	9
-Electrical Engineering / Electronic / Communications	10
-Mechanical Engineering	12
-Nursing	218
-Economics	214
-2024–2025 USNWR Best Graduate School Rankings[96]
-Library and Information Studies	19
-Occupational Therapy	30
-Social Work	77
-Speech-Language Pathology	74
-Fine Arts	110
-Public Affairs	121
-Public Health	116
-Nursing Master's	135
-Part-time MBA	143
-Education	120
-According to the 2024 U.S. News & World Report college rankings, San Jose State was ranked No. 3 in the western United States. SJSU was ranked No. 16 among all 120 "regional universities" in the western U.S.[97]
-
-SJSU's undergraduate engineering program was ranked tied for No. 12 nationally among 230 public and private colleges that do not offer doctoral degrees in engineering, according to the 2022-2023 U.S. News & World Report college rankings.[98]
-
-SJSU was ranked No. 107 out of approximately 500 institutions nationwide on the 2022 Forbes America's Top Colleges list. SJSU was ranked No. 43 nationally on the Forbes list of top public universities and colleges. Forbes also ranked SJSU No. 40 nationally out of approximately 300 colleges and universities on the most recent Forbes list of America's Best Value Colleges (2019).[99]
-
-Money magazine ranked San Jose State No. 31 nationally out of approximately 625 schools it evaluated for its 2022 "Best Colleges in America" ranking.[100] Money also ranked SJSU No. 27 nationally on its 2022 list of Best Public Colleges,[101] No. 39 on its list of Best Colleges for Engineering Majors,[102] and No. 19 on Money's list of Best Colleges in the West.[103] Finally, Money magazine ranked San Jose State No. 1 nationally on its 2020 list of "Most Transformative Colleges."[104]
-
-SJSU was ranked No. 16 out of more than 800 U.S. colleges and universities in the Wall Street Journal/Times Higher Education College Rankings 2025. The ranking was based on 15 individual performance indicators and responses from more than 170,000 current college students.[105]
-
-Washington Monthly ranked SJSU No. 53 nationally out of 603 master's universities (2022). Washington Monthly ranks colleges based on their "contribution to the public good in three broad categories: social mobility, research, and promoting public service."[106]
-
-The Webometrics Ranking of World Universities, which provides an assessment of the scholarly contents, visibility and impact of universities on the web, ranked SJSU No. 701 out of approximately 12,000 universities worldwide, and No. 200 out of approximately 3,200 U.S. colleges and universities (2022).[107][108]
-
-Undergraduate admissions
-Admission to SJSU is based on a combination of the applicant's high school cumulative grade point average (GPA) and standardized test scores. These factors are used to determine the applicant's California State University (CSU) eligibility index. More specifically, the eligibility index is a weighted combination of the applicant's high school grade point average during the final three years of high school and either the SAT or ACT score.
-
-The CSU eligibility index is calculated by using either the SAT or ACT as follows: (Sum of SAT scores in mathematics and critical reading) + (800 x high school GPA) or (10 x ACT composite score without the writing score) + (200 x high school GPA).
-
-In fall 2022, a total of 34,783 first-time, first-year (freshmen) applications were submitted, with 26,083 applicants accepted (75.0%) and 4,036 enrolling (15.5% of those accepted).[109]
-
-Freshman Admission Statistics[110][110][111][112][113]
-2024	2023	2022	2021	2020
-Applicants	37,132	35,780	34,783	30,441	32,375
-Admits	31,419	28,708	26,083	25,682	21,810
-% Admitted	84.6	80.2	75.0	84.4	67.4
-Enrolled	4,604	4,519	4,036	4,220	3,325
-SAT composite (middle 50% range)	1090–1330	1070–1320	1070–1370	1030–1310	1030–1240
-ACT composite (middle 50% range)	24–30	22–28	21–29	20–31	19–26
-Average High School GPA	3.53	3.50	3.60	3.54	3.55
-Transfer Admission Statistics[114][111][112][113]
-2024	2023	2022	2021	2020
-Applicants	11,504	10,880	12,458	14,337	14,929
-Admits	8.036	7,806	8,720	10,120	10,329
-% Admitted	69.8	71.7	70.0	70.6	69.2
-Enrolled	3,144	2,939	3,220	3,739	4,328
-Among first-time, first-year (freshmen) students who enrolled in fall 2021, SAT scores for the middle 50.0% ranged from 1030–1310.[112] ACT composite scores for the middle 50.0% ranged from 20–31.[111] The average high school GPA for incoming freshmen was 3.54. Approximately 39.0% of all incoming freshmen had a high school GPA between 3.75 and 4.0. and 18% had an incoming average high school GPA of 4.0[111]
-
-In recent years, enrollment at SJSU has become impacted in all undergraduate majors, which means the university no longer has the enrollment capacity to accept all CSU-eligible applicants, including some from local high schools and community colleges. Although an applicant may meet the minimum CSU admission requirements, CSU-eligible applicants are no longer guaranteed admission.[115][116]
-
-Undergraduate graduation and retention
-Among all first-time freshmen students who enrolled at SJSU in fall 2017, 30% graduated within four years; 68% who enrolled in fall 2015 graduated within six years.[117] Among new undergraduate transfer students who enrolled at SJSU in fall 2017, 33.0% graduated within two years, 69% graduated within three years, and 80.0% graduated within four years. Among first-time graduate students who enrolled at SJSU in fall 2017, 52.0% graduated within two years, 78% graduated within three years, and 83.0% graduated within four years.[117]
-
-The percentage of undergraduate students from the fall 2019 cohort returning in fall 2020 was 86.0% for full-time freshman students, 90.0% for new undergraduate transfer students, and 92.0% for first-time graduate students.[117]
-
-Faculty and research
-
-The Moss Landing Marine Laboratories.
-The university is classified among "R2: High Research Spending and Doctorate Production".[13] As of fall 2024, San José State University employed 2,177 faculty, 1,300 of whom (or about 60%) were full-time or equivalent (FTEF).[118]
-
-According to National Science Foundation survey data, in 2023 San Jose State's research and development expenditures totaled $83.4 million, placing it second in total R&D expenditures out of all 23 California State University (CSU) campuses and No. 185 out of more than 900 colleges and universities nationwide.[119]
-
-Research collections located at SJSU include the Ira F. Brilliant Center for Beethoven Studies, the Martha Heasley Cox Center for Steinbeck Studies, the J. Gordon Edwards Entomology Museum and the Carl W. Sharsmith Herbarium.
-
-SJSU research partnerships include the SJSU Metropolitan Technology Center at NASA Ames Research Center, Moffett Field, the Cisco Networking Laboratory, and the Moss Landing Marine Laboratories. SJSU is also home to the Mineta Transportation Institute.
-
-Additionally, the university operates the Survey and Policy Research Institute (SPRI), which conducts the quarterly, high-profile California Consumer Confidence Survey and many other research projects.
-
-SJSU is a member institution of the National Space Grant College and Fellowship Program.[120]
-
-Since 1979, the SJSU Department of Kinesiology operates the Timpany Center (located at 730 Empey Way), a non-profit therapeutic facility open to all and owned by the County of Santa Clara. The center is dedicated to the health and fitness of those with a disability or age-related concerns.[121]
-
-From 1989 to 2024, the SJSU Environmental Studies Department headquartered and operated the Center for the Development of Recycling, an environmental research and service organization.[122]
-
-On July 21, 2012, SJSU launched its first miniaturized satellite used for space research, TechEdSat, in a partnership with the NASA Ames Research Center.[123]
-
-Since 2014, SJSU has operated the Silicon Valley Big Data and Cybersecurity Center (BDCC). The center serves as a cybersecurity research and knowledge hub by creating multidisciplinary collaborations between faculty members from across the university and Silicon Valley tech companies.
-
-Air Force ROTC
-Known academically as the Department of Aerospace Studies, SJSU's Detachment 045 is one of only two Air Force Reserve Officer Training Corps detachments in the San Francisco Bay Area.[124] As such, Detachment 045 hosts "crosstown cadets" from other Bay Area schools including Santa Clara University, Stanford University and UC Santa Cruz.[125] San Jose State students and crosstown cadets enrolled in the AFROTC program learn leadership skills and participate in a number of other mandatory activities leading to an active-duty U.S. military officer commission.[citation needed]
-
-Student life
-Undergraduate demographics as of Fall 2024 
-Race and ethnicity[126]	Total
-Asian	35.9%	
- 
-Hispanic/Latino	29.6%	
- 
-White	13.6%	
- 
-Other[a]	9.4%	
- 
-Foreign national	7.9%	
- 
-Black or African American	3.3%	
- 
-Native Hawaiian or Other Pacific Islander	.4%	
- 
-American Indian or Alaskan Native	.1%	
- 
-Economic diversity
-Low-income[b]	40%	
- 
-Affluent[c]	60%	
- 
-Student Body Origin (Returning students)	Fall 2024[5][127]
-California: Santa Clara County	44.6%
-California: Bay Area (Outside Santa Clara County)	35.0%
-California: Non-local	12.6%
-International	6.8%
-Other U.S.	0.9%
-As the oldest and one of the largest universities in the CSU system, SJSU attracts students from California, the United States, and 100 countries around the world.[128] As of fall 2022, 35,751 students were enrolled at SJSU including 26,863 undergraduate students and 8,888 graduate and credential students. Approximately 51% of students were male and 49% were female. Graduate student enrollment at SJSU was the highest of any campus in the CSU system.[4][5]
-
-As of fall 2022, the average age of undergraduate students at SJSU was 22.2. The average age of graduate students was 29.0, and the average age of credential students was 31.7.[4]
-
-Approximately 4,500 students (12.5%) live in campus housing and community impact studies show an estimated 5,000 more students live within easy walking or biking distance of the campus.[129] Additionally, approximately 45% of all first-year (freshman) students live in campus residence facilities.[111]
-
-As of 2022, there were over 475 recognized student organizations at SJSU.[130] These include academic and honorary organizations, cultural and religious organizations, special interest organizations, fraternities and sororities, and a wide variety of club sports organizations.
-
-Fraternities and sororities
-Fraternities and sororities have existed at SJSU since 1896.[131] SJSU is home to 43 social fraternity and sorority chapters managed by Student Involvement. Greek life at SJSU comprises both social (NIC & NPC) and cultural (NPHC & USFC) organizations. Eighteen fraternities and sororities maintain chapter homes in the residential community east of campus along S. 10th and 11th streets, north of campus along San Fernando Street, and south of campus along San Salvador Street, S. 8th Street, and E. Reed Street, in downtown San Jose.[132]
-
-An additional 26 fraternities are co-ed and are either major-related, honors-related, or community service-related. The United Sorority and Fraternity Council (USFC) at San José State University was established in 2003. USFC is the coordinating body for the 17 cultural interest fraternities and sororities at SJSU.[133] Approximately 6% of male students join social fraternities, and 6% of female students join social sororities.
-
-Spartan Marching Band
-
-A student drum major conducts the Pride of the Spartans marching band during a football game at Stanford University.
-The Spartan marching band comprises students from every field of study on campus, from first year undergraduates through graduate students, as well as several "open university" members. At each home football game, the Spartan marching band performs a completely new halftime show, plus a pre-game show and a post-game concert. The band reflects all the color and fanfare of major university sports pageantry. The band is unofficially known as "The Pride of the Spartans," and generally performs with a color guard and dance team. The band performs at all home football games, and also travels with the team for select road games.[134]
-
-Student press
-Main article: The Spartan Daily
-
-The Dwight Bentel Hall houses the School of Journalism and Mass Communications.
-The school newspaper, The Spartan Daily, was founded in 1934 and is published three days a week when classes are in session. The publication follows a broadsheet format and has a daily print circulation of over 6,000, as well as a daily on-line edition. The newspaper is produced by journalism and advertising students enrolled in SJSU's School of Journalism and Mass Communications. The journalism school, including The Spartan Daily newsroom and other student press facilities, are housed inside Dwight Bentel Hall. The building was named after the department's founder and long time chairman, Dwight Bentel. The journalism school also runs an on-campus advertising agency, Dwight, Bentel and Hall Communications.[citation needed]
-
-Update News is a weekly, student-produced television newscast that airs every weekend on KICU, Channel 36 in San Jose. The newscast is produced by San Jose State broadcast journalism students, and has aired in the Bay Area since 1982.[135] The newscast previously aired on educational station KTEH. Update News also features a daily live webcast.[citation needed]
-
-Equal Time is a news magazine show produced by the San Jose State School of Journalism and Mass Communications. Each half-hour episode examines a different issue in depth, and ends with a roundtable discussion featuring professors and other experts in search of solutions. Equal Time airs Saturday afternoons on KQED+ (Channel 54 or Comcast Channel 10) in the Bay Area.[136]
-
-Established in 1963, KSJS, 90.5 FM, is the university's student-run radio station. KSJS features live broadcasts of San Jose State athletic events, various types of music including electronic, urban, jazz, subversive rock, and rock en Español, as well as specialty talk shows.[137]
-
-Notable student organizations
-W6YL is a student-run amateur radio station that has been in continuous operation for 97–98 years.[138][139] Originally founded in 1927 when SJSU was still known as San Jose State Teachers College, SJSU Amateur Radio Club W6YL is recognized as one of the oldest continuously operating student organizations on campus.[140] The SJSU Amateur Radio Club is a federally licensed radio station that operates under the callsign W6YL on amateur radio bands.[141]
-
-Athletics
-Main article: San Jose State Spartans
-
-California State Normal School football. (1910)
-San José State University has participated in athletics since it first fielded a baseball team in 1890. SJSU sports teams are known as the Spartans, and compete in the Mountain West Conference (MWC) in NCAA Division I.[citation needed]
-
-San José State University sports teams have won NCAA national titles in track and field, golf, boxing, fencing and tennis.[142] As of December 2022, SJSU has won 10 NCAA national Division 1 team championships[143] and produced 50 NCAA national Division 1 individual champions.[142] SJSU also has achieved an international reputation for its judo program, winning 52 National Collegiate Judo Association (NCJA) men's team championship titles and 26 NCJA women's team championship titles between 1962 and 2024.[144][145][146][147][148][149]
-
-SJSU alumni have won 20 Olympic medals (including seven gold medals) dating back to the first gold medal won by Willie Steele in track and field in the 1948 Summer Olympics. Alumni also have won medals in swimming, judo, water polo and boxing. The track team coached by "Bud" Winter earned San Jose State the nickname "Speed City," and produced Olympic medalists and social activists Lee Evans, Tommie Smith and John Carlos. Smith and Carlos are perhaps best remembered for giving the raised fist salute from the medalist's podium during the 1968 Summer Olympics in Mexico City. In 2005, a monument of the protest was built on Tower Lawn, designed by artist Rigo 23 and titled Victory Salute, the monument encourages passerby's to recreate the historic moment.[150] The track and field program was canceled in 1988 after a series of budget cuts and Title IX related decisions decimated the program. The program was reinstated in 2016.[151]
-
-After an 11-2 finish in 2012, SJSU's football team achieved its first-ever BCS ranking and first national ranking since 1990.[152] SJSU was ranked No. 21 in both the 2012 post-season Associated Press Poll and the USA Today Coaches' Poll.
-
-The Spartan football team had another breakout season in 2020, cracking the AP Poll top-25 for the first time since 2012 and appearing in the College Football Playoff ranking at No. 24. The team also won its first conference championship title since 1991. The Spartans finished the 2020 season 7-1 and ranked No. 24 in the AP Poll.
-
-
-Utah vs. San Jose State at Spartan Stadium (2009)
-Club sports
-In addition to its various NCAA Division I sports programs, San José State University has a very active club sports community consisting of approximately 25 sports and 50 teams.[153] Many of the club sports teams are run and organized by students, although some of the more established teams employ full-time paid coaches and enjoy strong alumni support. The list of club sports active at SJSU includes:
-
-Men's and women's archery, men's and women's badminton, baseball, men's and women's basketball, men's and women's bowling, men's and women's boxing, men's and women's cycling, dancesport, men's and women's dragon boat racing, esports, men's and women's fencing, men's and women's figure skating, men's and women's gymnastics, ACHA Division II and Division lll men's ice hockey, women's ice hockey, men's and women's judo, MCLA Division II men's lacrosse, women's lacrosse, mountain biking, men's and women's powerlifting, men's and women's quidditch, men's roller hockey, men's and women's rugby, salsa, men's and women's soccer, softball, men's and women's swimming, track and field, triathlon, ultimate Frisbee, men's and women's volleyball, men's and women's water polo, and men's and women's wrestling.[154]
-
-
-The Boccardo Gate on the Paseo de San Carlos.
-Traditions
-The old campus bell, which was originally located in a small tower to the right of the main entrance to the campus, was purchased and installed in 1881 at a cost of $1,217. The bell chimed each morning at eight o'clock until the 1906 San Francisco earthquake stilled its voice. When Tower Hall was constructed in 1909, it was specially designed to house the old bell. The bell rang on special occasions until the college obtained new carillon chimes in 1946. The old bell is displayed to this day on the Washington Square quad near Tower Hall.[29]
-
-In 1922, the State Teachers College at San Jose adopted the Spartans as the school's official mascot and nickname. Mascots and nicknames prior to 1922 included the Daniels, the Teachers, the Pedagogues, the Normals and the Normalites.
-
-In 1925, students debated whether to change the school colors from gold and white to purple and white. Tradition won out, and the students decided to keep the original colors, gold and white. At some point prior to 1929 when the SJSU alma mater was officially adopted, blue was added as an official school color alongside gold and white.[29]
-
-According to information published in the old SJSU La Torre yearbook, Spardi Gras was first held in 1929 on George Washington's birthday. Spardi Gras was described in the 1929 edition of La Torre as "[an] event which met with unprecedented participance by the entire student body ... a gala occasion of play, sport, and merrymaking later authorized by the Executive Board as an annual event because of its great success."[155] Spardi Gras was last mentioned in La Torre in 1960.[155]
-
-Another longstanding event at SJSU was "Spartan Revelries." According to information published in the 1960 edition of La Torre, Spartan Revelries was an "all-student college musical event written, produced and presented entirely by students."[155] It's unclear when Spartan Revelries began, but some believe it started in 1929 as a grand finale to Spardi Gras. In 1949, an official Revelries board was established to carry out the business and management of each year's show, which had grown into a major annual event requiring the efforts of many students and several months of preparation.[155][29]
-
-Sparta Camp was an annual event held between 1953 and 1965.[155] The retreat was hosted by the Associated Students and was held every spring at the Asilomar State Beach. The event was open to all students with an interest in student government, and students had to apply to go. Participants attended workshops and discussion groups on leadership. A similar event known as Freshman Camp was also held at Asilomar every September to help new students get oriented to the campus and the "Spirit of Sparta."[155][29]
-
-The chimes heard on the SJSU campus each quarter hour are Westminster chimes, which were a gift from the class of 1947. They ring the same tones as the famous Big Ben chimes in England.[29] Students and alumni show their Spartan pride every Thursday by wearing Spartan blue and gold.[156] Each year during homecoming week, SJSU hosts a series of events leading up to the homecoming football game at CEFCU Stadium. Events include the Campus MovieFest Finale and Fire on the Fountain festival.[156]
-
-Alma mater
-"Hail! Spartans, Hail!" is the university's official alma mater. The lyrics were written by Gerald Erwin, a 1933 graduate. Erwin was a music major who also served as the student director of the glee club. The song was officially adopted as the school hymn on February 25, 1929.[155] Whenever the SJSU Alma Mater is played, students are asked to stand, remove their hats and sing along.[29]
-
-The university also has a fight song, which is typically played and/or sung at the end of football games and other athletic events including pep rallies.[29]
-
-Alumni
-Main article: List of San Jose State University people
-
-Lindsey Buckingham (left)
-(Attended '68-'70) and Stevie Nicks (right)
-(Attended '68-'70)
-Musicians best known for Fleetwood Mac
-
-Ben Nighthorse Campbell
-(B.A., '57)
-First Native American to be elected to the United States Senate and member of the first US Olympic judo team
-
-John Carlos (right)
-(Attended '68-'69)
-and Tommie Smith (center) (B.A., '69)
-Track and field athletes known for a 1968 Protest
-
-Dian Fossey
-(B.S., '54)
-Primatologist and conservationist known for studying mountain gorilla groups
-
-Lou Henry Hoover
-(DipEd, 1893)
-Philanthropist and former First Lady of the United States
-
-Gordon Moore
-(Attended '46-'47)
-Founder of the Intel Corporation and creator of "Moore's law"
-
-Gaylord Nelson
-(B.A., '39)
-Governor of Wisconsin and founder of Earth Day
-
-Bill Walsh
-(B.A, '55)
-Football coach in the Pro Football Hall of Fame and three time Super Bowl champion
-About 60% of San Jose State's 275,000 living alumni of record reside in the San Francisco Bay Area. The other 40% are scattered around the globe, with concentrations in Southern California, Seattle, Portland, Philadelphia, Washington, D.C., and New York City.[157]
-
-SJSU is consistently listed among the leading suppliers of undergraduate and graduate alumni to Silicon Valley science and technology firms.[158][159][160] In 2015, San José State University was listed as the top feeder school for Apple Inc., which employed over 1,000 SJSU graduates at the time. SJSU ranked 9th on the list of top feeder schools for Facebook.[161]
-
-Some of the more notable SJSU alumni in science and engineering include Ray Dolby, founder of Dolby sound systems; Dian Fossey, primatologist and gorilla researcher; Gordon Moore, founder of Intel Corporation and creator of "Moore's law;" and Ed Oates, co-founder of Oracle.[162]
-
-Nearly 200 former SJSU students and graduates have founded, co-founded, served or serve as senior executives or officers of public and private companies reporting annual sales between $40 million and $26 billion.[163] This list includes former Intel Corporation CEO, Brian Krzanich,[164] and current Crown Worldwide Group CEO, billionaire James E. Thompson.[165]
-
-Notable companies founded by SJSU students and alumni include Dolby Laboratories (1965), Intel Corporation (1968), Specialized Bicycle Components (1974), Oracle Corporation (1977), Seagate Technology (1979) and WhatsApp (2008).[166][167]
-
-Musicians Doug Clifford and Stu Cook (Creedence Clearwater Revival), Tom Johnston and Patrick Simmons (the Doobie Brothers), Lindsey Buckingham and Stevie Nicks (Fleetwood Mac) and Paul Kantner (Jefferson Airplane) all attended San Jose State.[168][169][170][171][172]
-
-SJSU distinguished alumni also include former first Lady of the United States, Lou Henry Hoover, novelists Amy Tan and Jayne Ann Krentz, and fashion designer Jessica McClintock.
-
-SJSU alumni Dick Vermeil and Bill Walsh earned a combined four Super Bowl victories as NFL head coaches.[173][174]
-
-San Jose State alumnus and 1964 U.S. Open winner Ken Venturi was named Sports Illustrated "Sportsman of the Year" and later inducted into the World Golf Hall of Fame.[175]

community_contributions/ChatBot_with_evaluator_and_notifier/rag.py

@@ -1,207 +0,0 @@
-import os
-import glob
-from typing import Optional, List, Dict, Any
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_community.document_loaders import DirectoryLoader, TextLoader
-from langchain_huggingface import HuggingFaceEmbeddings
-from langchain_chroma import Chroma
-
-DB_NAME = os.getenv("DB_NAME", "career_db")
-DIRECTORY_NAME = os.getenv("DIRECTORY_NAME", "knowledge_base")
-CHROMA_PERSIST_DIRECTORY = os.getenv("CHROMA_PERSIST_DIRECTORY", "./chroma_db")
-TOP_K = int(os.getenv("TOP_K", "25"))
-CHUNK_SIZE = int(os.getenv("CHUNK_SIZE", "1000"))
-CHUNK_OVERLAP = int(os.getenv("CHUNK_OVERLAP", "300"))
-MODEL_NAME = os.getenv("EMBED_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
-
-class Retriever:
-    def __init__(
-        self,
-        db_name: str = DB_NAME,
-        directory_name: str = DIRECTORY_NAME,
-        top_k: int = TOP_K,
-        chunk_size: int = CHUNK_SIZE,
-        chunk_overlap: int = CHUNK_OVERLAP,
-        model_name: str = MODEL_NAME,
-        force_rebuild: bool = False,
-    ):
-        self.db_name = db_name
-        self.directory_name = directory_name
-        self.top_k = top_k
-        self.chunk_size = chunk_size
-        self.chunk_overlap = chunk_overlap
-        self._embeddings = HuggingFaceEmbeddings(model_name=model_name)
-        self.vectorstore = None
-        self._retriever = None
-        self._init_or_load_db(force_rebuild=force_rebuild)
-
-    def _get_documents(self) -> List:
-        text_loader_kwargs = {"encoding": "utf-8"}
-        docs = []
-        for pattern in ("*.txt", "*.md", "*.markdown"):
-            loader = DirectoryLoader(
-                self.directory_name,
-                glob=pattern,
-                loader_cls=TextLoader,
-                loader_kwargs=text_loader_kwargs,
-                show_progress=False,
-            )
-            docs.extend(loader.load())
-        return docs
-
-    def _build_store(self):
-        documents = self._get_documents()
-        if documents:
-            splitter = RecursiveCharacterTextSplitter(
-                chunk_size=self.chunk_size,
-                chunk_overlap=self.chunk_overlap,
-            )
-            chunks = splitter.split_documents(documents)
-            if chunks:
-                self.vectorstore = Chroma.from_documents(
-                    documents=chunks,
-                    embedding=self._embeddings,
-                    persist_directory=self.db_name,
-                )
-            else:
-                self.vectorstore = Chroma(
-                    persist_directory=self.db_name,
-                    embedding_function=self._embeddings,
-                )
-        else:
-            self.vectorstore = Chroma(
-                persist_directory=self.db_name,
-                embedding_function=self._embeddings,
-            )
-        # Persistence is handled automatically when using persist_directory
-
-    def _init_or_load_db(self, force_rebuild: bool = False):
-        exists = os.path.exists(self.db_name) and any(
-            os.scandir(self.db_name)
-        )
-        if force_rebuild or not exists:
-            self._build_store()
-        else:
-            self.vectorstore = Chroma(
-                persist_directory=self.db_name,
-                embedding_function=self._embeddings,
-            )
-        self._retriever = self.vectorstore.as_retriever(
-            search_type="similarity_score_threshold",
-            search_kwargs={"k": self.top_k, "score_threshold": 0.2},
-        )
-
-    def rebuild(self):
-        self._build_store()
-        self._retriever = self.vectorstore.as_retriever(
-            search_type="similarity_score_threshold",
-            search_kwargs={"k": self.top_k, "score_threshold": 0.2},
-        )
-
-    def get_retriever(self, k: Optional[int] = None):
-        if k and k != self.top_k:
-            return self.vectorstore.as_retriever(search_kwargs={"k": k})
-        return self._retriever
-
-    def get_relevant_docs(self, message: str, k: Optional[int] = None):
-        if k:
-            # respect threshold on ad-hoc calls
-            retr = self.vectorstore.as_retriever(
-                search_type="similarity_score_threshold",
-                search_kwargs={"k": k, "score_threshold": 0.2},
-            )
-            return retr.invoke(message)
-        return self._retriever.invoke(message)
-
-    def get_relevant_chunks(self, message: str, k: Optional[int] = None):
-        docs = self.get_relevant_docs(message, k=k)
-        return [d.page_content for d in docs]
-
-
-# --- Back-compat free functions expected by controller/app ---
-_GLOBAL_RETRIEVER: Optional[Retriever] = None
-
-
-def get_retriever()  -> Any:
-    """
-    Returns a LangChain retriever object with get_relevant_documents().
-    Lazily initializes a module-level Retriever to persist across calls.
-    """
-    global _GLOBAL_RETRIEVER
-    if _GLOBAL_RETRIEVER is None:
-        _GLOBAL_RETRIEVER = Retriever()
-    return _GLOBAL_RETRIEVER.get_retriever()
-
-
-def ingest(data_dir: Optional[str] = None) -> str:
-    """
-    Rebuilds the vector store using documents from data_dir or default DIRECTORY_NAME.
-    Returns a short status string for UI display.
-    """
-    target_dir = data_dir or DIRECTORY_NAME
-    global _GLOBAL_RETRIEVER
-    _GLOBAL_RETRIEVER = Retriever(directory_name=target_dir, force_rebuild=True)
-    count = getattr(_GLOBAL_RETRIEVER.vectorstore._collection, "count", lambda: 0)()
-    return f"ingested from {target_dir} — chunks in store: {count}"
-
-
-class ChromaRAG:
-    """Minimal agent-style RAG wrapper: ingest, retrieve, metadata."""
-
-    def __init__(
-        self,
-        persist_dir: str = CHROMA_PERSIST_DIRECTORY,
-        kb_dir: str = DIRECTORY_NAME,
-        model_name: str = os.getenv("EMBED_MODEL", "sentence-transformers/all-MiniLM-L6-v2"),
-    ):
-        self.persist_dir = persist_dir
-        self.kb_dir = kb_dir
-        self._embeddings = HuggingFaceEmbeddings(model_name=model_name)
-        self._vs = None
-        self._ensure_vectorstore()
-
-    def _ensure_vectorstore(self):
-        if os.path.exists(self.persist_dir) and any(os.scandir(self.persist_dir)):
-            self._vs = Chroma(persist_directory=self.persist_dir, embedding_function=self._embeddings)
-            print(f"[rag] loaded vectorstore at {self.persist_dir}")
-        else:
-            os.makedirs(self.persist_dir, exist_ok=True)
-            self._vs = Chroma(persist_directory=self.persist_dir, embedding_function=self._embeddings)
-            print(f"[rag] initialized empty vectorstore at {self.persist_dir}")
-
-    def ingest_documents(self, folder_path: Optional[str] = None) -> Dict[str, Any]:
-        folder = folder_path or self.kb_dir
-        text_loader_kwargs = {"encoding": "utf-8"}
-        docs: List = []
-        for pattern in ("*.txt", "*.md", "*.markdown"):
-            loader = DirectoryLoader(folder, glob=pattern, loader_cls=TextLoader, loader_kwargs=text_loader_kwargs, show_progress=False)
-            docs.extend(loader.load())
-
-        if not docs:
-            print(f"[rag] no documents in {folder}")
-            return {"ingested": 0, "total": getattr(self._vs._collection, "count", lambda: 0)()}
-
-        splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
-        chunks = splitter.split_documents(docs)
-        if not chunks:
-            print("[rag] no chunks produced")
-            return {"ingested": 0, "total": getattr(self._vs._collection, "count", lambda: 0)()}
-
-        Chroma.from_documents(documents=chunks, embedding=self._embeddings, persist_directory=self.persist_dir)
-        self._ensure_vectorstore()
-        total = getattr(self._vs._collection, "count", lambda: 0)()
-        print(f"[rag] ingested={len(chunks)} total={total}")
-        return {"ingested": len(chunks), "total": total}
-
-    def retrieve_context(self, query: str, top_k: int = 3) -> List[str]:
-        retriever = self._vs.as_retriever(search_kwargs={"k": top_k})
-        docs = retriever.invoke(query)
-        return [d.page_content for d in docs]
-
-    def get_retrieval_metadata(self, query: str, top_k: int = 3) -> Dict[str, Any]:
-        retriever = self._vs.as_retriever(search_kwargs={"k": top_k})
-        docs = retriever.invoke(query)
-        results: List[Dict[str, Any]] = []
-        for d in docs:
-            results.append({"content": d.page_content, "metadata": getattr(d, "metadata", {})})
-        return {"query": query, "results": results}

community_contributions/ChatBot_with_evaluator_and_notifier/requirements.txt

@@ -1,8 +0,0 @@
-gradio
-langchain
-langchain-community
-langchain-openai
-chromadb
-sentence-transformers
-python-dotenv
-requests

community_contributions/ChatBot_with_evaluator_and_notifier/tools.py

@@ -1,133 +0,0 @@
-import os
-import csv
-import json
-import base64
-from dotenv import load_dotenv
-from datetime import datetime
-import requests
-
-
-try:
-    import gspread
-    from google.oauth2.service_account import Credentials
-    GOOGLE_SHEETS_AVAILABLE = True
-except ImportError:
-    GOOGLE_SHEETS_AVAILABLE = False
-
-
-CSV_FILE = "user_interest.csv"
-SHEET_NAME = "UserInterest"
-
-
-def _get_google_credentials():
-    load_dotenv(override=True)
-    scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"]
-    google_creds_json = os.getenv("GOOGLE_CREDENTIALS_JSON")
-
-    if google_creds_json:
-        json_str = base64.b64decode(google_creds_json).decode('utf-8')
-        creds_dict = json.loads(json_str)
-        creds = Credentials.from_service_account_info(creds_dict, scopes=scope)
-        print("[info] Loaded Google credentials from environment.")
-        return creds
-
-    raise RuntimeError("Google credentials not found.")
-
-def _save_to_google_sheets(email, name, notes):
-    creds = _get_google_credentials()
-    client = gspread.authorize(creds)
-    sheet = client.open(SHEET_NAME).sheet1
-    row = [datetime.today().strftime('%Y-%m-%d %H:%M'), email, name, notes]
-    sheet.append_row(row)
-    print(f"[Google Sheets] Recorded: {email}, {name}")
-
-def _save_to_csv(email, name, notes):
-    file_exists = os.path.isfile(CSV_FILE)
-    with open(CSV_FILE, mode='a', newline='', encoding='utf-8') as f:
-        writer = csv.writer(f)
-        if not file_exists:
-            writer.writerow(["Timestamp", "Email", "Name", "Notes"])
-        writer.writerow([datetime.today().strftime('%Y-%m-%d %H:%M'), email, name, notes])
-    print(f"[CSV] Recorded: {email}, {name}")
-
-def _record_user_details(email, name="Name not provided", notes="Not provided"):
-    try:
-        if GOOGLE_SHEETS_AVAILABLE:
-            _save_to_google_sheets(email, name, notes)
-        else:
-            raise ImportError("gspread not installed.")
-    except Exception as e:
-        print(f"[Warning] Google Sheets write failed, using CSV. Reason: {e}")
-        _save_to_csv(email, name, notes)
-
-    return {"recorded": "ok"}
-
-
-# --- Minimal Pushover + logging helpers for agent-based RAG ---
-
-def send_pushover_notification(message: str, user_details: dict | None = None):
-    """
-    Sends a simple Pushover notification if PUSHOVER_TOKEN and PUSHOVER_USER are set.
-    Returns a small dict with status info; never raises to keep the app resilient.
-    """
-    load_dotenv(override=True)
-    token = os.getenv("PUSHOVER_TOKEN")
-    user = os.getenv("PUSHOVER_USER")
-
-    if not token or not user:
-        print("[pushover] disabled (missing PUSHOVER_TOKEN or PUSHOVER_USER)")
-        return {"sent": False, "reason": "missing_creds"}
-
-    try:
-        payload = {
-            "token": token,
-            "user": user,
-            "title": "RAG: Unsupported Answer With Empty Context",
-            "message": message,
-            "priority": 0,
-        }
-
-        if user_details:
-            try:
-                details = {k: v for k, v in user_details.items() if v}
-            except Exception:
-                details = {}
-            if details:
-                payload["message"] = payload["message"] + "\n" + json.dumps(details)
-
-        resp = requests.post("https://api.pushover.net/1/messages.json", data=payload, timeout=10)
-        ok = resp.status_code == 200
-        print(f"[pushover] status={resp.status_code} ok={ok}")
-        return {"sent": ok, "status_code": resp.status_code}
-    except Exception as e:
-        print(f"[pushover] error: {e}")
-        return {"sent": False, "error": str(e)}
-
-
-def collect_user_details(name: str | None = None, email: str | None = None) -> dict:
-    return {"name": name or "", "email": email or ""}
-
-
-def log_interaction(query: str, response: str, evaluation: dict, user_details: dict | None = None, csv_path: str = "interactions.csv"):
-    try:
-        file_exists = os.path.isfile(csv_path)
-        with open(csv_path, mode='a', newline='', encoding='utf-8') as f:
-            writer = csv.writer(f)
-            if not file_exists:
-                writer.writerow(["timestamp", "query", "response", "evaluation", "user_details"])
-            writer.writerow([
-                datetime.today().strftime('%Y-%m-%d %H:%M:%S'),
-                query,
-                response,
-                json.dumps(evaluation, ensure_ascii=False),
-                json.dumps(user_details or {}, ensure_ascii=False),
-            ])
-        print(f"[log] wrote interaction to {csv_path}")
-    except Exception as e:
-        print(f"[log] error: {e}")
-
-
-# Back-compat simple notifier expected by existing controller
-def notify(title: str, message: str):
-    full = f"{title}: {message}" if title else message
-    return send_pushover_notification(full)

community_contributions/Indira_1_lab1.ipynb

@@ -1,370 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Welcome to the start of your adventure in Agentic AI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Are you ready for action??</h2>\n",
-    "            <span style=\"color:#ff7800;\">Have you completed all the setup steps in the <a href=\"../setup/\">setup</a> folder?<br/>\n",
-    "            Have you read the <a href=\"../README.md\">README</a>? Many common questions are answered here!<br/>\n",
-    "            Have you checked out the guides in the <a href=\"../guides/01_intro.ipynb\">guides</a> folder?<br/>\n",
-    "            Well in that case, you're ready!!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/tools.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#00bfff;\">This code is a live resource - keep an eye out for my updates</h2>\n",
-    "            <span style=\"color:#00bfff;\">I push updates regularly. As people ask questions or have problems, I add more examples and improve explanations. As a result, the code below might not be identical to the videos, as I've added more steps and better comments. Consider this like an interactive book that accompanies the lectures.<br/><br/>\n",
-    "            I try to send emails regularly with important updates related to the course. You can find this in the 'Announcements' section of Udemy in the left sidebar. You can also choose to receive my emails via your Notification Settings in Udemy. I'm respectful of your inbox and always try to add value with my emails!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### And please do remember to contact me if I can help\n",
-    "\n",
-    "And I love to connect: https://www.linkedin.com/in/eddonner/\n",
-    "\n",
-    "\n",
-    "### New to Notebooks like this one? Head over to the guides folder!\n",
-    "\n",
-    "Just to check you've already added the Python and Jupyter extensions to Cursor, if not already installed:\n",
-    "- Open extensions (View >> extensions)\n",
-    "- Search for python, and when the results show, click on the ms-python one, and Install it if not already installed\n",
-    "- Search for jupyter, and when the results show, click on the Microsoft one, and Install it if not already installed  \n",
-    "Then View >> Explorer to bring back the File Explorer.\n",
-    "\n",
-    "And then:\n",
-    "1. Click where it says \"Select Kernel\" near the top right, and select the option called `.venv (Python 3.12.9)` or similar, which should be the first choice or the most prominent choice. You may need to choose \"Python Environments\" first.\n",
-    "2. Click in each \"cell\" below, starting with the cell immediately below this text, and press Shift+Enter to run\n",
-    "3. Enjoy!\n",
-    "\n",
-    "After you click \"Select Kernel\", if there is no option like `.venv (Python 3.12.9)` then please do the following:  \n",
-    "1. On Mac: From the Cursor menu, choose Settings >> VS Code Settings (NOTE: be sure to select `VSCode Settings` not `Cursor Settings`);  \n",
-    "On Windows PC: From the File menu, choose Preferences >> VS Code Settings(NOTE: be sure to select `VSCode Settings` not `Cursor Settings`)  \n",
-    "2. In the Settings search bar, type \"venv\"  \n",
-    "3. In the field \"Path to folder with a list of Virtual Environments\" put the path to the project root, like C:\\Users\\username\\projects\\agents (on a Windows PC) or /Users/username/projects/agents (on Mac or Linux).  \n",
-    "And then try again.\n",
-    "\n",
-    "Having problems with missing Python versions in that list? Have you ever used Anaconda before? It might be interferring. Quit Cursor, bring up a new command line, and make sure that your Anaconda environment is deactivated:    \n",
-    "`conda deactivate`  \n",
-    "And if you still have any problems with conda and python versions, it's possible that you will need to run this too:  \n",
-    "`conda config --set auto_activate_base false`  \n",
-    "and then from within the Agents directory, you should be able to run `uv python list` and see the Python 3.12 version."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First let's do an import. If you get an Import Error, double check that your Kernel is correct..\n",
-    "\n",
-    "from dotenv import load_dotenv\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Next it's time to load the API keys into environment variables\n",
-    "# If this returns false, see the next cell!\n",
-    "\n",
-    "load_dotenv(override=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Wait, did that just output `False`??\n",
-    "\n",
-    "If so, the most common reason is that you didn't save your `.env` file after adding the key! Be sure to have saved.\n",
-    "\n",
-    "Also, make sure the `.env` file is named precisely `.env` and is in the project root directory (`agents`)\n",
-    "\n",
-    "By the way, your `.env` file should have a stop symbol next to it in Cursor on the left, and that's actually a good thing: that's Cursor saying to you, \"hey, I realize this is a file filled with secret information, and I'm not going to send it to an external AI to suggest changes, because your keys should not be shown to anyone else.\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/stop.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Final reminders</h2>\n",
-    "            <span style=\"color:#ff7800;\">1. If you're not confident about Environment Variables or Web Endpoints / APIs, please read Topics 3 and 5 in this <a href=\"../guides/04_technical_foundations.ipynb\">technical foundations guide</a>.<br/>\n",
-    "            2. If you want to use AIs other than OpenAI, like Gemini, DeepSeek or Ollama (free), please see the first section in this <a href=\"../guides/09_ai_apis_and_ollama.ipynb\">AI APIs guide</a>.<br/>\n",
-    "            3. If you ever get a Name Error in Python, you can always fix it immediately; see the last section of this <a href=\"../guides/06_python_foundations.ipynb\">Python Foundations guide</a> and follow both tutorials and exercises.<br/>\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Check the key - if you're not using OpenAI, check whichever key you're using! Ollama doesn't need a key.\n",
-    "\n",
-    "import os\n",
-    "openai_api_key = os.getenv('OPENAI_API_KEY')\n",
-    "\n",
-    "if openai_api_key:\n",
-    "    print(f\"OpenAI API Key exists and begins {openai_api_key[:8]}\")\n",
-    "else:\n",
-    "    print(\"OpenAI API Key not set - please head to the troubleshooting guide in the setup folder\")\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - the all important import statement\n",
-    "# If you get an import error - head over to troubleshooting in the Setup folder\n",
-    "# Even for other LLM providers like Gemini, you still use this OpenAI import - see Guide 9 for why\n",
-    "\n",
-    "from openai import OpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now we'll create an instance of the OpenAI class\n",
-    "# If you're not sure what it means to create an instance of a class - head over to the guides folder (guide 6)!\n",
-    "# If you get a NameError - head over to the guides folder (guide 6)to learn about NameErrors - always instantly fixable\n",
-    "# If you're not using OpenAI, you just need to slightly modify this - precise instructions are in the AI APIs guide (guide 9)\n",
-    "\n",
-    "openai = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a list of messages in the familiar OpenAI format\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": \"What is 2+2?\"}]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now call it! Any problems, head to the troubleshooting guide\n",
-    "# This uses GPT 4.1 nano, the incredibly cheap model\n",
-    "# The APIs guide (guide 9) has exact instructions for using even cheaper or free alternatives to OpenAI\n",
-    "# If you get a NameError, head to the guides folder (guide 6) to learn about NameErrors - always instantly fixable\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"llama3.2\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "print(response.choices[0].message.content)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# And now - let's ask for a question:\n",
-    "\n",
-    "question = \"Please propose a hard, challenging question to assess someone's IQ. Respond only with the question.\"\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ask it - this uses GPT 4.1 mini, still cheap but more powerful than nano\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"llama3.2\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "question = response.choices[0].message.content\n",
-    "\n",
-    "print(question)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# form a new messages list\n",
-    "messages = [{\"role\": \"user\", \"content\": question}]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Ask it again\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model=\"llama3.2\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "answer = response.choices[0].message.content\n",
-    "print(answer)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import Markdown, display\n",
-    "\n",
-    "display(Markdown(answer))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Congratulations!\n",
-    "\n",
-    "That was a small, simple step in the direction of Agentic AI, with your new environment!\n",
-    "\n",
-    "Next time things get more interesting..."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table style=\"margin: 0; text-align: left; width:100%\">\n",
-    "    <tr>\n",
-    "        <td style=\"width: 150px; height: 150px; vertical-align: middle;\">\n",
-    "            <img src=\"../assets/exercise.png\" width=\"150\" height=\"150\" style=\"display: block;\" />\n",
-    "        </td>\n",
-    "        <td>\n",
-    "            <h2 style=\"color:#ff7800;\">Exercise</h2>\n",
-    "            <span style=\"color:#ff7800;\">Now try this commercial application:<br/>\n",
-    "            First ask the LLM to pick a business area that might be worth exploring for an Agentic AI opportunity.<br/>\n",
-    "            Then ask the LLM to present a pain-point in that industry - something challenging that might be ripe for an Agentic solution.<br/>\n",
-    "            Finally have 3 third LLM call propose the Agentic AI solution. <br/>\n",
-    "            We will cover this at up-coming labs, so don't worry if you're unsure.. just give it a try!\n",
-    "            </span>\n",
-    "        </td>\n",
-    "    </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First create the messages:\n",
-    "\n",
-    "messages = [{\"role\": \"user\", \"content\": \"Pick a business area that might be worth exploring for an Agentic AI opportunity.\"}]\n",
-    "\n",
-    "# Then make the first call:\n",
-    "\n",
-    "\n",
-    "response = openai.chat.completions.create(\n",
-    "    model = \"llama3.2\",\n",
-    "    messages=messages\n",
-    ")\n",
-    "\n",
-    "# Then read the business idea:\n",
-    "\n",
-    "business_idea = response.choices[0].message.content\n",
-    "print(business_idea)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}