cohere_langchain.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1e7ed19c-34d9-411c-9de4-8292971e15b7",
   "metadata": {},
   "source": [
    "# Cohere for event listing\n",
    "In this notebook, I set up a simple workflow for an agent to suggest some cool events from the [Boston Calendar](https://www.thebostoncalendar.com/). It uses LangChain's wrapper for Cohere's Command-R+ API.  \n",
    "\n",
    "I also perform an experiment comparing styling information in the preamble to a post-result styling.  \n",
    "\n",
    "The result indicates that there may be benefit in separating the tasks.  I did not conduct the experiment here, but potentially a lighter-weight model could be asked to do the styling while the more complex model conducts the agent workflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "dc4dd1f3-4be3-4b2c-b1ba-fa11553ca172",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_cohere import ChatCohere, create_cohere_react_agent\n",
    "from langchain.agents import (\n",
    "    tool, \n",
    "    AgentExecutor\n",
    ")\n",
    "from langchain_core.prompts import PromptTemplate\n",
    "from datetime import datetime, date\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "\n",
    "# some requirements for arguments\n",
    "from langchain_core.pydantic_v1 import BaseModel, Field, validator\n",
    "from langchain_core.runnables import RunnablePassthrough\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# to handle rate limit\n",
    "import time\n",
    "from cohere.errors import TooManyRequestsError\n",
    "\n",
    "\n",
    "# this is for simple scraping tool\n",
    "import requests\n",
    "from random import sample\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "223a53b0-fecb-4636-818d-923f51ada613",
   "metadata": {},
   "outputs": [],
   "source": [
    "# using .env file for cohere API key\n",
    "from dotenv import load_dotenv\n",
    "import os\n",
    "load_dotenv()\n",
    "# trial key\n",
    "llm = ChatCohere(model=\"command-r-plus\", cohere_api_key=os.getenv(\"COHERE_KEY\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fd4bf33",
   "metadata": {},
   "source": [
    "### Working example\n",
    "This section has all the code you need to run the \"winning\" approach; a post-workflow styling.  I only experimented with the current set of parameters, but switching these up should not break the workflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "28d06294",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define style (\"Rewrite in the style of...\")\n",
    "style = \"an angry pirate\"\n",
    "# what are you asking the agent to do\n",
    "# this is for upcoming events, other types of questions may not work\n",
    "user_prompt = \"What is going on this weekend?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7cedfe0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the function calls for our tools\n",
    "@tool\n",
    "def today(text: str = 's') -> dict:\n",
    "    \"\"\"Returns today's date, use this when you need to get today's date.\n",
    "    The input should always be an empty string.\"\"\"\n",
    "    # has to return a dictionary\n",
    "    return {'today': str(date.today())}\n",
    "\n",
    "def parse_for_calendar(text: str) -> str:\n",
    "    # utility for converting text input to boston calendar URL\n",
    "    if len(text) == 1:\n",
    "        # will assume this month if we're looking at weekend number\n",
    "        today = datetime.now()\n",
    "        month = today.month\n",
    "        day = today.day\n",
    "        url = f'https://www.thebostoncalendar.com/events?day={day}&month={month}&weekend={text}&year=2024'\n",
    "    # this will fail if the string provided is not a date\n",
    "    else:\n",
    "        try:\n",
    "            f_date = datetime.strptime(text, '%Y-%M-%d')\n",
    "            day_of_month = f_date.day\n",
    "            month = f_date.month\n",
    "            url = f'https://www.thebostoncalendar.com/events?day={day_of_month}&month={month}&year=2024'\n",
    "        except ValueError:\n",
    "            return \n",
    "    return url\n",
    "\n",
    "@tool\n",
    "def weekend(text: str = '') -> dict:\n",
    "    \"\"\"Returns the single-digit weekend number for this weekend, \\\n",
    "    use this for any questions related to the weekend date. \\\n",
    "    The input should always be an empty string, \\\n",
    "    and this function will always return the weekend number.\"\"\"\n",
    "    today = datetime.now()\n",
    "    \n",
    "    # Calculate the weekend number within the month\n",
    "    first_day_of_month = today.replace(day=1)\n",
    "    weekend_number_within_month = (today - first_day_of_month).days // 7 + 1\n",
    "\n",
    "    #return weekend_number_within_month\n",
    "    # has to return a dictionary\n",
    "    return {'weekend_number': weekend_number_within_month}\n",
    "\n",
    "@tool\n",
    "def get_events(text: str) -> dict:\n",
    "    \"\"\"Returns local events. \\ \n",
    "    The input is either a date string in the format YYYY-MM-DD, \\\n",
    "    or it is a single-digit weekend number.\\\n",
    "    The input cannot be a function call.\\\n",
    "    This function will return a list where \\\n",
    "    each element contains an event name, date and location as a tuple.\\\n",
    "    This function should be used to provide complete information about events.\"\"\"\n",
    "    # use the parsing utility to get a formatted url\n",
    "    url = parse_for_calendar(text)\n",
    "    if url is None:\n",
    "        # give the LLM a useful response\n",
    "        return {'events': \n",
    "                f'Input \"{text}\" is not in the right format - it needs to be a date string or a weekend number'}\n",
    "    response = requests.get(url)     \n",
    "    \n",
    "    # Parse the HTML content\n",
    "    soup = BeautifulSoup(response.content, 'html.parser')\n",
    "    \n",
    "    # Extract data\n",
    "    events = soup.find_all('div', class_='info')\n",
    "\n",
    "    all_events = []\n",
    "    for event in events:\n",
    "        title = event.find('h3').text.strip()\n",
    "        date = event.find('p', class_='time').text.strip()\n",
    "        location = event.find('p', class_='location').text.strip()\n",
    "        all_events.append((title, date, location))\n",
    "\n",
    "    # randomly select a few, provide as list\n",
    "    choices = sample(all_events, 3)\n",
    "    \n",
    "    #return choices\n",
    "    # has to return a dictionary\n",
    "    return {'events': choices}\n",
    "\n",
    "def run_agent(agent_details, prompt=\"What is going on this weekend?\"):\n",
    "    result = agent_details['executor'].invoke({\n",
    "        \"input\": prompt,\n",
    "        \"preamble\": agent_details['preamble'],\n",
    "    })\n",
    "    return result\n",
    "\n",
    "class empty_string(BaseModel):\n",
    "    text: str = Field(description=\"Empty string input\", required=False, default='')\n",
    "    @validator(\"text\")\n",
    "    def is_empty(cls, field):\n",
    "        if field is None:\n",
    "            return ''\n",
    "        return field\n",
    "\n",
    "class date_input(BaseModel):\n",
    "    text: str = Field(description=\"Date string in the format YYYY-MM-DD or weekend number (e.g. 1)\")\n",
    "\n",
    "today.args_schema = empty_string\n",
    "weekend.args_schema = empty_string\n",
    "get_events.args_schema = date_input\n",
    "\n",
    "tools = [today, weekend, get_events]\n",
    "\n",
    "preamble = \"\"\"You are an expert who answers the user's question with the most relevant datasource. \\\n",
    "You are equipped with tools for getting date information and looking for upcoming events.\"\"\"\n",
    "\n",
    "prompt = PromptTemplate.from_template(\"{input}\")\n",
    "agent = create_cohere_react_agent(llm, tools, prompt)\n",
    "agent_executor = AgentExecutor(agent=agent, tools=tools, \n",
    "                                verbose=False, \n",
    "                                handle_parsing_errors=True,\n",
    "                                max_iterations=5)\n",
    "\n",
    "styling_prompt = f'Rewrite the following as if you are {style}:\\n' + '{events_output}'\n",
    "styling_template = PromptTemplate.from_template(styling_prompt)\n",
    "\n",
    "full_pipe = {'executor': {'events_output': agent_executor, 'input': RunnablePassthrough()} | \n",
    "                               styling_template | \n",
    "                               llm | StrOutputParser(),\n",
    "                               'preamble': preamble}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09977635",
   "metadata": {},
   "source": [
    "#### Run the workflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f78b7278",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Argh, ye scurvy dog! Listen up, ye landlubber! It be Sunday, April 6 of the year 2024. And mark me words, there be a single event happenin' today that ye might be interested in, given yer penchant fer cheap travel: \\n\\n$10 Commuter Rail Weekends in Boston, startin' at 5:00 am. \\n\\nNow, ye best be mindful o' the time, or ye might miss the chance fer a cheap voyage! Arrrr!\""
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run_agent(full_pipe, prompt=user_prompt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d32ba30b",
   "metadata": {},
   "source": [
    "### Experiment details\n",
    "This code is for running the experiment I used to determine the \"winning\" approach"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9029500-4e41-46ba-a739-41a3f337e33c",
   "metadata": {},
   "source": [
    "#### Defining the tools\n",
    "Here are the tools with which I want to equip the LLM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "cec18cb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the function calls for our tools\n",
    "@tool\n",
    "def today(text: str = 's') -> dict:\n",
    "    \"\"\"Returns today's date, use this when you need to get today's date.\n",
    "    The input should always be an empty string.\"\"\"\n",
    "    # has to return a dictionary\n",
    "    return {'today': str(date.today())}\n",
    "\n",
    "def parse_for_calendar(text: str) -> str:\n",
    "    # utility for converting text input to boston calendar URL\n",
    "    if len(text) == 1:\n",
    "        # will assume this month if we're looking at weekend number\n",
    "        today = datetime.now()\n",
    "        month = today.month\n",
    "        day = today.day\n",
    "        url = f'https://www.thebostoncalendar.com/events?day={day}&month={month}&weekend={text}&year=2024'\n",
    "    # this will fail if the string provided is not a date\n",
    "    else:\n",
    "        try:\n",
    "            f_date = datetime.strptime(text, '%Y-%M-%d')\n",
    "            day_of_month = f_date.day\n",
    "            month = f_date.month\n",
    "            url = f'https://www.thebostoncalendar.com/events?day={day_of_month}&month={month}&year=2024'\n",
    "        except ValueError:\n",
    "            return \n",
    "    return url\n",
    "\n",
    "@tool\n",
    "def weekend(text: str = '') -> dict:\n",
    "    \"\"\"Returns the single-digit weekend number for this weekend, \\\n",
    "    use this for any questions related to the weekend date. \\\n",
    "    The input should always be an empty string, \\\n",
    "    and this function will always return the weekend number.\"\"\"\n",
    "    today = datetime.now()\n",
    "    \n",
    "    # Calculate the weekend number within the month\n",
    "    first_day_of_month = today.replace(day=1)\n",
    "    weekend_number_within_month = (today - first_day_of_month).days // 7 + 1\n",
    "\n",
    "    #return weekend_number_within_month\n",
    "    # has to return a dictionary\n",
    "    return {'weekend_number': weekend_number_within_month}\n",
    "\n",
    "@tool\n",
    "def get_events(text: str) -> dict:\n",
    "    \"\"\"Returns local events. \\ \n",
    "    The input is either a date string in the format YYYY-MM-DD, \\\n",
    "    or it is a single-digit weekend number.\\\n",
    "    The input cannot be a function call.\\\n",
    "    This function will return a list where \\\n",
    "    each element contains an event name, date and location as a tuple.\\\n",
    "    This function should be used to provide complete information about events.\"\"\"\n",
    "    # use the parsing utility to get a formatted url\n",
    "    url = parse_for_calendar(text)\n",
    "    if url is None:\n",
    "        # give the LLM a useful response\n",
    "        return {'events': \n",
    "                f'Input \"{text}\" is not in the right format - it needs to be a date string or a weekend number'}\n",
    "    response = requests.get(url)     \n",
    "    \n",
    "    # Parse the HTML content\n",
    "    soup = BeautifulSoup(response.content, 'html.parser')\n",
    "    \n",
    "    # Extract data\n",
    "    events = soup.find_all('div', class_='info')\n",
    "\n",
    "    all_events = []\n",
    "    for event in events:\n",
    "        title = event.find('h3').text.strip()\n",
    "        date = event.find('p', class_='time').text.strip()\n",
    "        location = event.find('p', class_='location').text.strip()\n",
    "        all_events.append((title, date, location))\n",
    "\n",
    "    # randomly select a few, provide as list\n",
    "    choices = sample(all_events, 3)\n",
    "    \n",
    "    #return choices\n",
    "    # has to return a dictionary\n",
    "    return {'events': choices}\n",
    "\n",
    "class empty_string(BaseModel):\n",
    "    text: str = Field(description=\"Empty string input\", required=False, default='')\n",
    "    @validator(\"text\")\n",
    "    def is_empty(cls, field):\n",
    "        if field is None:\n",
    "            return ''\n",
    "        return field\n",
    "\n",
    "class date_input(BaseModel):\n",
    "    text: str = Field(description=\"Date string in the format YYYY-MM-DD or weekend number (e.g. 1)\")\n",
    "\n",
    "today.args_schema = empty_string\n",
    "weekend.args_schema = empty_string\n",
    "get_events.args_schema = date_input\n",
    "\n",
    "tools = [today, weekend, get_events]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba67bae8",
   "metadata": {},
   "source": [
    "#### Defining the agent structures\n",
    "I try out several agent structures here.  The main thing I want to test is how styling within the preamble or styling the result change the helpfulness/robustness of the workflow\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "00be57a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "preamble = \"\"\"You are an expert who answers the user's question with the most relevant datasource. \\\n",
    "You are equipped with tools for getting date information and looking for upcoming events.\"\"\"\n",
    "\n",
    "agent_options = {}\n",
    "verbose = False\n",
    "prompt = PromptTemplate.from_template(\"{input}\")\n",
    "agent = create_cohere_react_agent(llm, tools, prompt)\n",
    "\n",
    "agent_executor = AgentExecutor(agent=agent, tools=tools, \n",
    "                                verbose=verbose, \n",
    "                                handle_parsing_errors=True,\n",
    "                                max_iterations=5)\n",
    "agent_options['base'] = {'executor': agent_executor,\n",
    "                         'preamble': preamble}\n",
    "\n",
    "# define style\n",
    "style = \"an angry pirate\"\n",
    "# style in preamble\n",
    "style_preamble= preamble + f'\\nRespond in the style of {style}.'\n",
    "agent_options['preamble_style'] = {'executor': agent_executor,\n",
    "                         'preamble': style_preamble}\n",
    "\n",
    "styling_prompt = f'Rewrite the following as if you are {style}:\\n' + '{events_output}'\n",
    "styling_template = PromptTemplate.from_template(styling_prompt)\n",
    "\n",
    "agent_options['post_style'] = {'executor': {'events_output': agent_executor, 'input': RunnablePassthrough()} | styling_template | llm | StrOutputParser(),\n",
    "                               'preamble': preamble}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "041bb092",
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_result(result, llm=llm):\n",
    "    # evaluation prompt\n",
    "    eval_prompt = \"\"\"The user has requested information about upcoming events. \\\n",
    "    The following is a response to this request. \\\n",
    "    Evaluate the quality of the response. \\\n",
    "    Respond with one word, either \"good\" or \"bad\".\"\"\"\n",
    "    prompt = PromptTemplate.from_template(f\"{eval_prompt}:\\n{result}\")\n",
    "    eval_pipe = prompt | llm | StrOutputParser()\n",
    "    eval_result = eval_pipe.invoke({'result': result})\n",
    "    # process output\n",
    "    output = {}\n",
    "    output['raw'] = eval_result\n",
    "    if 'good' in eval_result.lower():\n",
    "        output['good'] = True\n",
    "    elif 'bad' in eval_result.lower():\n",
    "        output['good'] = False\n",
    "    return output\n",
    "\n",
    "def run_agent(agent_details, prompt=\"What is going on this weekend?\"):\n",
    "    result = agent_details['executor'].invoke({\n",
    "        \"input\": prompt,\n",
    "        \"preamble\": agent_details['preamble'],\n",
    "    })\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3ab5d6d",
   "metadata": {},
   "source": [
    "#### Running the experiment!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "87d0a3ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using preamble: base\n",
      "Iteration 1\n",
      "Iteration 2\n",
      "Iteration 3\n",
      "Iteration 4\n",
      "Iteration 5\n",
      "Iteration 6\n",
      "Iteration 7\n",
      "Iteration 8\n",
      "Iteration 9\n",
      "Iteration 10\n",
      "Using preamble: preamble_style\n",
      "Iteration 1\n",
      "Iteration 2\n",
      "Iteration 3\n",
      "Iteration 4\n",
      "Iteration 5\n",
      "Iteration 6\n",
      "Iteration 7\n",
      "Iteration 8\n",
      "Iteration 9\n",
      "Iteration 10\n",
      "Using preamble: post_style\n",
      "Iteration 1\n",
      "Iteration 2\n",
      "Iteration 3\n",
      "Iteration 4\n",
      "Iteration 5\n",
      "Error: peer closed connection without sending complete message body (incomplete chunked read)\n",
      "Iteration 6\n",
      "Iteration 7\n",
      "Iteration 8\n",
      "Iteration 9\n",
      "Iteration 10\n",
      "Error: The read operation timed out\n"
     ]
    }
   ],
   "source": [
    "# how many times to iterate\n",
    "iter_num = 10\n",
    "# iterate through the preamble dictionary\n",
    "eval_collect = []\n",
    "result_collect = []\n",
    "for opt in agent_options:\n",
    "    print(f\"Using preamble: {opt}\")\n",
    "    for i in range(iter_num):\n",
    "        print(f\"Iteration {i+1}\")\n",
    "        try:\n",
    "            result = run_agent(agent_options[opt])\n",
    "        except TooManyRequestsError:\n",
    "            print(\"Too many requests, waiting\")\n",
    "            time.sleep(60)\n",
    "            result = run_agent(agent_options[opt])\n",
    "        # capture other exceptions\n",
    "        except Exception as e:\n",
    "            print(f\"Error: {e}\")\n",
    "            continue\n",
    "        if 'output' in result:\n",
    "            result_text = result['output']\n",
    "        else:\n",
    "            result_text = result\n",
    "        result_collect.append(result_text)\n",
    "        eval_output = eval_result(result_text)\n",
    "        eval_collect.append((opt, eval_output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "201c2656",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Preamble performance')"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# consolidate and visualize results\n",
    "from collections import defaultdict\n",
    "opt_count = defaultdict(int)\n",
    "opt_good = defaultdict(int)\n",
    "for opt, eval_result in eval_collect:\n",
    "    if eval_result['good']:\n",
    "        opt_good[opt] += 1\n",
    "    opt_count[opt] += 1\n",
    "# combine count and good pct side by side\n",
    "opt_pct = {k: v/iter_num for k, v in opt_count.items()}\n",
    "opt_good_pct = {k: v/opt_count[k] for k, v in opt_good.items()}\n",
    "# plot\n",
    "fig, ax = plt.subplots()\n",
    "ax.bar([f'{k}_success' for k in opt_pct.keys()], opt_pct.values())\n",
    "ax.bar([f'{k}_good' for k in opt_good_pct.keys()], opt_good_pct.values())\n",
    "# rotate x labels\n",
    "plt.xticks(rotation=90)\n",
    "ax.set_ylabel('Percentage')\n",
    "ax.set_title('Preamble performance')\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "llamabot",
   "language": "python",
   "name": "llamabot"
  },
  "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}