storm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "044d3184-548b-4018-997c-10b7fac08d3f",
   "metadata": {},
   "source": [
    "# STORM - LangChain\n",
    "\n",
    "<img src=\"storm.png\"></img>\n",
    "\n",
    "STORM is a research assistant designed by Shao, et. al that extends the idea of \"outline-driven RAG\" for richer article generation.\n",
    "\n",
    "STORM is designed to generate Wikipedia-style ariticles on a user-provided topic. It applies two main insights to produce more organized and comprehensive articles:\n",
    "\n",
    "Creating an outline (planning) by querying similar topics helps improve coverage.\n",
    "Multi-perspective, grounded (in search) conversation simulation helps increase the reference count and information density.\n",
    "The control flow looks like the diagram below.\n",
    "\n",
    "STORM has a few main stages:\n",
    "\n",
    "Generate initial outline + Survey related subjects\n",
    "Identify distinct perspectives\n",
    "\"Interview subject matter experts\" (role-playing LLMs)\n",
    "Refine outline (using references)\n",
    "Write sections, then write article\n",
    "The expert interviews stage occurs between the role-playing article writer and a research expert. The \"expert\" is able to query external knowledge and respond to pointed questions, saving cited sources to a vectorstore so that the later refinement stages can synthesize the full article.\n",
    "\n",
    "There are a couple hyperparameters you can set to restrict the (potentially) infinite research breadth:\n",
    "\n",
    "N: Number of perspectives to survey / use (Steps 2->3) M: Max number of conversation turns in step (Step 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8aa862f0-450a-4312-b1d7-6808ad87ca3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture --no-stderr\n",
    "%pip install --quiet -U langgraph langchain_openai langchain_community langchain_core"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f99b2868-fb11-47f3-bdfe-413176b6c9a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from dotenv import load_dotenv\n",
    "\n",
    "_ = load_dotenv(\"src/local.env\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fc034c0f-1427-44be-847a-2ca704d710e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7692b3f3-e04b-4569-ba78-dbc6861b9172",
   "metadata": {},
   "source": [
    "## Generate Analysts: Human-In-The-Loop\n",
    "\n",
    "Create analysts and review them using human-in-the-loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8c3251b6-a4d7-4fcc-9d80-7ac7b6d0e19b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "from typing_extensions import TypedDict\n",
    "from pydantic import BaseModel, Field"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f32c3644-2ce9-4f8b-b7b3-4f1952a1ce72",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Analyst(BaseModel):\n",
    "    affiliation: str = Field(\n",
    "        description=\"Primary affiliation of the analyst.\"\n",
    "    )\n",
    "    name: str = Field(\n",
    "        description=\"Name of the analyst.\"\n",
    "    )\n",
    "    role: str = Field(\n",
    "        description=\"Role of the analyst in the contex of the topic.\"\n",
    "    )\n",
    "    description: str = Field(\n",
    "        description=\"Description of the analyst focus, and motives.\"\n",
    "    )\n",
    "    @property\n",
    "    def persona(self) -> str:\n",
    "        return f\"Name: {self.name}\\nRole: {self.role}\\nAffiliation: {self.affiliation}\\nDescription: {self.description}\\n\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cab5653b-0e31-4b7c-a934-9bff7ebf3405",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Perspectives(BaseModel):\n",
    "    analysts: List[Analyst] = Field(\n",
    "        description=\"Comprehensive list of analysts with their roles and affiliations.\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3c4f87f6-4ad5-4883-88ed-5d539cde5bcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GenerateAnalystsState(TypedDict):\n",
    "    topic: str\n",
    "    max_analysts: int\n",
    "    human_analyst_feedback: str\n",
    "    analysts: List[Analyst]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "de349f75-58db-4b56-bcaa-782b4e3ea087",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.graph import START, END, StateGraph\n",
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "from langchain_core.messages import AIMessage, HumanMessage, SystemMessage\n",
    "from IPython.display import Image, display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "28fbdc81-6521-4e7c-885b-4b80ca411418",
   "metadata": {},
   "outputs": [],
   "source": [
    "analyst_instructions = \"\"\"\n",
    "You are tasked with creating a set of AI analyst personas. Follow these instructions carefully:\n",
    "\n",
    "1. First, review the research topic:\n",
    "{topic}\n",
    "\n",
    "2. Examine any editorial feedback that has been optionally provided to guide creation of the analysts:\n",
    "{human_analyst_feedback}\n",
    "\n",
    "3. Determine the most interesting themes based upon documents and / or feedback above.\n",
    "\n",
    "4. Pick the top {max_analysts} themes.\n",
    "\n",
    "5. Assign one analyst to each theme.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "c45c2b02-0172-414b-8cc8-025f9aadd239",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_analysts(state: GenerateAnalystsState):\n",
    "    \n",
    "    \"\"\" \n",
    "    Create analysts \n",
    "    \"\"\"\n",
    "    \n",
    "    topic=state['topic']\n",
    "    max_analysts=state['max_analysts']\n",
    "    human_analyst_feedback=state.get('human_analyst_feedback', '')\n",
    "    \n",
    "    structured_llm = llm.with_structured_output(Perspectives)\n",
    "    \n",
    "    system_message = analyst_instructions.format(\n",
    "        topic=topic,\n",
    "        human_analyst_feedback=human_analyst_feedback,\n",
    "        max_analysts=max_analysts\n",
    "    )\n",
    "    \n",
    "    analysts = structured_llm.invoke([SystemMessage(content=system_message)]+[HumanMessage(content=\"Generate the set of analysts.\")])\n",
    "    \n",
    "    return {\"analysts\": analysts.analysts}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "00657d35-c1e2-44ad-bc29-ae8bccff8423",
   "metadata": {},
   "outputs": [],
   "source": [
    "def human_feedback(state: GenerateAnalystsState):\n",
    "    \"\"\" \n",
    "    No-op node that should be interrupted on\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "7daadf8d-7551-4053-8e58-8111fa684698",
   "metadata": {},
   "outputs": [],
   "source": [
    "def should_continue(state: GenerateAnalystsState):\n",
    "    \"\"\"\n",
    "    Return the next node to execute\n",
    "    \"\"\"\n",
    "\n",
    "    human_analyst_feedback = state.get('human_analyst_feedback', None)\n",
    "    if human_analyst_feedback:\n",
    "        return \"create_analysts\"\n",
    "    return END"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "c3b0d068-a4f3-4e90-b460-59f5e2636c44",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/4gHYSUNDX1BST0ZJTEUAAQEAAAHIAAAAAAQwAABtbnRyUkdCIFhZWiAH4AABAAEAAAAAAABhY3NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlkZXNjAAAA8AAAACRyWFlaAAABFAAAABRnWFlaAAABKAAAABRiWFlaAAABPAAAABR3dHB0AAABUAAAABRyVFJDAAABZAAAAChnVFJDAAABZAAAAChiVFJDAAABZAAAAChjcHJ0AAABjAAAADxtbHVjAAAAAAAAAAEAAAAMZW5VUwAAAAgAAAAcAHMAUgBHAEJYWVogAAAAAAAAb6IAADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9YWVogAAAAAAAA9tYAAQAAAADTLXBhcmEAAAAAAAQAAAACZmYAAPKnAAANWQAAE9AAAApbAAAAAAAAAABtbHVjAAAAAAAAAAEAAAAMZW5VUwAAACAAAAAcAEcAbwBvAGcAbABlACAASQBuAGMALgAgADIAMAAxADb/2wBDAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRT/2wBDAQMEBAUEBQkFBQkUDQsNFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBT/wAARCAF3AKoDASIAAhEBAxEB/8QAHQABAAMBAAMBAQAAAAAAAAAAAAUGBwQBAwgCCf/EAFQQAAEDAwICAwgNCQUFCAMAAAECAwQABQYREgchEzGUCBQVFiJBVtMXNlFUVWF0dZOy0dLUIzI1QlJxgZW0N2KRsbMkJTRDggkYM0VXg5bBoqPC/8QAGwEBAQADAQEBAAAAAAAAAAAAAAECAwQFBgf/xAAzEQEAAQICBwYFBQADAAAAAAAAAQIRAxIEITFRUqHRFDNBYXGRYoGSscEFExUiIzLh8P/aAAwDAQACEQMRAD8A/qnSlKBSlKBSlQN0ukybcVWm0FLchCUrlznEbkRUnqSkfrOqHMJ6kjyldaUrzppmubQqZkSWYrZcfdQy2OtTigkf4muA5TZQdDd4GvylH21wR+H9kSvppsNN5mEaKl3QCQ4rnry3DRI18yQByGg5V3+Ktl+B4HZkfZW22DG2Zk1HjVZfhiB2lH208arL8MQO0o+2nirZfgeB2ZH2U8VbL8DwOzI+yn+PnyXUeNVl+GIHaUfbTxqsvwxA7Sj7aeKtl+B4HZkfZTxVsvwPA7Mj7Kf4+fI1HjVZfhiB2lH208arL8MQO0o+2nirZfgeB2ZH2U8VbL8DwOzI+yn+PnyNTqh3SFcCRFlsSdBqehdSv/I11VAzcCxu4aF+xW8rHNLqI6UOIPupWAFJPxgiuRYmYV+VXJk3Ow6/lBIV0r8Iftbz5TjY8+7csdepHIMlFerDnXun/wB0S0TsWmleEqC0hSSFJI1BB1BFea50KUpQKUpQKUpQKUpQeifMbt0GRLe1DTDanV6de1I1P+VQuBw1xsXhPyAkzpyROlqTqdzzg3K5nnoNQke4EgaDTSpK/W83ax3GCkhKpMZxkE9QKkkf/dcuGzxc8Ts8oApLkRsqQoaFCgkBSSPMQQQf3V0R3M23x9pt+V8EzSlK50VrPeI2O8MrOzc8kuIt8R+QiIztZcfdeeUCUttttpUtaiEqOiUk6AnzVnWYd1NjOMX/AAGMyxPuNpyhMp7v+LbJjq2W2W1EaMoYUtSitO0p0CkAFRGnOpXuirVabniVqXc7ZlMt6Jc25MGfh8ZUifbJCUObZIQkElIBUgjasHpACkjUjLBcc/TB4I57mWN3i6TrNMujV2ZtlsK5yWX2XWYr7kRvUpUpKWytKfzSs8h1ANlzHugMC4f35uz5DfTbJqkNuKLkOQpllLh0QXXktltoE/tqTXRf+OGGY1ly8WnXV45Clth426Lb5Ml3o3VKShYDTatU6pIKupPLcU7hr88cf4uX8QX+JFpl2jPZkadZW0YjbLIy6xb3Oki6uqmrQUpLiXioKafV+akBKVE89K4NWS4njNkF+mWe4Qo0vD7AyxJnw3GSVgSVOtarA0WnVG9HWk6agUFh4P8AdB2ri1kWVWaPBnwZdmuciG10sCUlt5loNjpFOrZShCypw/kireAAdCOdavWH8FZFww3iJxGxe649emHLrk0u9wrqmCtdudjOsslP+0AbErBQpJQTrrp7tbhQK8KSFpKVAKSRoQRqCK80oKzgizGhXGzk6izzVwm+ZOjWxDrKef7Lbraf+mrNVYwxPTzsnuAB6KXdFBskaahppphX7/LaXzqz1vx+8mfS/rbXzWdpSlK0IUpSgUpSgUpSgVV1HxKnSnlIJsEx0vuKQkqMJ5ZJWtQH/KWfKKv1FFSj5KiUWilbKK8t4nXErdVcp4b4ZxMTClZDjlmyZLKD3q9PiNyQhKtCdhUDoDoOrr0FQP8A3bOE+mnsb4tp7nghj7tWR/AbX0rjsFUuyuOElfgySthCiTqSWwdhJPPXbrzPPma9ZwmRr7ab8Pi6Zn1VbMmFOyu3rHS5aDD+FuHcPpEl/GMXtGPvSUhDzlthNsKcSDqAopA1ANWiqv4kyPSq/fTM+qp4kyPSq/fTM+qp+3h8fKS0b1opWV5Vb7rZsywq2R8pvBi3eXJYlFx1ncEoiuup2fk+vchOvXy1/fVs8SZHpVfvpmfVU/bw+PlJaN6XyDHbXldnk2m9W6NdbZJAD0OY0l1pwAhQCkqBB0IB/eBVIHc2cKEnUcN8WB6uVpYH/wDNWDxJkelV++mZ9VTxJkelV++mZ9VT9vD4+Ulo3oyycBuG+N3WNc7TgmO224xV9IxLi2xlt1pXupUE6g/uqZut+XcJLtosbrbtxB2SJA8puCnzlenLpNPzUdZ5E6J1Nek4CxJ5Trvebg352nZym0K/eGtmo+I8jU/b7dFtMRuLCjNRIzY0Q0ygJSn+Ap/nRribzy/7XVD82m1x7JbIsCIkojRm0tIBOp0A01J85PWT5zzrrpStEzNU3liUpSoFKUoFKUoFKUoFKUoFKUoFKUoM9z8gcS+F+pOpuM3TsD/x/bWhVnuf6+yXwv6v0jN69Nf+Af6tf/qtCoFKUoFKUoFKUoFKUoFKUoFKUoFKUoFKUoFKUoFKUoM84gDXiZwu8oD/AHjN5Edf+75HVWh1nnEDT2TOF2vX4Rm6ctf/AC+R/hWh0ClKUClKUClKUClKUClKUClK4rzd49itzs2TvLaNEhDady1qUQlKEjzqKiAB7pqxE1TaNo7aVSlZDlrx3t2q0R0HmG3pzilgf3ilrTX4hqPjNfnw7mHvCx9re9XXX2WvfHvC2XelUjw7mHvCx9re9XTw7mHvCx9re9XTste+PeCy70qkeHcw94WPtb3q6eHcw94WPtb3q6dlr3x7wWXelUjw7mHvCx9re9XTw7mHvCx9re9XTste+PeCz5K7o3u5JfCvjrb7Fc+HTrr+MTXn2HUXUAT2Xo6221pHQHZqHASAToQU6+evtjFrpLvmMWi5XC3KtE+ZDZkSLcte9UVxaApTRVoNxSSU66DXTqFfPvFbuf3uLvE7Cs2vFuswnY04VFhMh1SJqAd7aHNW+pDnlfHqQevlr/h3MPeFj7W96unZa98e8Fl3pVI8O5h7wsfa3vV08O5h7wsfa3vV07LXvj3gsu9KpHh3MPeFj7W96unh3MPeFj7W96unZa98e8Fl3pVI8O5h7wsfa3vV08O5h7wsfa3vV07LXvj3gsu9KpIvuX6jWBZNPPpLe9XUzjuSLur70GdFTAujCEuLZQ50ja0KJAW2vRO4aggggEHrGhSVYV6PXRGbVPpMFk7SlK5kKqPEk/7stI8xu0TUf+4Kt1VHiV+jbR87RP8AUFdWi99T6rG110pSulClKUClK4b1fLfjltduF1msW+C0UhciS4EISVKCUgk+cqUkAeckDz0HdSlKBSlKBSlRWV5Ta8Ixu4369Su8rTbmVSJUjo1OdG2nmTtQCo/uAJoJWlflp1L7SHEHchaQpJ90Gv1QKVwxL5b7hcp9vjTWJE63lsS47bgUuOVp3ICwPzSU8wD5iD567qBUTCOnE2AB1G0Stfj0ej6f5mpaomH/AGnW/wCZ5f8ArRqzp2Vek/ZlC80pSvJYlVHiV+jbR87RP9QVbqqPEr9G2j52if6grq0XvqfVY2uusy7pDMrrgnCC73SzS0264KeiQ0XBaAtMNL8ltlT5B5eQlwqGvLUDXlWm1xXuyQMktEy13WGzcLdMaUzIiyEBbbqCNClQPWK6J2IwPjXhdw4T8DMun2HN8teuj3eDbcy53hySthZmNJU42ToUFQWQpKSEkctANa4uK8LI8XyvBeHmNXa8zm8iVPuE2TcsmfiSZS2G2dGW5QbdUynylOFtpKR5J02jUHS7d3OHDy12a42pixOmDcEMtyG3rlKdJQ04HWkJUt0qQlK0ghKSB5tNOVWbO+G+N8TLYxAyS2IuLEd4SGFBxbTrDg6ltutqStCtCRqlQNYZZGEXFnNcSwpvGMqmXmZc75f0x8biWLJVGb0fQFxxqRcVMtq6NOx1e/aV6bU6q0qiZQ5fb93NvEqyZVcbiuTjGYQ4bC/DDkh1LKnoSg25JCW1PhPfCyFLTrqEHrQDX009wKwd/EY2Mrsp8Expff7ITMkJfbkc9XkyA50oWdxBVv1IJHUa827gVglpsN/ssXHWEWm/JSLnEU64tuSUp2hagpR0WRoSsaKUQCSSAamWRk3E9vJo/EfEuF+MzLm9a02aVd3FyspkwJk5xL6UBBndG88vYFlWwEahQ1VojQ6rwTs2Z2DEpEHNpbUya3Od7yWmcqa6mIdpbQ6+Wmi4tJKxuKASAnXU6165/c/YHdMdttkl2Z2RDtjy34TrlxlGVHWr84ok9L0ydeQIC9DoPcr3nCL7iNqt9n4fTLDYLLFQvWNdbbInLK1LK1KCxKbPMqJO7cSSTrWURMTcQndA3YmDjeOQ1X5y+324KagxbBdPBi3ujZW4500nQltpKAVHaNxISADzFYtbMqzOXw7t9iuORXW33GFxPaxlybGuRflCIoAlpUgoT0xAdKd6kAnakkait8lcMJeewO9eI7tovyYz6JNudscWVa3orgCkqUHRKWvUhQHkqTy1B115e+18B8EsjDbECwIiMN3Ri9JaakvJQJrKQlD+3foVaAbv2yNVbjzqTEzNxj9xyhzh3L4t4tLvmU3K1w12VNoSxclO3NMicVN9A1JeJUkKcbTzUTtClaeaqTf52V2nhr3QeH5E9NXHt+ORbhDjXC9Ku70bp0PhaTJW2hSgeiSdpB2nXQkGvqW+8I8SyVzInLnZkTF5C1GauRW85+WTHKiwRor8mpBUSFI2nXQ66gacFl4DYJj5uhh2BBVdYKrdcVSZL0gzWCSSl8uLV0p5kBa9VAHQEDlUyyM74m8S5PAzLI2SzZkmVjN7xt1hiE48pbLd0ioU8yltJOiS+2pxGidNymk686qF3suYcK04rfc9yTLJ+JwrVDRcJ9nvCkLt9wU8VPuy2SdZDClOJQD5WxKdAgDQ1qWWcDjf3cHxqIzbYfDzG5bF072fW9ImuPsKWWmUlZIDXlDVSlKJGqQAOdWbLeCOFZ1kTV8vtl8IXBtLSCVyn0tOJbUVthxlKw24EqJIC0nmaWmRlmA4L0nH7jfOt94usW7MPxDFLtzfXGS4/bwQp1gr2OJQpXkBQIQEgJ0AGkn3OMqfYbvc8SyyZkpzyPAjypzN6uhnw5SNy0GXDX+oha9QUEJKdEjbyJOjXjg7iF+y5WTzLSVXtbAjOyWZTzIfbCVJCXUIWEOaBSgCsEgHlTAeDuIcMZEuRjlo7ykym0MuvvSnpLnRoJKWwt1ailAJOiEkJ+KrFMxIudRMP+063/M8v/WjVLVEw/7Trf8AM8v/AFo1b6dlXpP2ZQvNKUryWJVR4lfo20fO0T/UFW6onJrH4wWoxkPd7yEONyGHincEOIWFpJGo1TqNCNRqCRqK34FUUYtNVWy6xtcVKhlXDImDsdxKW84OSlw5kZbRP90uOIUR+9IPxCvz4Wv3oZde1QvX16GT4o+qOpZN0qE8LX70MuvaoXr6eFr96GXXtUL19MnxR9UdVsm6VCeFr96GXXtUL19PC1+9DLr2qF6+mT4o+qOpZN0qE8LX70MuvaoXr65rplN1stsl3GbiVzjwojK5D7qpMMhDaUlSlHR/zAE0yfFH1R1LLJSq7b8kvF0gRpkfDrsqPIaS82pT8RJKVAEEgvgjkeojWq1iXGyDnWR5HYLHZp0+8Y7I71ucRL8VK47nPl5Tw3DUEap1GoI11pk+KPqjqWaPSoTwtfvQy69qhevp4Wv3oZde1QvX0yfFH1R1LJulQnha/ehl17VC9fTwtfvQy69qhevpk+KPqjqWTdKhPC1+9DLr2qF6+nha/ehl17VC9fTJ8UfVHUsm6iYf9p1v+Z5f+tGr1put+KgPE66J185lQ9B/++pXGrJOVdXLzdG0xZCmO9mIaF7+ibJClFahyKlEJ6uQCRzOpqTbDpqmZjZMapidvoRqWilKV5LEpSlApSlApSlApSlAqg8dFKf4Y3W2Nn8penI9kSNNdRLfbjq5aHqS6onloACTyBNX6s94lpFyzHhvaSCpC705cHgBqCiPEfUnXny0eUwfP1fxAaClIQkJSAlIGgAGgAr+dfc+9yzxtwzuibdm9zvFpsNwuD7lyvNtdkuuvPw1yNr7Si22thSyCFJT0h0JQeRHL+itV7IJht+SYy4qTNQ1Kfeg97x2t7K1KZU6lTx/UCegISr9pYT+tQWGlKUClKUClKUClKUClKUClKUClKUClKUClKUCs8vBErj7irSjqImOXV8J2jTcuRAQDr5tAlY+PcfcrQ6z+elbPH2xqO/o5OM3ADQeTq3Kh9Z938ry/j7lBoFV3NZIhx7Q6X7kyPCkVvS2oCive4EbXQf+V5XlHzAa+arFVdzGT0JsTIlz4i5F0YbSYDe/foFOFDh/VbUEEKP8PPQWKlKUClKUClKUClKUClKUClKhbxm2PY/KEa53y3W+SRu6GTKQhenu7SddKzpoqrm1MXlbXTVKq3spYd6U2jtrf209lLDvSm0dtb+2tvZ8bgn2lcs7lppVW9lLDvSm0dtb+2nspYd6U2jtrf207PjcE+0mWdy00qreylh3pTaO2t/bT2UsO9KbR21v7adnxuCfaTLO5aay7ixfrVhGecOsjvNyh2e3d9TbQ7NnPoYabD0Vb4ClrUAAVQ0j9+g89Wj2UsO9KbR21v7a+C/+0D4H2XiDksDiBg92t1yu81xmDeIMaWhbi9AENSQNepKQlCvcASfMo07PjcE+0mWdz+hthyC15TaY90styh3e2SASzNgPofZdAJSdq0kg6EEcj1g1G3+RuyjF4iZs2KsvvyVMxmdzUlCGFoKHl/qpCnULHnKkJ+Oqtw5v+B8OsCx/GIWUWYRrTBahpKZjY3lCQCrr61HU/wAa9y+KuJvZuykZewhiPbnCpkPtCG6px1G1Rc15uoDSgEg8kuEnrFOz43BPtJlnc0WlVb2UsO9KbR21v7aeylh3pTaO2t/bTs+NwT7SZZ3LTSqt7KWHelNo7a39tPZSw70ptHbW/tp2fG4J9pMs7lppVW9lLDvSm0dtb+2nspYd6U2jtrf207PjcE+0mWdy00qreylh3pTaO2t/bXsZ4mYjIcCG8mtC1HQACa35zoPP7pA/jTs+NwT7Slp3LLSlK50cV6mKt9nnSkAFbDDjqQfdSkkf5VUcSiNxrBCcA3PyWkPvvK5recUkFS1E8yST/Dq6hVnyr2sXj5G99Q1Xsa9rlq+SNfUFehgasKfVfBJUpSs0KUpQKUpQKUpQKUpQKUpQKUpQKUpQK8LQlxBStIUkjQpUNQa80oOTh2sMM3y2NkiJbLiY0ZvTk02phl4IT/dSXSAOoAAAAACrdVO4ffpPM/nhH9DEq41zaT3s/LnELO1F5V7WLx8je+oar2Ne1y1fJGvqCrDlXtYvHyN76hqvY17XLV8ka+oK34Pcz6/g8ElXzDYOOWTYGriVdbnYJmQYjaMxlR5d3euqekgxyWUhDDCgorQ3u3FO5AG47deen09WEX/gRf7rwn4t4u1MtqZ+XXqXcYLi3XA02270O0OkI1Ch0atQkKHMczUqv4IuKuL+2XxTZ8E+0dCF7u+f+N3Qkyv2Pyf52z9bq1+Kqkruib9c3+98fwRF1kIxiDk73T3lMdCGpCXCWQS0oqWOj8k6AK1OpRoN3nMuE2cKv/EpeLSrAbbnMRtD7l2W+l6C8iJ3sShCEEOJUhKDzUnadToocj1YPwWveM3OZIlSre4h7CbbjaQy4skSY6XgtZ1QPyZ6VOh6+R1SPPNdx+8E7oKdld5wlu44iuyWfNIrsmyTvCKH3VFDPTbHmggBvc2FKSQtfVodDyHox3ujXZfFi34NfrDb7RNuS32ophZBHuD7bjTanNslhACmdyEKIOqhqNNda/Nk4H3232nglEdnwm3MJhvRri7HdXqtS7cuKFMao56LWD5W3kNevlVYwbue82xeXw1ad8UWoGFzluKehdOJN0Q4y4y4+4oo0Q7o5vKPLClE+WkDnP7CfsvdKXS4QLLfJeEmDidxvpx83MXVDjzb/fS4yHOh6MatFxIBJUFAk+SQATu1YRG4EX9ngzZsRVMtpuULKU3xx0OudCWBdlTNoOzXf0agNNAN3LXTnV1Xx3xVtakljJtUnQ6YldiP8RGrKJttGa2nLMkundCcQJuTl+14jhMdpxAh351MdtosuOh12MhpIfU4jyiFqIb2hI3fnV7cL7sS0ZTk2PwZEK0xLfkD4jwHYeSRZs1paklTffURvymdwTodFL2qICtNauNv4VKv994pz7i8g4/ncCJGZbbDjcltoQ1MudIhaBsUd/Icz7oB5VzcLcI4hYtHtOPZEcSuGOWyL3n4ShtvpnzG0o2NFTZSENK0AKiFL156aa1NYptu7tfH7jdoDrca0qxufPbgMSW8ijLufludEh5dvHlpbKiD+cVhJ3FA0IqP488dcmvPDXPH8Nx+WxYLTJ8Gry1m7CK8mQ2+hDpYaCdy0JVqgr3p18rQECrnwo4YZ9wvZtOKJdxW54Xa3lIYuT6HhdFRdVKQ0psJ6PenUJ6TfoQn83WqrlXALiMcIzLAcen4w9iN6nvT4ci5OSG5kTppAkOMlKG1IUkL3bV666HmDWP9rD2tcW8zw7OOMMuPjMzMccst2ZdfPhdLbkKOIEdbiYzCwQvTyllIUgEq5akmrTxO7o1eC2O05DbrLbbtjFwtqLm1PnZCxbnX0KTv6OOy4kqdc2bVbdU67wAdajb5wp4lMXziSjHZ2MMWjNJQWuXOVIVKgN96NR1qS2lOxxXkKISVJAIGpOug4bn3N99s90lsYy5YJlpm4xExhEvIEuuSrU0w2tsqjpQnasLCwpSSpvykg6kVf7C43bjrIuN1sVowbGl5ZdrnZ2r+pEiamAxFhOHRpTjpSs71nUBCUk+SonQDWqVlHGqfgPGGRJvzExh6Rh0AxMRZmh7p7o9OfbQy1p5CnFaJSXAPzU6nkmu+w8HM/wABfxS+Y3Kx2RfYmMxMZvFvuTr6YkhEYktPsuobK0rGqtUqRoQrTXUan95R3OMnijmz9/zXwSuS7ibVnbk2zpA7BnpkuPd8RwseSE7mylRVu1SQQATq/tI3G0PzZNqiO3GK1BnuNJVIisv9MhpwjykJc2p3AHUbto19wV11B4Qzf4+JWpnKXIT+QtMJbmvW9Siw64ORcTuSkjdoFEaciSBqBqZytg4eH36TzP54R/QxKuNU7h9+k8z+eEf0MSrjXPpXefKPtCyi8q9rF4+RvfUNV7Gva5avkjX1BVhyr2sXj5G99Q1Xsa9rlq+SNfUFb8HuZ9fweCSpXonRTNgyI4ecjl5tTYeZVtWjUabknzEdYNR3iwx78uXbnfvVZmUTFKh/Fhj35cu3O/ep4sMe/Ll25371S87hMUqH8WGPfly7c796niwx78uXbnfvUvO4TFKh/Fhj35cu3O/ep4sMe/Ll25371LzuExSofxYY9+XLtzv3qeLDHvy5dud+9S87hMUqH8WGPfly7c796niwx78uXbnfvUvO4TFKh/Fhj35cu3O/ep4sMe/Ll25371LzuExSofxYY9+XLtzv3qeLDHvy5dud+9S87hMUrngwUW9ktIcedBO7c+6pxX+KiTXRVHDw+/SeZ/PCP6GJVxqncPv0nmfzwj+hiVca59K7z5R9oWUXlXtYvHyN76hqvY17XLV8ka+oKsOVe1i8fI3vqGq9jXtctXyRr6grfg9zPr+DwSVKUrJClVPivmq+HHDbJMnbirmOWuC5JS02lKiSByJSpaAoDrICgSAQnVRANSvvdBQsO8Ix7tYb1MfsceG5e5ltjNd6wy+gEK8t4KIBPNKQpYHPQjnWMzEDWaVmELjFIPEPObXcLI/b8VxdhpUm/uOMdE250BkOlz8tv29Epkp2tk81btvLWPf7puwQbddJs+w5Dbmodp8NsIkxmQ7OilxLaVNIDpUlSlLQAh0NqOvVyOjNA1+lZ5deMaLPNsVvfxHIlXe9rkiDbW0RS8tDCELU4o9PsbSQtIG9SSCdFBJIry7xtszFhu91cgXJLdtvjOPLYDbZdeluOMNAN6OaKSFyAkkkc0L0B0Gq8DQqVmDHdAWh67sRl2K+sW16+O46i9OMM95mah5bOzk6XNqnEFIXs26kAkHUDr4Q8S7rxJTkEmZjcqz26JdJMOBLdcYUiS2y6WV/mPLVvDjbup2hOm3aVczS8DRKVV3+KWFxcgFiey+wtXwvJjC2OXNlMkuqICW+iKt24kgBOmp1FV/jfnF1wq3YqmytyX7hdchhwe94bTbjz7I3PPtoDmiQVNMuJ3Ep27tdydNRbwNIpWXs90JYpcGEIlpvUu/ypsm3pxtthoT0PR9C+F7nA0lKApBKy5sIWjRR3Cq3kvGu45n7HsDC4t4hIyp+U4/cGGoSpMSPG3JeCEvuFveHejBVotOwqKd5KRUzQN0pWbWrjnZbjebVCat93Va7nOctcDI3GWhBmSm0uFSEEL6Tn0TgCy2EKKfJUdRryW3uiLJccRYybwHfY1nmuojWxx5hkuXN9bim0NR2kulZUopJBUEp2+Vu0BIZoGqUqrYBxAi8QIl1cZt060yrXOVbpsK4dEXWXkttuEatOOIUNrqDqlR6yDoQRVpqjh4ffpPM/nhH9DEq41TuH36TzP54R/QxKuNc+ld58o+0LKLyr2sXj5G99Q1Xsa9rlq+SNfUFWHKvaxePkb31DVexr2uWr5I19QVvwe5n1/B4OudIciQpD7UZ2a602paIzBQHHSBqEJK1JSCeoblAanmQOdVHx/vv/prlHabV+Nq60qozXK7fcuMGMz8Xm49ecRiySw47OuHeT7biG5DS1shLEpatXEJUnUjQAk8yAk+i/cEfD9uzSK9etqsovkO6SHe9dS3HjiKnvUDfzCkxiN/m6UnadOeo0qW3jKZXA565ReJdpnX9L+O5qp55yOiFslxHnGGmSoP9IUrSlLSdqS2NPOSBXFbO57biYW5YHH8fhF+6QJ0p/H8cRbUymo0ht7onEJdVqpZbIK9dAFHRHmrY6UywKxJwnvviXb8tcmbhBtMi2MQi1+aXnmnHHd+7rIYQnTb7vPzVn3sDXONOjl3K0O47Eyl7LPBzdpJkvuKdcfDK3umO4JcWkpKWwdEAEHkRtFKWgYFwc4RZDccOwiXl91DcKI/4xIx1NsMZ9qe8tx/SU6pxRWW3H1naEN+UBu121o3CPALjwzxc2GXe2b3DYedXDcTBMd1CFuLcIdPSLDi9yzqsBGv7NXelIiIFXf4c2qRkAvK5d+EsPJf6NvIbgiNuSQQO9w+GtvLmjZtPPUHU1F8R+Hl3y+/4tebPf41lmY+5IfZRLtxmNOOutdCFKSHWz5La3gAD1rB10SQq+Uq2gYJdu5QgTVWqcLjbrre2HJr1wk5PZG7nHnuyltrdcLG9sNqSWkBBSryUjaQoE1bbZiM5zjZFufg4Qsex3HVWmE4EIbbdffdacdLLaT5KEIYaTroBqoga6GtOpUywMZxrufZ1ktdhtMnKxMtGMNv+L8dFu6Jcd1bTjTb0hfSnp1todWE7Q2CVEkE6EdeUdz3AyHhVheGplRD4qmIuI7cbcmZFfUywpg9NHUoBaVIcXqN4IJBCtRWt0plgQeE4uzhuMQbSyxbmAwk7k2mAmFG3EkkoZSVBA59WpPuk1OUpVHDw+/SeZ/PCP6GJVxqncPv0nmfzwj+hiVca59K7z5R9oWUdkbK5GPXRptJU4uK6lKR5yUECq1i60uY1aVJOqVRGSD7o2CrtVTlcPk9O4u2Xu5WNlaisxYYYWyFHmSlLrS9up56JIGpJ051ng4lMUzRVNvE8LOmlcHiBcPTO9/QQvw9PEC4emd7+ghfh633w+OOfQt5u+lcHiBcPTO9/QQvw9PEC4emd7+ghfh6Xw+OOfQt5u+lcHiBcPTO9/QQvw9PEC4emd7+ghfh6Xw+OOfQt5u+lcHiBcPTO9/QQvw9PEC4emd7+ghfh6Xw+OOfQt5u+lVe8YvdIF8sMROfzY6Jz7ra2JMeIXnwllawlnRjQKBSFHXXyQrz1M+IFw9M739BC/D0vh8cc+hbzd9K4PEC4emd7+ghfh6eIFw9M739BC/D0vh8cc+hbzd9K4PEC4emd7+ghfh6eIFw9M739BC/D0vh8cc+hbzd9K4PEC4emd7+ghfh6eIFw9M739BC/D0vh8cc+hbzd9K4PEC4emd7+ghfh6/SMBmakO5denkHrT0cRGvP3UsAj+B89S+Hxxz6FvN54foInZa6Dqh27gpOh80SMg/8A5JUP4Vb65LVaotkt7MKEyGIzQISnUqJJJJUSdSpRJJKiSSSSSSTXXXFjVxiVzVGzpqJ1lKUrShSlKBSlKBSlKBSlKCvX+YY+S4uyJ0OMH5LyTHkNbnZOkdxW1pX6qhpuJ86UqHnqw1XcgkFrJsWbEu3sB2S+CzKRq+9pHcOjB/VUNNyv7oUKsVApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlBXcgecbybFkJkWtpDkl8Lbmj/aHQI7hAjf3gRqr+4FVYqruQuqRk+LIS/bm0rkv7m5be59wd7ucmD+qoHmo/shQ89WKgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUqo5bxPsuIPmI6p6fcgATBgpC3Eg9RUSQlH/Uoa+bWqW7x6uJJLOLMlOvLp7nsVp8YSyoD/E16OD+n6Vj058OjV8o+9ls2KlYz7PN49FYf83V+Hp7PN49FYf8AN1fh63/xGm8HOnqWZjxs7vLEOEvFmPi94xjIjMs0lZlrFujOl1tbCg2uKsyARuKknUgEpKhoDX1LYLsL/Yrdc0xZMETYzckRZiAl5nekK2OAEgKGuhAJGoPM18c8Y8Jg8ZuKuFZvdMahMv4+v/aYnhBS03FtJ3tNrJYG0JXqSdDqCRy662/2ebx6Kw/5ur8PT+I03g509SzZqVjPs83j0Vh/zdX4evI483fz4rE0/u3dRP8AT0/iNN4OdPUs2WlZtYuONpmuoZu8SRYnFEAPvKS5G1PmLifzf3rSkfHWkJUlaQpJCkkagg6givPxtHxdHnLi02LPNKUrnQpSlApSlApSlApSlAqlcU81dxKzMswVBN2uCy1HUUhXRJA1W6QeR2ggAHluUnUEa1dawrjO+t3iHHZUdUR7W2ttPPkXHXAs/wAeiR/hXqfpuBTpGk0017I1+yxvUxtsN7zqpa1qK3HFqKluLJ1KlE8ySeZJr9UpX6IwKUr57RxF4jZWbnesbgXR+OxOfjwrc3EgmC8hp0tkOuuPB8KVtOpSAE68goDU8+LjRhWvEzfcj6ErwpQQkqUQEgaknzVhuQ5ZmS2+J90hZF4PYxVzpotvMFlxLqUxGnlturIKikkq02kKBUfKI0AlXsjyXiLk15t9mvScYt1nt8V57ZEbkOSnpDRdAO8aJbSnQeToSSeY0rX2mmZtFM3+Wvb5+U7Vatb7jFu0JmZBkszYb6QtqRHcDjbiT1FKhyI+MV0Vn/c//wBiuGfNrX+VaBXRh1Z6Ka58YQq+8IcxctN0YxuUvdbpIUIBP/IcAKi1r+ypIJSP1SkgclJAoVeA8qLNtshH/isToziP3h5HL+PV/GtGlYFOk4NWHV8vKfBlTts+p6UpX5kpSlKBSlKBSlKBSlKBWRcc7CtqVa8hbTqyhJgyyB+alSgWln3AFbk/vdT8da7XpmQ2LjEfiymUSIz6FNOsuJCkrQRoUkHrBB00rs0TSJ0XGpxY8PssPluQp1Ed1TCEuvBJKELVtSpWnIE6HQa+fQ/uqpIvOeFQ3YpYwnXmRkDpIHZK2TK+E14sUhx6ytKvVsJ1SwHAJTA/Z8ogOJHmOoVpoCFHVRprjM1glL1puzCh1pctr4P1Of8ACvv8PSMLSaYqwsT7X+cSxyz4KX4az70TsX/yF38HXMxwhgw76/crfeb3Z2ZUsT5NqgTQiI6/qFKURt3DcR5QSoBXnFXrV/4PuX8vf+5TV/4PuX8vf+5W3JRP/Ob+34sZZ3KpJ4Z2uVBzKKt+WG8qChNKVp1b3MJYPReTy8lIPlbufxcqj7lwdtky6NXGHdrzZJfebcCSu2Sktd+NNghAdBQQSASApO1Q166ver/wfcv5e/8Acpq/8H3L+Xv/AHKTh4U7YgyzuUa12nIcAs9ux7G7JButnt0ZDDMq5XhTD6gB+slEZSf4g8/cFdHhrPvROx//ACB38HVx1f8Ag+5fy9/7lB3wo6JttzUfcTbnyT/DZTLERaK7R8uhlncjsflXiXDWu9W6JbZQcIS1DmKlIKNBooqU23oddRpoeoc+egtWF2FeT5laoaUkx4zqJ8pWnJKGlBSAfjU4EDTzgL9w1+7FguSZI6kR7U9bo5I3SrogsBI8+jZ/KE/FoB8YrbsOw6Fhdr71ilTzzh3yJTgHSPL906dQHUAOQH8SfK0/9Qw9Hwpw6Ks1c6vTzmyxFtaepSlfCBSlKBSlKBSlKBSlKBSlKBSlKBSlKBSlKBSlKBSlKBSlKBSlKBSlKD//2Q==",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "builder = StateGraph(GenerateAnalystsState)\n",
    "builder.add_node(\"create_analysts\", create_analysts)\n",
    "builder.add_node(\"human_feedback\", human_feedback)\n",
    "\n",
    "builder.add_edge(START, \"create_analysts\")\n",
    "builder.add_edge(\"create_analysts\", \"human_feedback\")\n",
    "builder.add_conditional_edges(\"human_feedback\", should_continue, [\"create_analysts\", END])\n",
    "\n",
    "memory = MemorySaver()\n",
    "graph = builder.compile(interrupt_before=[\"human_feedback\"], checkpointer=memory)\n",
    "\n",
    "display(Image(graph.get_graph(xray=1).draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "76134ad3-e039-46ac-992e-52e60faa69ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are you satisfied with generated analysts (yes/no):  yes\n"
     ]
    }
   ],
   "source": [
    "max_analysts = 3\n",
    "topic = \"how to create ec2 instance\"\n",
    "thread = {\"configurable\": {\"thread_id\": \"1\"}}\n",
    "\n",
    "graph.invoke({\"topic\": topic, \"max_analysts\": max_analysts, \"human_analyst_feedback\": \"\"}, thread)\n",
    "\n",
    "user_approval = input(\"Are you satisfied with generated analysts (yes/no): \")\n",
    "\n",
    "if user_approval.lower() == \"yes\":\n",
    "    result = graph.invoke(None, thread)  \n",
    "else:\n",
    "    user_feedback = input(\"How would you improve analyst creation: \")\n",
    "    graph.invoke({\"topic\": topic + \",\" + user_feedback, \"max_analysts\": max_analysts, \"human_analyst_feedback\": \"\"}, thread)\n",
    "    result = graph.invoke(None, thread)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "5ac338a9-0132-43f3-bf84-2f30e6b281da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'topic': 'how to create ec2 instance', 'max_analysts': 3, 'human_analyst_feedback': '', 'analysts': [Analyst(affiliation='Amazon Web Services', name='Alice Johnson', role='Cloud Solutions Architect', description='Alice specializes in cloud infrastructure and has extensive experience in deploying and managing EC2 instances. She focuses on best practices for scalability and cost optimization.'), Analyst(affiliation='Tech Innovations Inc.', name='Bob Smith', role='DevOps Engineer', description='Bob is a DevOps engineer with a passion for automation and continuous integration. He explores how to streamline the process of creating and managing EC2 instances using Infrastructure as Code.'), Analyst(affiliation='Cloud Security Group', name='Catherine Lee', role='Cloud Security Analyst', description='Catherine is a cloud security expert who emphasizes the importance of security when creating EC2 instances. She focuses on compliance, risk management, and securing cloud environments.')]}\n"
     ]
    }
   ],
   "source": [
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "2aeb0607-a16a-4ea1-acc8-d0f284037eae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = graph.get_state(thread)\n",
    "state.next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "3b7aa7a6-a9e2-4d88-be41-b321d0ed2904",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Alice Johnson\n",
      "Affiliation: Amazon Web Services\n",
      "Role: Cloud Solutions Architect\n",
      "Description: Alice specializes in cloud infrastructure and has extensive experience in deploying and managing EC2 instances. She focuses on best practices for scalability and cost optimization.\n",
      "--------------------------------------------------\n",
      "Name: Bob Smith\n",
      "Affiliation: Tech Innovations Inc.\n",
      "Role: DevOps Engineer\n",
      "Description: Bob is a DevOps engineer with a passion for automation and continuous integration. He explores how to streamline the process of creating and managing EC2 instances using Infrastructure as Code.\n",
      "--------------------------------------------------\n",
      "Name: Catherine Lee\n",
      "Affiliation: Cloud Security Group\n",
      "Role: Cloud Security Analyst\n",
      "Description: Catherine is a cloud security expert who emphasizes the importance of security when creating EC2 instances. She focuses on compliance, risk management, and securing cloud environments.\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "for analyst in result[\"analysts\"]:\n",
    "    print(f\"Name: {analyst.name}\")\n",
    "    print(f\"Affiliation: {analyst.affiliation}\")\n",
    "    print(f\"Role: {analyst.role}\")\n",
    "    print(f\"Description: {analyst.description}\")\n",
    "    print(\"-\" * 50)  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "685e22b7-1550-4a9f-97b3-6982f4b9868b",
   "metadata": {},
   "source": [
    "## Conduct Interview\n",
    "\n",
    "### Generate Question\n",
    "The analyst will ask questions to the expert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "677125ff-36ef-46f9-990a-3a59e07c8b92",
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "from typing import Annotated\n",
    "from langgraph.graph import MessagesState"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c334ffd1-67f4-447c-9dad-ee1a4ff6e570",
   "metadata": {},
   "outputs": [],
   "source": [
    "class InterviewState(MessagesState):\n",
    "    max_num_turns: int\n",
    "    context: Annotated[list, operator.add]\n",
    "    analyst: Analyst\n",
    "    interview: str\n",
    "    sections: str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "16ab479e-be75-4547-add9-e707493670c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SearchQuery(BaseModel):\n",
    "    search_query: str = Field(None, description=\"Search query for retrieval\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "4f6b1abd-df13-4db1-ab5b-7eba1a609031",
   "metadata": {},
   "outputs": [],
   "source": [
    "question_instructions = \"\"\"\n",
    "You are an analyst tasked with interviewing an expert to learn about a specific topic. \n",
    "\n",
    "Your goal is boil down to interesting and specific insights related to your topic.\n",
    "\n",
    "1. Interesting: Insights that people will find surprising or non-obvious.\n",
    "        \n",
    "2. Specific: Insights that avoid generalities and include specific examples from the expert.\n",
    "\n",
    "Here is your topic of focus and set of goals: {goals}\n",
    "        \n",
    "Begin by introducing yourself using a name that fits your persona, and then ask your question.\n",
    "\n",
    "Continue to ask questions to drill down and refine your understanding of the topic.\n",
    "        \n",
    "When you are satisfied with your understanding, complete the interview with: \"Thank you so much for your help!\"\n",
    "\n",
    "Remember to stay in character throughout your response, reflecting the persona and goals provided to you.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9dfc48a0-acbd-41ad-a7a4-ea2773142a4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_question(state: InterviewState):\n",
    "    \"\"\"\n",
    "    Node to generate a question\n",
    "    \"\"\"\n",
    "\n",
    "    analyst = state[\"analyst\"]\n",
    "    messages = state[\"messages\"]\n",
    "\n",
    "    system_message = question_instructions.format(goals=analyst.persona)\n",
    "    question = llm.invoke([SystemMessage(content=system_message)] + messages)\n",
    "\n",
    "    return {\"messages\": [question]}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4bed670-3faa-4f71-b73f-1154d61bf8bf",
   "metadata": {},
   "source": [
    "### Generate Answer: Parallelization\n",
    "The expert will gather information from multiple sources in parallel to answer questions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "810b1b44-1c8b-4365-b3ed-ed0be3034085",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_core.messages import get_buffer_string\n",
    "\n",
    "from langchain_community.tools.tavily_search import TavilySearchResults\n",
    "tavily_search = TavilySearchResults(max_results=3)\n",
    "\n",
    "from langchain_community.document_loaders import WikipediaLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8ebe8a57-0727-4d96-825a-6d7cc2145ce7",
   "metadata": {},
   "outputs": [],
   "source": [
    "search_instructions = SystemMessage(\n",
    "    content=\"\"\"\n",
    "    You will be given a conversation between an analyst and an expert.\n",
    "\n",
    "    Your goal is to generate a well-structured query for use in retrieval and / or web-search related to the conversation.\n",
    "\n",
    "    First, analyze the full conversation.\n",
    "\n",
    "    Pay particular attention to the final question posed by the analyst.\n",
    "\n",
    "    Convert this final question into a well-structred web search query\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5da0c322-7c22-4f45-9e3b-0a796e0d4e1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def search_web(state: InterviewState):\n",
    "    \n",
    "    \"\"\" \n",
    "    Retrieve docs from web search\n",
    "    \"\"\"\n",
    "\n",
    "    structured_llm = llm.with_structured_output(SearchQuery)\n",
    "    search_query = structured_llm.invoke([search_instructions]+state['messages'])\n",
    "    \n",
    "    search_docs = tavily_search.invoke(search_query.search_query)\n",
    "\n",
    "    formatted_search_docs = \"\\n\\n---\\n\\n\".join(\n",
    "        [\n",
    "            f'<Document href=\"{doc[\"url\"]}\"/>\\n{doc[\"content\"]}\\n</Document>'\n",
    "            for doc in search_docs\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    return {\"context\": [formatted_search_docs]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "812d570f-d6ff-459d-8058-01f03ea8fe84",
   "metadata": {},
   "outputs": [],
   "source": [
    "def search_wikipedia(state: InterviewState):\n",
    "    \n",
    "    \"\"\" \n",
    "    Retrieve docs from wikipedia\n",
    "    \"\"\"\n",
    "\n",
    "    structured_llm = llm.with_structured_output(SearchQuery)\n",
    "    search_query = structured_llm.invoke([search_instructions]+state['messages'])\n",
    "    \n",
    "    search_docs = WikipediaLoader(query=search_query.search_query, \n",
    "                                  load_max_docs=2).load()\n",
    "\n",
    "    formatted_search_docs = \"\\n\\n---\\n\\n\".join(\n",
    "        [\n",
    "            f'<Document source=\"{doc.metadata[\"source\"]}\" page=\"{doc.metadata.get(\"page\", \"\")}\"/>\\n{doc.page_content}\\n</Document>'\n",
    "            for doc in search_docs\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    return {\"context\": [formatted_search_docs]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "26e3bb4b-6b17-454c-b713-7a43c5118f3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer_instructions = \"\"\"\n",
    "You are an expert being interview by an analyst.\n",
    "\n",
    "Here is analyst area of focus: {goals}.\n",
    "\n",
    "Your goal is to answer a question posed by the interviewer.\n",
    "\n",
    "To answer question, use this context:\n",
    "{context}\n",
    "\n",
    "When answering questions, follow these guidelines:\n",
    "\n",
    "1. Use only the information provided in the context.\n",
    "\n",
    "2. Do not introduce external information or make assumptions beyond what is explicitly stated in the context.\n",
    "\n",
    "3. The context contain sources at the topic of each individual document.\n",
    "\n",
    "4. Include these sources your answer next to any relevant statements. For example, for source # 1 use [1]. \n",
    "\n",
    "5. List your sources in order at the bottom of your answer. [1] Source 1, [2] Source 2, etc\n",
    "        \n",
    "6. If the source is: <Document source=\"assistant/docs/llama3_1.pdf\" page=\"7\"/>' then just list: \n",
    "        \n",
    "[1] assistant/docs/llama3_1.pdf, page 7 \n",
    "        \n",
    "And skip the addition of the brackets as well as the Document source preamble in your citation.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "6b9b25a5-6624-4a0e-ad9d-454b779c094e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_answer(state: InterviewState):\n",
    "    \"\"\"\n",
    "    Node to answer a question\n",
    "    \"\"\"\n",
    "\n",
    "    analyst = state[\"analyst\"]\n",
    "    messages = state[\"messages\"]\n",
    "    context = state[\"context\"]\n",
    "\n",
    "    system_message = answer_instructions.format(goals=analyst.persona, context=context)\n",
    "    answer = llm.invoke([SystemMessage(system_message)] + messages)\n",
    "\n",
    "    answer.name = \"expert\"\n",
    "    \n",
    "    return {\"messages\": [answer]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b848cf05-e112-468b-b0a5-5984be6eb1d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_interview(state: InterviewState):\n",
    "    \"\"\"\n",
    "    Save interviews\n",
    "    \"\"\"\n",
    "\n",
    "    messages = state[\"messages\"]\n",
    "    interview = get_buffer_string(messages)\n",
    "\n",
    "    return {\"interview\": interview}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "e5b93a23-75b7-48e0-8428-772fdb6027ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "def route_messages(state: InterviewState, name: str = \"expert\"):\n",
    "    \"\"\"\n",
    "    Route between question and answer\n",
    "    \"\"\"\n",
    "\n",
    "    messages = state[\"messages\"]\n",
    "    max_num_turns = state.get(\"max_num_turns\", 2)\n",
    "\n",
    "    num_responses = len(\n",
    "        [m for m in messages if isinstance(m, AIMessage) and m.name == name]\n",
    "    )\n",
    "\n",
    "    if num_responses >= max_num_turns:\n",
    "        return \"save_interview\"\n",
    "\n",
    "    last_question = messages[-2]\n",
    "\n",
    "    if \"Thank you so much for your help\" in last_question.content:\n",
    "        return 'save_interview'\n",
    "    return \"ask_question\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "00c11850-60e0-4c97-8f48-2d8f3100e5e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "section_writer_instructions = \"\"\"\n",
    "You are an expert technical writer. \n",
    "            \n",
    "Your task is to create a short, easily digestible section of a report based on a set of source documents.\n",
    "\n",
    "1. Analyze the content of the source documents: \n",
    "- The name of each source document is at the start of the document, with the <Document tag.\n",
    "        \n",
    "2. Create a report structure using markdown formatting:\n",
    "- Use ## for the section title\n",
    "- Use ### for sub-section headers\n",
    "        \n",
    "3. Write the report following this structure:\n",
    "a. Title (## header)\n",
    "b. Summary (### header)\n",
    "c. Sources (### header)\n",
    "\n",
    "4. Make your title engaging based upon the focus area of the analyst: \n",
    "{focus}\n",
    "\n",
    "5. For the summary section:\n",
    "- Set up summary with general background / context related to the focus area of the analyst\n",
    "- Emphasize what is novel, interesting, or surprising about insights gathered from the interview\n",
    "- Create a numbered list of source documents, as you use them\n",
    "- Do not mention the names of interviewers or experts\n",
    "- Aim for approximately 400 words maximum\n",
    "- Use numbered sources in your report (e.g., [1], [2]) based on information from source documents\n",
    "        \n",
    "6. In the Sources section:\n",
    "- Include all sources used in your report\n",
    "- Provide full links to relevant websites or specific document paths\n",
    "- Separate each source by a newline. Use two spaces at the end of each line to create a newline in Markdown.\n",
    "- It will look like:\n",
    "\n",
    "### Sources\n",
    "[1] Link or Document name\n",
    "[2] Link or Document name\n",
    "\n",
    "7. Be sure to combine sources. For example this is not correct:\n",
    "\n",
    "[3] https://ai.meta.com/blog/meta-llama-3-1/\n",
    "[4] https://ai.meta.com/blog/meta-llama-3-1/\n",
    "\n",
    "There should be no redundant sources. It should simply be:\n",
    "\n",
    "[3] https://ai.meta.com/blog/meta-llama-3-1/\n",
    "        \n",
    "8. Final review:\n",
    "- Ensure the report follows the required structure\n",
    "- Include no preamble before the title of the report\n",
    "- Check that all guidelines have been followed\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "d1e98ca5-f7d2-4a95-82c2-36e090a9a6c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_section(state: InterviewState):\n",
    "\n",
    "    \"\"\" \n",
    "    Node to answer a question \n",
    "    \"\"\"\n",
    "    \n",
    "    interview = state[\"interview\"]\n",
    "    context = state[\"context\"]\n",
    "    analyst = state[\"analyst\"]\n",
    "    \n",
    "    system_message = section_writer_instructions.format(focus=analyst.description)\n",
    "    section = llm.invoke([SystemMessage(content=system_message)]+[HumanMessage(content=f\"Use this source to write your section: {context}\")]) \n",
    "                \n",
    "    return {\"sections\": [section.content]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "00f0e94d-296f-4db9-85ad-10f7353ff0d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "interview_builder = StateGraph(InterviewState)\n",
    "interview_builder.add_node(\"ask_question\", generate_question)\n",
    "interview_builder.add_node(\"search_web\", search_web)\n",
    "interview_builder.add_node(\"search_wikipedia\", search_wikipedia)\n",
    "interview_builder.add_node(\"answer_question\", generate_answer)\n",
    "interview_builder.add_node(\"save_interview\", save_interview)\n",
    "interview_builder.add_node(\"write_section\", write_section)\n",
    "\n",
    "interview_builder.add_edge(START, \"ask_question\")\n",
    "interview_builder.add_edge(\"ask_question\", \"search_web\")\n",
    "interview_builder.add_edge(\"ask_question\", \"search_wikipedia\")\n",
    "interview_builder.add_edge(\"search_web\", \"answer_question\")\n",
    "interview_builder.add_edge(\"search_wikipedia\", \"answer_question\")\n",
    "interview_builder.add_conditional_edges(\"answer_question\", route_messages,['ask_question','save_interview'])\n",
    "interview_builder.add_edge(\"save_interview\", \"write_section\")\n",
    "interview_builder.add_edge(\"write_section\", END)\n",
    "\n",
    "memory = MemorySaver()\n",
    "interview_graph = interview_builder.compile(checkpointer=memory).with_config(run_name=\"Conduct Interviews\")\n",
    "\n",
    "display(Image(interview_graph.get_graph().draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "631ad07a-967f-4014-b575-db31705c8b1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Analyst(affiliation='Amazon Web Services', name='Alice Johnson', role='Cloud Solutions Architect', description='Alice specializes in cloud infrastructure and has extensive experience in deploying and managing EC2 instances. She focuses on best practices for scalability and cost optimization.')"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "analysts = result[\"analysts\"]\n",
    "analysts[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "5d125a49-1390-4df9-af93-82a37dcaf7d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "## Maximizing Efficiency: Best Practices for EC2 Cost Optimization\n",
       "\n",
       "### Summary\n",
       "In the realm of cloud infrastructure, particularly with Amazon EC2, cost optimization is a critical focus for organizations aiming to balance performance and expenditure. As businesses increasingly migrate to the cloud, understanding how to effectively manage costs while ensuring scalability becomes paramount. This report synthesizes insights from various sources on best practices for optimizing EC2 costs, revealing novel strategies that can lead to significant savings without compromising performance.\n",
       "\n",
       "One of the most surprising insights is the effectiveness of **auto-scaling**. This technique allows organizations to automatically adjust the capacity of their EC2 instances based on real-time workload demands. By scaling down during periods of low demand, businesses can avoid unnecessary costs associated with idle resources, thus enhancing fault tolerance at minimal expense [1][4]. \n",
       "\n",
       "Another fundamental principle is **rightsizing**. This involves selecting instance types that closely match workload requirements, thereby preventing overprovisioning. For instance, a web application hosted on EC2 can benefit from careful analysis to ensure that the chosen instance types are not only sufficient but also cost-effective [2]. \n",
       "\n",
       "Moreover, monitoring less utilized EC2 instances is crucial. By evaluating resource usage, organizations can identify underperforming instances and either terminate or resize them, leading to substantial savings [3]. The use of reserved and spot instances is also highlighted as a strategic approach to further reduce costs while maintaining necessary performance levels [2][3].\n",
       "\n",
       "In summary, the combination of auto-scaling, rightsizing, and diligent monitoring of resource utilization forms a robust framework for EC2 cost optimization. These practices not only help in managing expenses but also ensure that businesses can scale their operations efficiently in response to changing demands.\n",
       "\n",
       "### Sources\n",
       "[1] https://blog.economize.cloud/ec2-cost-optimization/  \n",
       "[2] https://community.aws/content/2hQNGTh6vpwOHTgKELzL8mkqmKb/ec2-cost-optimization-15-ways-to-save-on-amazon-ec2  \n",
       "[3] https://www.lucidity.cloud/blog/aws-ec2-cost-optimization  \n",
       "[4] https://www.prosperops.com/blog/aws-auto-scaling  "
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Markdown\n",
    "\n",
    "messages = [HumanMessage(f\"So you said you were writing article on {topic}?\")]\n",
    "thread = {\"configurable\": {\"thread_id\": \"1\"}}\n",
    "interview = interview_graph.invoke({\"analyst\": analysts[0], \"messages\": messages, \"max_num_turns\": 2}, thread)\n",
    "Markdown(interview['sections'][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e5f5874-2852-4d81-91ad-0fea0c288d7b",
   "metadata": {},
   "source": [
    "### Parallelze interviews: Map-Reduce\n",
    "\n",
    "We parallelize the interviews via the `Send()` API, a map step.\n",
    "\n",
    "We combine them into the report body in a reduce step.\n",
    "\n",
    "### Finalize\n",
    "\n",
    "We add a final step to write an intro and conclusion to the final report."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "3945ac4e-87c1-432f-a4e0-f8e6f6680d0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "from typing import List, Annotated\n",
    "from typing_extensions import TypedDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "f1386698-462a-4ad7-811e-cde64612d6d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResearchGraphState(TypedDict):\n",
    "    topic: str \n",
    "    max_analysts: int \n",
    "    human_analyst_feedback: str \n",
    "    analysts: List[Analyst] \n",
    "    sections: Annotated[list, operator.add]\n",
    "    introduction: str \n",
    "    content: str \n",
    "    conclusion: str\n",
    "    final_report: str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "67486949-99cb-49ef-87b0-17fd40d7c2ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.constants import Send"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "d89d74a4-0cb6-4077-b2dd-cdd3607b7115",
   "metadata": {},
   "outputs": [],
   "source": [
    "def initiate_all_interviews(state: ResearchGraphState):\n",
    "    \"\"\"\n",
    "    This is the \"map\" step where we run each interview sub-graph using Send API\n",
    "    \"\"\"\n",
    "\n",
    "    human_analyst_feedback=state.get('human_analyst_feedback')\n",
    "    if human_analyst_feedback:\n",
    "        # Return to create_analysts\n",
    "        return \"create_analysts\"\n",
    "\n",
    "   \n",
    "    else:\n",
    "        topic = state[\"topic\"]\n",
    "        return [Send(\"conduct_interview\", \n",
    "                     {\"analyst\": analyst,\n",
    "                      \"messages\": [HumanMessage(content=f\"So you said you were writing an article on {topic}?\")]\n",
    "                     }) for analyst in state[\"analysts\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "7b4a8646-7bc1-4801-ac62-5a3d1b594989",
   "metadata": {},
   "outputs": [],
   "source": [
    "report_writer_instructions = \"\"\"\n",
    "You are a technical writer creating a report on this overall topic: \n",
    "\n",
    "{topic}\n",
    "    \n",
    "You have a team of analysts. Each analyst has done two things: \n",
    "\n",
    "1. They conducted an interview with an expert on a specific sub-topic.\n",
    "2. They write up their finding into a memo.\n",
    "\n",
    "Your task: \n",
    "\n",
    "1. You will be given a collection of memos from your analysts.\n",
    "2. Think carefully about the insights from each memo.\n",
    "3. Consolidate these into a crisp overall summary that ties together the central ideas from all of the memos. \n",
    "4. Summarize the central points in each memo into a cohesive single narrative.\n",
    "\n",
    "To format your report:\n",
    " \n",
    "1. Use markdown formatting. \n",
    "2. Include no pre-amble for the report.\n",
    "3. Use no sub-heading. \n",
    "4. Start your report with a single title header: ## Insights\n",
    "5. Do not mention any analyst names in your report.\n",
    "6. Preserve any citations in the memos, which will be annotated in brackets, for example [1] or [2].\n",
    "7. Create a final, consolidated list of sources and add to a Sources section with the `## Sources` header.\n",
    "8. List your sources in order and do not repeat.\n",
    "\n",
    "[1] Source 1\n",
    "[2] Source 2\n",
    "\n",
    "Here are the memos from your analysts to build your report from: \n",
    "\n",
    "{context}\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "5ca7edc5-42c2-41fc-bffd-de4c70cdcb82",
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_report(state: ResearchGraphState):\n",
    "    \n",
    "    sections = state[\"sections\"]\n",
    "    topic = state[\"topic\"]\n",
    "\n",
    "    formatted_str_sections = \"\\n\\n\".join([f\"{section}\" for section in sections])\n",
    "    \n",
    "    system_message = report_writer_instructions.format(topic=topic, context=formatted_str_sections)    \n",
    "    report = llm.invoke([SystemMessage(content=system_message)]+[HumanMessage(content=f\"Write a report based upon these memos.\")])\n",
    "    \n",
    "    return {\"content\": report.content}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "933b41e3-1ef7-45da-83a4-87452ee359a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "intro_conclusion_instructions = \"\"\"\n",
    "You are a technical writer finishing a report on {topic}\n",
    "\n",
    "You will be given all of the sections of the report.\n",
    "\n",
    "You job is to write a crisp and compelling introduction or conclusion section.\n",
    "\n",
    "The user will instruct you whether to write the introduction or conclusion.\n",
    "\n",
    "Include no pre-amble for either section.\n",
    "\n",
    "Target around 100 words, crisply previewing (for introduction) or recapping (for conclusion) all of the sections of the report.\n",
    "\n",
    "Use markdown formatting. \n",
    "\n",
    "For your introduction, create a compelling title and use the # header for the title.\n",
    "\n",
    "For your introduction, use ## Introduction as the section header. \n",
    "\n",
    "For your conclusion, use ## Conclusion as the section header.\n",
    "\n",
    "Here are the sections to reflect on for writing: {formatted_str_sections}\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "ac929961-19a7-4a22-be5f-c52ee2618b7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_introduction(state: ResearchGraphState):\n",
    "\n",
    "    sections = state[\"sections\"]\n",
    "    topic = state[\"topic\"]\n",
    "\n",
    "    formatted_str_sections = \"\\n\\n\".join([f\"{section}\" for section in sections])\n",
    "    \n",
    "    instructions = intro_conclusion_instructions.format(topic=topic, formatted_str_sections=formatted_str_sections)    \n",
    "    intro = llm.invoke([instructions]+[HumanMessage(content=f\"Write the report introduction\")]) \n",
    "    \n",
    "    return {\"introduction\": intro.content}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "0b73c223-ce3e-4982-b71f-86b894fdaa50",
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_conclusion(state: ResearchGraphState):\n",
    "\n",
    "    sections = state[\"sections\"]\n",
    "    topic = state[\"topic\"]\n",
    "\n",
    "    formatted_str_sections = \"\\n\\n\".join([f\"{section}\" for section in sections])\n",
    "    \n",
    "    instructions = intro_conclusion_instructions.format(topic=topic, formatted_str_sections=formatted_str_sections)    \n",
    "    conclusion = llm.invoke([instructions]+[HumanMessage(content=f\"Write the report conclusion\")]) \n",
    "    \n",
    "    return {\"conclusion\": conclusion.content}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "a30c71dc-128a-43fe-b2e3-b8eccb49ef9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def finalize_report(state: ResearchGraphState):\n",
    "    \"\"\" \n",
    "    The is the \"reduce\" step where we gather all the sections, combine them, and reflect on them to write the intro/conclusion \n",
    "    \"\"\"\n",
    "    \n",
    "    content = state[\"content\"]\n",
    "    if content.startswith(\"## Insights\"):\n",
    "        content = content.strip(\"## Insights\")\n",
    "    if \"## Sources\" in content:\n",
    "        try:\n",
    "            content, sources = content.split(\"\\n## Sources\\n\")\n",
    "        except:\n",
    "            sources = None\n",
    "    else:\n",
    "        sources = None\n",
    "\n",
    "    final_report = state[\"introduction\"] + \"\\n\\n---\\n\\n\" + content + \"\\n\\n---\\n\\n\" + state[\"conclusion\"]\n",
    "    if sources is not None:\n",
    "        final_report += \"\\n\\n## Sources\\n\" + sources\n",
    "        \n",
    "    return {\"final_report\": final_report}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "c3e1f6ca-a1d3-47bd-a9bc-801e5e4d25d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "builder = StateGraph(ResearchGraphState)\n",
    "builder.add_node(\"create_analysts\", create_analysts)\n",
    "builder.add_node(\"human_feedback\", human_feedback)\n",
    "builder.add_node(\"conduct_interview\", interview_builder.compile())\n",
    "builder.add_node(\"write_report\",write_report)\n",
    "builder.add_node(\"write_introduction\",write_introduction)\n",
    "builder.add_node(\"write_conclusion\",write_conclusion)\n",
    "builder.add_node(\"finalize_report\",finalize_report)\n",
    "\n",
    "builder.add_edge(START, \"create_analysts\")\n",
    "builder.add_edge(\"create_analysts\", \"human_feedback\")\n",
    "builder.add_conditional_edges(\"human_feedback\", initiate_all_interviews, [\"create_analysts\", \"conduct_interview\"])\n",
    "builder.add_edge(\"conduct_interview\", \"write_report\")\n",
    "builder.add_edge(\"conduct_interview\", \"write_introduction\")\n",
    "builder.add_edge(\"conduct_interview\", \"write_conclusion\")\n",
    "builder.add_edge([\"write_conclusion\", \"write_report\", \"write_introduction\"], \"finalize_report\")\n",
    "builder.add_edge(\"finalize_report\", END)\n",
    "\n",
    "memory = MemorySaver()\n",
    "graph = builder.compile(interrupt_before=['human_feedback'], checkpointer=memory)\n",
    "\n",
    "display(Image(graph.get_graph(xray=1).draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "58d40712-39cd-4ce6-9925-bf43fceb8dfb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are you satisfied with generated analysts (yes/no):  no\n",
      "How would you improve analyst creation:  Add in the CEO of gen ai native startup\n"
     ]
    }
   ],
   "source": [
    "max_analysts = 3\n",
    "topic = \"how to create ec2 instance\"\n",
    "thread = {\"configurable\": {\"thread_id\": \"1\"}}\n",
    "\n",
    "graph.invoke({\"topic\": topic, \"max_analysts\": max_analysts, \"human_analyst_feedback\": \"\"}, thread)\n",
    "\n",
    "user_approval = input(\"Are you satisfied with generated analysts (yes/no): \")\n",
    "\n",
    "if user_approval.lower() == \"yes\":\n",
    "    result = graph.invoke(None, thread)  \n",
    "else:\n",
    "    user_feedback = input(\"How would you improve analyst creation: \")\n",
    "    graph.invoke({\"topic\": topic + \",\" + user_feedback, \"max_analysts\": max_analysts, \"human_analyst_feedback\": \"\"}, thread)\n",
    "    result = graph.invoke(None, thread)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "80487e96-a7b9-4b70-bfd4-32e77809ee29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "# Transforming Cloud Management: The Role of AI in EC2 Optimization\n",
       "\n",
       "## Introduction\n",
       "\n",
       "As businesses increasingly rely on cloud computing, the integration of artificial intelligence (AI) into Amazon Web Services (AWS) is reshaping the management of Amazon Elastic Compute Cloud (EC2) instances. This report explores innovative cloud solutions that leverage AI for optimized EC2 management, highlighting advancements such as the unique DL1 instance type and Amazon Elastic Inference, which significantly reduce operational costs. We also address common challenges in EC2 management and present best practices for overcoming them. By examining the intersection of AI and cloud computing, this report underscores the potential for enhanced efficiency and cost-effectiveness in managing EC2 instances, ultimately driving business growth and technological advancement.\n",
       "\n",
       "---\n",
       "\n",
       "\n",
       "The integration of artificial intelligence (AI) with Amazon Web Services (AWS) is significantly transforming the management and deployment of Amazon Elastic Compute Cloud (EC2) instances. Recent advancements in AI technologies are streamlining processes, enhancing performance, and reducing operational costs, making cloud infrastructure more efficient and cost-effective.\n",
       "\n",
       "One of the key innovations is the introduction of specialized EC2 instance types, such as the DL1 instances utilizing Habana Gaudi chips for deep learning, and the M7i instances powered by 4th Gen Intel® Xeon® Scalable processors, which can reduce inference costs by up to 2.5 times compared to previous models [1]. Additionally, the EC2 DL2q instances, equipped with Qualcomm AI 100 Standard accelerators, facilitate cost-efficient deployment of deep learning workloads, ensuring performance and accuracy during transitions to Qualcomm devices [2]. The collaboration between AWS and NVIDIA has also led to the development of EC2 P5 instances, optimized for training large machine learning models, which can improve training times by up to four times [3].\n",
       "\n",
       "AI-driven automation tools are emerging as essential components in infrastructure management. These tools can automate the provisioning of EC2 instances, RDS databases, and S3 buckets, leading to more efficient resource management and cost optimization [4]. Intelligent automation can also manage power cycles of development instances, ensuring resources are utilized only when necessary [5]. Furthermore, integrating AI with infrastructure management tools like Terraform enhances data-driven decision-making regarding instance utilization, such as recommending downsizing underutilized instances [6].\n",
       "\n",
       "However, managing EC2 instances is not without challenges. Common issues include failures to launch instances due to misconfigurations or resource limitations, and the importance of selecting the appropriate Amazon Machine Image (AMI) for instance connectivity [1]. Users must also be cautious of Free Tier usage limits to avoid unexpected charges [2]. Best practices for managing EC2 instances include right-sizing based on workload characteristics, utilizing Spot Instances for cost savings, and continuously monitoring performance [3][4]. Understanding the different EC2 instance families—General Purpose, Compute-Optimized, and Memory-Optimized—can help users make informed decisions tailored to their specific application needs [5].\n",
       "\n",
       "In summary, the intersection of AI and cloud computing is paving the way for more efficient, cost-effective, and innovative solutions in managing EC2 instances. As organizations continue to explore these advancements, the ability to deploy flexible and specialized resources will be crucial for optimizing cloud expenditures and enhancing operational performance.\n",
       "\n",
       "\n",
       "---\n",
       "\n",
       "## Conclusion\n",
       "\n",
       "In conclusion, the integration of artificial intelligence with Amazon EC2 is reshaping cloud infrastructure management, offering innovative solutions that enhance efficiency and reduce costs. This report has explored the transformative impact of AI on EC2 instance management, highlighting advancements such as the DL1 instance type and Amazon Elastic Inference, which significantly lower operational expenses. We also examined common challenges users face with EC2 and best practices for optimizing performance and cost. As organizations increasingly adopt AI-driven automation tools and specialized instance types, they can expect improved resource management and accelerated innovation, positioning themselves for success in a competitive landscape.\n",
       "\n",
       "## Sources\n",
       "[1] https://www.intel.com/content/www/us/en/developer/articles/technical/accelerate-your-ai-software-workloads-on-aws.html  \n",
       "[2] https://aws.amazon.com/blogs/machine-learning/optimizing-costs-for-machine-learning-with-amazon-sagemaker/  \n",
       "[3] https://aws.amazon.com/ec2/instance-types/inf1/  \n",
       "[4] https://www.linkedin.com/pulse/aws-infrastructure-automation-services-using-ai-tools-lcsuc/  \n",
       "[5] https://nuvento.com/blog/leveraging-ai-for-efficient-cloud-management/  \n",
       "[6] https://medium.com/@shane.digital.ai/automating-aws-provisioning-with-terraform-using-claude-ai-powered-provisioning-7b72a5a56ade  \n",
       "[7] https://aws.plainenglish.io/what-are-the-common-issues-in-aws-ec2-instances-20adce409a7c  \n",
       "[8] https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html  \n",
       "[9] https://hands-on.cloud/amazon-ec2-instance-types/  \n",
       "[10] https://aws.amazon.com/blogs/aws/choosing-the-right-ec2-instance-type-for-your-application/  \n",
       "[11] https://medium.com/@bilal325/comparing-ec2-instance-types-finding-the-right-fit-for-your-workload-701d454031f  \n",
       "[12] https://community.intel.com/t5/Blogs/Tech-Innovation/Cloud/Flexible-and-cost-effective-LLM-deployment-with-Amazon-EC2-M7i/post/1590028  \n",
       "[13] https://aws.amazon.com/blogs/machine-learning/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/  \n",
       "[14] https://press.aboutamazon.com/2023/3/aws-and-nvidia-collaborate-on-next-generation-infrastructure-for-training-large-machine-learning-models-and-building-generative-ai-applications  \n",
       "[15] https://en.wikipedia.org/wiki/Amazon_Elastic_Compute_Cloud  \n",
       "[16] https://opsiocloud.com/resource/blog/ec2-cost-optimization-maximizing-aws-efficiency/  \n",
       "[17] https://www.toptal.com/aws/aws-cost-optimization-at-scale"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Markdown\n",
    "final_state = graph.get_state(thread)\n",
    "report = final_state.values.get('final_report')\n",
    "Markdown(report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80de46c5-622f-4485-a365-b6a1f4121dec",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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": 5
}