examples/document_workflows/patient_case_summary/patient_case_summary.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a65d3850-3ddb-4db3-87fe-fa7d92e6c55b",
   "metadata": {},
   "source": [
    "# Patient Case Summary Workflow\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/run-llama/llamacloud-demo/blob/main/examples/document_workflows/patient_case_summary/patient_case_summary.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
    "\n",
    "This tutorial shows you how to build an agentic workflow that can extract key details from a given patient, check clinical guidelines to see whether the patient's status meets recommended care standards, and then produce a human-readable case summary that a clinician can review.\n",
    "\n",
    "![](patient_case_summary.png)\n",
    "\n",
    "We use [Synthea](https://github.com/synthetichealth/synthea) to generate synthetic patient data, which contains a comprehensive set of information surrounding the patient. This includes, among other attributes, active patient conditions, encounters, and medications.\n",
    "\n",
    "Given a sample patient, we extract out the relevant information, and use it to retrieve relevant medical guidelines that provide recommendations on continued treatment, and present it to a clinician."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87c5f0d7-c884-475a-88ff-4b7057bb91a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install llama-index llama-index-indices-managed-llama-cloud llama-cloud llama-parse "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "8fe98ed0-cfcb-4c37-ac5a-7140d79fefd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import nest_asyncio\n",
    "\n",
    "nest_asyncio.apply()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d76541e7-65d3-4c70-afcd-49658bc00954",
   "metadata": {},
   "source": [
    "## Setup\n",
    "\n",
    "We define code snippets which will parse a patient bundle and extract out relevant fields of interest, including:\n",
    "1. Patient demographics\n",
    "2. Condition\n",
    "3. Medication request\n",
    "4. Observation (vital signs)\n",
    "5. Immunization & Procedures\n",
    "\n",
    "\n",
    "We also setup an index for relevant clinical guidelines (e.g. ADA for diabetes). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "89fc744f-04fa-4e07-a14e-93083c65af62",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List, Optional\n",
    "from pydantic import BaseModel, Field\n",
    "\n",
    "class ConditionInfo(BaseModel):\n",
    "    code: str\n",
    "    display: str\n",
    "    clinical_status: str\n",
    "\n",
    "class EncounterInfo(BaseModel):\n",
    "    date: str = Field(..., description=\"Date of the encounter.\")\n",
    "    reason_display: Optional[str] = Field(None, description=\"Reason for the encounter.\")\n",
    "    type_display: Optional[str] = Field(None, description=\"Type or class of the encounter.\")\n",
    "\n",
    "class MedicationInfo(BaseModel):\n",
    "    name: str = Field(..., description=\"Name of the medication.\")\n",
    "    start_date: Optional[str] = Field(None, description=\"When the medication was prescribed.\")\n",
    "    instructions: Optional[str] = Field(None, description=\"Dosage instructions.\")\n",
    "\n",
    "class PatientInfo(BaseModel):\n",
    "    given_name: str\n",
    "    family_name: str\n",
    "    birth_date: str\n",
    "    gender: str\n",
    "    conditions: List[ConditionInfo] = Field(default_factory=list)\n",
    "    recent_encounters: List[EncounterInfo] = Field(default_factory=list, description=\"A few recent encounters.\")\n",
    "    current_medications: List[MedicationInfo] = Field(default_factory=list, description=\"Current active medications.\")\n",
    "\n",
    "    @property\n",
    "    def demographic_str(self) -> str:\n",
    "        \"\"\"Get demographics string.\"\"\"\n",
    "        return f\"\"\"\\\n",
    "Given name: {self.given_name}\n",
    "Family name: {self.family_name}\n",
    "Birth date: {self.birth_date}\n",
    "Gender: {self.gender}\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "bec87b1f-74e5-41e6-b482-ce077aeddb7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_synthea_patient(file_path: str, filter_active: bool = True) -> PatientInfo:\n",
    "    # Load the Synthea-generated FHIR Bundle\n",
    "    with open(file_path, \"r\") as f:\n",
    "        bundle = json.load(f)\n",
    "\n",
    "    patient_resource = None\n",
    "    conditions = []\n",
    "    encounters = []\n",
    "    medication_requests = []\n",
    "\n",
    "    for entry in bundle.get(\"entry\", []):\n",
    "        resource = entry.get(\"resource\", {})\n",
    "        resource_type = resource.get(\"resourceType\")\n",
    "\n",
    "        if resource_type == \"Patient\":\n",
    "            patient_resource = resource\n",
    "        elif resource_type == \"Condition\":\n",
    "            conditions.append(resource)\n",
    "        elif resource_type == \"Encounter\":\n",
    "            encounters.append(resource)\n",
    "        elif resource_type == \"MedicationRequest\":\n",
    "            medication_requests.append(resource)\n",
    "\n",
    "    if not patient_resource:\n",
    "        raise ValueError(\"No Patient resource found in the provided file.\")\n",
    "\n",
    "    # Extract patient demographics\n",
    "    name_entry = patient_resource.get(\"name\", [{}])[0]\n",
    "    given_name = name_entry.get(\"given\", [\"\"])[0]\n",
    "    family_name = name_entry.get(\"family\", \"\")\n",
    "    birth_date = patient_resource.get(\"birthDate\", \"\")\n",
    "    gender = patient_resource.get(\"gender\", \"\")\n",
    "\n",
    "    # Define excluded conditions\n",
    "    excluded_conditions = {\"Medication review due (situation)\", \"Risk activity involvement (finding)\"}\n",
    "    condition_info_list = []\n",
    "    for c in conditions:\n",
    "        code_info = c.get(\"code\", {}).get(\"coding\", [{}])[0]\n",
    "        condition_code = code_info.get(\"code\", \"Unknown\")\n",
    "        condition_display = code_info.get(\"display\", \"Unknown\")\n",
    "        clinical_status = (\n",
    "            c.get(\"clinicalStatus\", {})\n",
    "             .get(\"coding\", [{}])[0]\n",
    "             .get(\"code\", \"unknown\")\n",
    "        )\n",
    "        \n",
    "        # Check exclusion and active filters\n",
    "        if condition_display not in excluded_conditions:\n",
    "            if filter_active:\n",
    "                if clinical_status == \"active\":\n",
    "                    condition_info_list.append(\n",
    "                        ConditionInfo(\n",
    "                            code=condition_code,\n",
    "                            display=condition_display,\n",
    "                            clinical_status=clinical_status\n",
    "                        )\n",
    "                    )\n",
    "            else:\n",
    "                # Include conditions regardless of their status if filter_active is False\n",
    "                condition_info_list.append(\n",
    "                    ConditionInfo(\n",
    "                        code=condition_code,\n",
    "                        display=condition_display,\n",
    "                        clinical_status=clinical_status\n",
    "                    )\n",
    "                )\n",
    "\n",
    "    # Parse encounters\n",
    "    def get_encounter_date(enc):\n",
    "        period = enc.get(\"period\", {})\n",
    "        start = period.get(\"start\")\n",
    "        return datetime.fromisoformat(start) if start else datetime.min\n",
    "\n",
    "    encounters_sorted = sorted(encounters, key=get_encounter_date)\n",
    "    recent_encounters = encounters_sorted[-3:] if len(encounters_sorted) > 3 else encounters_sorted\n",
    "\n",
    "    encounter_info_list = []\n",
    "    for e in recent_encounters:\n",
    "        period = e.get(\"period\", {})\n",
    "        start_date = period.get(\"start\", \"\")\n",
    "        reason = e.get(\"reasonCode\", [{}])[0].get(\"coding\", [{}])[0].get(\"display\", None)\n",
    "        etype = e.get(\"type\", [{}])[0].get(\"coding\", [{}])[0].get(\"display\", None)\n",
    "        encounter_info_list.append(\n",
    "            EncounterInfo(\n",
    "                date=start_date,\n",
    "                reason_display=reason,\n",
    "                type_display=etype\n",
    "            )\n",
    "        )\n",
    "\n",
    "    # Parse medications\n",
    "    medication_info_list = []\n",
    "    for m in medication_requests:\n",
    "        status = m.get(\"status\")\n",
    "        if status == \"active\":\n",
    "            med_code = m.get(\"medicationCodeableConcept\", {}).get(\"coding\", [{}])[0]\n",
    "            med_name = med_code.get(\"display\", \"Unknown Medication\")\n",
    "            authored = m.get(\"authoredOn\", None)\n",
    "            dosage_instruction = m.get(\"dosageInstruction\", [{}])[0].get(\"text\", None)\n",
    "            medication_info_list.append(\n",
    "                MedicationInfo(\n",
    "                    name=med_name,\n",
    "                    start_date=authored,\n",
    "                    instructions=dosage_instruction\n",
    "                )\n",
    "            )\n",
    "\n",
    "    patient_info = PatientInfo(\n",
    "        given_name=given_name,\n",
    "        family_name=family_name,\n",
    "        birth_date=birth_date,\n",
    "        gender=gender,\n",
    "        conditions=condition_info_list,\n",
    "        recent_encounters=encounter_info_list,\n",
    "        current_medications=medication_info_list\n",
    "    )\n",
    "\n",
    "    return patient_info\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "f1f9ee2f-0c0f-4d63-aa8b-c56085f76119",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'given_name': 'Almeta56',\n",
       " 'family_name': 'Buckridge80',\n",
       " 'birth_date': '2010-12-31',\n",
       " 'gender': 'female',\n",
       " 'conditions': [{'code': '24079001',\n",
       "   'display': 'Atopic dermatitis (disorder)',\n",
       "   'clinical_status': 'active'},\n",
       "  {'code': '233678006',\n",
       "   'display': 'Childhood asthma (disorder)',\n",
       "   'clinical_status': 'active'}],\n",
       " 'recent_encounters': [{'date': '2024-01-26T01:38:45-08:00',\n",
       "   'reason_display': None,\n",
       "   'type_display': 'Well child visit (procedure)'},\n",
       "  {'date': '2024-02-09T01:38:45-08:00',\n",
       "   'reason_display': 'Patient referral for dental care (procedure)',\n",
       "   'type_display': 'Encounter for check up (procedure)'},\n",
       "  {'date': '2024-10-05T21:38:45-07:00',\n",
       "   'reason_display': 'Childhood asthma (disorder)',\n",
       "   'type_display': 'Asthma follow-up (regime/therapy)'}],\n",
       " 'current_medications': [{'name': 'Loratadine 5 MG Chewable Tablet',\n",
       "   'start_date': '2011-07-25T11:14:11-07:00',\n",
       "   'instructions': 'Take as needed.'},\n",
       "  {'name': 'NDA020800 0.3 ML Epinephrine 1 MG/ML Auto-Injector',\n",
       "   'start_date': '2011-07-25T11:14:11-07:00',\n",
       "   'instructions': 'Take as needed.'},\n",
       "  {'name': '120 ACTUAT fluticasone propionate 0.044 MG/ACTUAT Metered Dose Inhaler [Flovent]',\n",
       "   'start_date': '2024-01-26T01:38:45-08:00',\n",
       "   'instructions': 'Take as needed.'},\n",
       "  {'name': 'albuterol 0.417 MG/ML Inhalation Solution',\n",
       "   'start_date': '2024-01-26T01:38:45-08:00',\n",
       "   'instructions': 'Take as needed.'}]}"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example Usage\n",
    "patient_info = parse_synthea_patient(\"data/almeta_buckridge.json\")\n",
    "patient_info.dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27a1399a-8280-42f6-9355-a046cd1828d4",
   "metadata": {},
   "source": [
    "### Map Conditions to Encounters/Medications\n",
    "\n",
    "We now use an LLM to dynamically transform the existing JSON into a new structured output (a \"ConditionBundle\") where we map each condition to its associated encounters/medications. We rely on the LLM's prior medical knowledge to do this transformation.\n",
    "\n",
    "This transformation allows us to then consult the relevant guidelines for each condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "a3b6ede9-af91-4cec-8f1c-54913722eb85",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConditionBundle(BaseModel):\n",
    "    condition: ConditionInfo\n",
    "    encounters: List[EncounterInfo] = Field(default_factory=list)\n",
    "    medications: List[MedicationInfo] = Field(default_factory=list)\n",
    "\n",
    "class ConditionBundles(BaseModel):\n",
    "    bundles: List[ConditionBundle]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "25fb1368-73bd-43ae-a3df-69b22410983f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from llama_index.llms.openai import OpenAI\n",
    "from llama_index.core.llms import LLM\n",
    "from llama_index.core.prompts import ChatPromptTemplate\n",
    "\n",
    "CONDITION_BUNDLE_PROMPT = \"\"\"\\\n",
    "You are an assistant that takes a patient's summarized clinical data and associates each active condition with any relevant recent encounters and current medications.\n",
    "\n",
    "**Steps to follow:**\n",
    "1. Review the patient's demographics, conditions, recent encounters, and current medications.\n",
    "2. For each condition in 'conditions':\n",
    "   - Determine which of the 'recent_encounters' are relevant. An encounter is relevant if:\n",
    "     - The 'reason_display' or 'type_display' of the encounter mentions or is closely related to the condition.\n",
    "     - Consider synonyms or partial matches. For example, for \"Childhood asthma (disorder)\", any encounter mentioning \"asthma\" or \"asthma follow-up\" is relevant.\n",
    "   - Determine which of the 'current_medications' are relevant. A medication is relevant if:\n",
    "     - The medication 'name' or 'instructions' are clearly related to managing that condition. For example, inhalers or corticosteroids for asthma, topical creams for dermatitis.\n",
    "     - Consider partial matches. For \"Atopic dermatitis (disorder)\", a medication used for allergic conditions or skin inflammations could be relevant.\n",
    "3. Ignore patient demographics for relevance determination; they are just context.\n",
    "4. Return the final output strictly as a JSON object following the schema (provided as a tool call). \n",
    "   Do not include extra commentary outside the JSON.\n",
    "\n",
    "**Patient Data**:\n",
    "{patient_info}\n",
    "\"\"\"\n",
    "\n",
    "async def create_condition_bundles(\n",
    "    patient_data: PatientInfo, llm: Optional[LLM] = None\n",
    ") -> ConditionEncounters:\n",
    "    llm = llm or OpenAI(model=\"gpt-4o\")\n",
    "\n",
    "    # we will dump the entire patient info into an LLM and have it figure out the relevant encounters/medications\n",
    "    # associated with each condition\n",
    "    prompt = ChatPromptTemplate.from_messages([\n",
    "        (\"user\", CONDITION_BUNDLE_PROMPT)\n",
    "    ])\n",
    "    condition_bundles = await llm.astructured_predict(\n",
    "        ConditionBundles,\n",
    "        prompt,\n",
    "        patient_info=patient_data.json()\n",
    "    )\n",
    "\n",
    "    return condition_bundles"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aec6dbbd-fc9a-4f16-8e7a-047eb89b08fc",
   "metadata": {},
   "source": [
    "Let's run a sample (we will plug this into a full workflow later)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "0f946b2a-5e52-4486-8732-1e90e724b0f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'bundles': [{'condition': {'code': '24079001',\n",
       "    'display': 'Atopic dermatitis (disorder)',\n",
       "    'clinical_status': 'active'},\n",
       "   'encounters': [],\n",
       "   'medications': [{'name': 'Loratadine 5 MG Chewable Tablet',\n",
       "     'start_date': '2011-07-25T11:14:11-07:00',\n",
       "     'instructions': 'Take as needed.'}]},\n",
       "  {'condition': {'code': '233678006',\n",
       "    'display': 'Childhood asthma (disorder)',\n",
       "    'clinical_status': 'active'},\n",
       "   'encounters': [{'date': '2024-10-05T21:38:45-07:00',\n",
       "     'reason_display': 'Childhood asthma (disorder)',\n",
       "     'type_display': 'Asthma follow-up (regime/therapy)'}],\n",
       "   'medications': [{'name': '120 ACTUAT fluticasone propionate 0.044 MG/ACTUAT Metered Dose Inhaler [Flovent]',\n",
       "     'start_date': '2024-01-26T01:38:45-08:00',\n",
       "     'instructions': 'Take as needed.'},\n",
       "    {'name': 'albuterol 0.417 MG/ML Inhalation Solution',\n",
       "     'start_date': '2024-01-26T01:38:45-08:00',\n",
       "     'instructions': 'Take as needed.'}]}]}"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "condition_bundles = await create_condition_bundles(patient_info)\n",
    "condition_bundles.dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e01c7a8f-25f9-4f3b-b040-ee15d34826f6",
   "metadata": {},
   "source": [
    "### Setup Index\n",
    "\n",
    "We've setup the right extraction flow over the patient record. The next step is to setup an index that contains a set of relevant guidelines which we will match against each condition of the patient. This will help us generate a more useful and comprehensive case summary.\n",
    "\n",
    "Here we use LlamaCloud: https://cloud.llamaindex.ai/. If you don't have access yet, you're always welcome to use our open-source VectorStoreIndex."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56212b49-964a-49b8-beac-f55abf0415c5",
   "metadata": {},
   "source": [
    "We use the following guidelines as datapoints:\n",
    "\n",
    "- [\"Guidelines of care for the management of atopic dermatitis in adults with phototherapy and systemic therapies\"](https://www.jaad.org/action/showPdf?pii=S0190-9622%2823%2902878-5) (from JAAD)\n",
    "- [\"2020 Focused Updates to the Asthma Management Guidelines\"](https://www.nhlbi.nih.gov/resources/2020-focused-updates-asthma-management-guidelines) (from NHLBI)\n",
    "\n",
    "Download the PDFs, and either upload them to LlamaCloud or index them through `VectorStoreIndex.from_documents`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "07ccec03-9aaf-42c7-99e1-f7187328548b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from llama_index.indices.managed.llama_cloud import LlamaCloudIndex\n",
    "\n",
    "index = LlamaCloudIndex(\n",
    "  name=\"medical_guidelines_0\", \n",
    "  project_name=\"llamacloud_demo\",\n",
    "  organization_id=\"cdcb3478-1348-492e-8aa0-25f47d1a3902\",\n",
    "  # api_key=\"llx-...\"\n",
    ")\n",
    "\n",
    "retriever = index.as_retriever(similarity_top_k=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e36b38a-23cf-4dc5-bc64-49cea9467c16",
   "metadata": {},
   "source": [
    "### Define Guideline Recommendation Schema\n",
    "\n",
    "Given a condition (and associated encounters/medications), define an output schema that represents the matched guideline.\n",
    "\n",
    "We need to make sure we ask the right questions in order to retrieve the relevant guidelines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "b6496ab9-e70a-4203-8411-fd7c167ee054",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "from pydantic import BaseModel, Field\n",
    "\n",
    "class GuidelineQueries(BaseModel):\n",
    "    \"\"\"Represents a set of recommended queries to retrieve guideline sections relevant to the patient's conditions.\"\"\"\n",
    "    queries: List[str] = Field(\n",
    "        default_factory=list,\n",
    "        description=\"A list of query strings that can be used to search a vector index of medical guidelines.\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "24acdc84-9da0-4339-9c8e-fb9929d00286",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GuidelineRecommendation(BaseModel):\n",
    "    guideline_source: str = Field(..., description=\"The origin of the guideline (e.g., 'NHLBI Asthma Guidelines').\")\n",
    "    recommendation_summary: str = Field(..., description=\"A concise summary of the relevant recommendation.\")\n",
    "    reference_section: Optional[str] = Field(None, description=\"Specific section or reference in the guideline.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15e1805c-a9ad-433c-8f22-a005de3fe0ab",
   "metadata": {},
   "source": [
    "### Define Final Output Schema\n",
    "\n",
    "This is the schema for the final case summary. It contains the patient's basic demographic info, conditions, and also matched guideline recommendations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "b9f275f4-66cc-4950-93f7-47da98d14e96",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional, List\n",
    "from pydantic import BaseModel, Field\n",
    "\n",
    "class ConditionSummary(BaseModel):\n",
    "    condition_display: str = Field(..., description=\"Human-readable name of the condition.\")\n",
    "    summary: str = Field(..., description=\"A concise narrative summarizing the condition’s status, relevant encounters, medications, and guideline recommendations.\")\n",
    "\n",
    "class CaseSummary(BaseModel):\n",
    "    patient_name: str = Field(..., description=\"The patient's name.\")\n",
    "    age: int = Field(..., description=\"The patient's age in years.\")\n",
    "    overall_assessment: str = Field(..., description=\"A high-level summary synthesizing all conditions, encounters, medications, and guideline recommendations.\")\n",
    "    condition_summaries: List[ConditionSummary] = Field(\n",
    "        default_factory=list,\n",
    "        description=\"A list of condition-specific summaries providing insight into each condition's current management and recommendations.\"\n",
    "    )\n",
    "\n",
    "    def render(self) -> str:\n",
    "        lines = []\n",
    "        lines.append(f\"Patient Name: {self.patient_name}\")\n",
    "        lines.append(f\"Age: {self.age} years\")\n",
    "        lines.append(\"\")\n",
    "        lines.append(\"Overall Assessment:\")\n",
    "        lines.append(self.overall_assessment)\n",
    "        lines.append(\"\")\n",
    "        \n",
    "        if self.condition_summaries:\n",
    "            lines.append(\"Condition Summaries:\")\n",
    "            for csum in self.condition_summaries:\n",
    "                lines.append(f\"- {csum.condition_display}:\")\n",
    "                lines.append(f\"  {csum.summary}\")\n",
    "        else:\n",
    "            lines.append(\"No specific conditions were summarized.\")\n",
    "\n",
    "        return \"\\n\".join(lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ff8eebc-c00e-4499-ad5d-2d7843786eba",
   "metadata": {},
   "source": [
    "## Setup Patient Case Summary Workflow\n",
    "\n",
    "Let's define the following workflow to generate patient case summaries:\n",
    "1. Extract out patient data including conditions, medications, encounters from the synthetically generated patient JSON (from Synthea)\n",
    "2. Use an LLM to map each condition to relevant medications/encounters (defined as a \"condition bundle\") \n",
    "3. For each condition bundle, generate a set of search queries to match it against relevant medical guidelines in our index.\n",
    "4. Generate final case summary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "8b803856-630c-497c-9142-bd5aeb9efa5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from llama_index.core.workflow import (\n",
    "    Event,\n",
    "    StartEvent,\n",
    "    StopEvent,\n",
    "    Context,\n",
    "    Workflow,\n",
    "    step,\n",
    ")\n",
    "from llama_index.core.llms import LLM\n",
    "from typing import Optional, Tuple\n",
    "from pydantic import BaseModel\n",
    "from llama_index.core import SimpleDirectoryReader\n",
    "from llama_index.core.schema import Document\n",
    "from llama_index.core.agent import FunctionCallingAgentWorker\n",
    "from llama_index.core.prompts import ChatPromptTemplate\n",
    "from llama_index.core.llms import ChatMessage, MessageRole\n",
    "from llama_index.core.retrievers import BaseRetriever\n",
    "from pathlib import Path\n",
    "import logging\n",
    "import json\n",
    "import os\n",
    "\n",
    "_logger = logging.getLogger(__name__)\n",
    "_logger.setLevel(logging.INFO)\n",
    "\n",
    "\n",
    "\n",
    "GUIDELINE_QUERIES_PROMPT = \"\"\"\\\n",
    "You are an assistant tasked with determining what guidelines would be most helpful to consult for a given patient's condition data. You have:\n",
    "\n",
    "- Patient information (demographics, conditions, encounters, medications)\n",
    "- A single condition bundle that includes:\n",
    "  - One specific condition and its related encounters and medications\n",
    "- Your goal is to produce several high-quality search queries that can be used to retrieve relevant guideline sections from a vector index of medical guidelines.\n",
    "\n",
    "**Instructions:**\n",
    "1. Review the patient info and the condition bundle. Identify the key aspects of the condition that might require guideline consultation—such as disease severity, typical management steps, trigger avoidance, or medication optimization.\n",
    "2. Consider what clinicians would look up:\n",
    "   - Best practices for this condition's management (e.g., stepwise therapy for asthma, maintenance therapy for atopic dermatitis)\n",
    "   - Medication recommendations (e.g., use of inhaled corticosteroids, timing and dose adjustments, rescue inhaler usage, antihistamines for atopic dermatitis)\n",
    "   - Encounter follow-ups (e.g., what follow-up intervals are recommended, what tests or measurements to track)\n",
    "   - Patient education and preventive measures (e.g., trigger avoidance, skincare routines, inhaler technique)\n",
    "3. Formulate 3-5 concise, targeted queries that, if run against a medical guideline index, would return the most relevant sections. Each query should be a natural language string that could be used with a vector-based retrieval system. \n",
    "4. Make the queries condition-specific, incorporating relevant medications or encounter findings. \n",
    "5. Return the output as a JSON object following the schema defined as a tool call.\n",
    "\n",
    "Patient Info: {patient_info}\n",
    "\n",
    "Condition Bundle: {condition_info}\n",
    "\n",
    "Do not include any commentary outside the JSON.\"\"\"\n",
    "\n",
    "\n",
    "GUIDELINE_RECOMMENDATION_PROMPT = \"\"\"\\\n",
    "Given the following patient condition and the corresponding relevant medical guideline text (unformatted), \n",
    "generate a guideline recommendation according to the schema defined as a tool call.\n",
    "\n",
    "The condition details are given below. This includes the condition itself, along with associated encounters/medications\n",
    "that the patient has taken already. Make sure the guideline recommendation is relevant.\n",
    "\n",
    "**Patient Condition:**\n",
    "{patient_condition_text}\n",
    "\n",
    "**Matched Guideline Text(s):**\n",
    "{guideline_text}\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "CASE_SUMMARY_SYSTEM_PROMPT = \"\"\"\\\n",
    "You are a medical assistant that produces a concise and understandable case summary for a clinician. \n",
    "\n",
    "You have access to the patient's name, age, and a list of conditions. \n",
    "\n",
    "For each condition, you also have related encounters, medications, and guideline recommendations. \n",
    "\n",
    "Your goal is to produce a `CaseSummary` object in JSON format that adheres to the CaseSummary schema, defined as a tool call.\n",
    "\n",
    "**Instructions:**\n",
    "- Use the patient's name and age as given.\n",
    "- Create an `overall_assessment` that integrates the data about their conditions, encounters, medications, and guideline recommendations.\n",
    "- For each condition, write a short `summary` describing:\n",
    "  - The current state of the condition.\n",
    "  - Relevant encounters that indicate progress or issues.\n",
    "  - Medications currently managing that condition and if they align with guidelines.\n",
    "  - Any key recommendations from the guidelines that should be followed going forward.\n",
    "- Keep the summaries patient-friendly but medically accurate. Be concise and clear.\n",
    "- Return only the final JSON that matches the schema. No extra commentary.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "CASE_SUMMARY_USER_PROMPT = \"\"\"\\\n",
    "**Patient Demographics**\n",
    "{demographic_info}\n",
    "\n",
    "**Condition Information**\n",
    "{condition_guideline_info}\n",
    "\n",
    "\n",
    "Given the above data, produce a `CaseSummary` as per the schema.\n",
    "\"\"\"\n",
    "\n",
    "def generate_condition_guideline_str(\n",
    "    bundle: ConditionBundle,\n",
    "    rec: GuidelineRecommendation\n",
    ") -> str:\n",
    "    return f\"\"\"\\\n",
    "**Condition Info**:\n",
    "{bundle.json()}\n",
    "\n",
    "**Recommendation**:\n",
    "{rec.json()}\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "class PatientInfoEvent(Event):\n",
    "    patient_info: PatientInfo\n",
    "\n",
    "\n",
    "class ConditionBundleEvent(Event):\n",
    "    bundles: ConditionBundles\n",
    "\n",
    "\n",
    "class MatchGuidelineEvent(Event):\n",
    "    bundle: ConditionBundle\n",
    "\n",
    "\n",
    "class MatchGuidelineResultEvent(Event):\n",
    "    bundle: ConditionBundle\n",
    "    rec: GuidelineRecommendation\n",
    "\n",
    "\n",
    "class GenerateCaseSummaryEvent(Event):\n",
    "    condition_guideline_info: List[Tuple[ConditionBundle, GuidelineRecommendation]]\n",
    "\n",
    "\n",
    "class LogEvent(Event):\n",
    "    msg: str\n",
    "    delta: bool = False\n",
    "\n",
    "\n",
    "class GuidelineRecommendationWorkflow(Workflow):\n",
    "    \"\"\"Guidline recommendation workflow.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        guideline_retriever: BaseRetriever,\n",
    "        llm: LLM | None = None,\n",
    "        similarity_top_k: int = 20,\n",
    "        output_dir: str = \"data_out\",\n",
    "        **kwargs,\n",
    "    ) -> None:\n",
    "        \"\"\"Init params.\"\"\"\n",
    "        super().__init__(**kwargs)\n",
    "\n",
    "        self.guideline_retriever = guideline_retriever\n",
    "        \n",
    "        self.llm = llm or OpenAI(model=\"gpt-4o-mini\")\n",
    "        self.similarity_top_k = similarity_top_k\n",
    "\n",
    "        # if not exists, create\n",
    "        out_path = Path(output_dir) / \"workflow_output\"\n",
    "        if not out_path.exists():\n",
    "            out_path.mkdir(parents=True, exist_ok=True)\n",
    "            os.chmod(str(out_path), 0o0777)\n",
    "        self.output_dir = out_path\n",
    "\n",
    "    @step\n",
    "    async def parse_patient_info(\n",
    "        self, ctx: Context, ev: StartEvent\n",
    "    ) -> PatientInfoEvent:\n",
    "        # load patient info from cache if exists, otherwise generate\n",
    "        patient_info_path = Path(\n",
    "            f\"{self.output_dir}/patient_info.json\"\n",
    "        )\n",
    "        if patient_info_path.exists():\n",
    "            if self._verbose:\n",
    "                ctx.write_event_to_stream(LogEvent(msg=\">> Loading patient info from cache\"))\n",
    "            patient_info_dict = json.load(open(str(patient_info_path), \"r\"))\n",
    "            patient_info = PatientInfo.model_validate(patient_info_dict)\n",
    "        else:\n",
    "            if self._verbose:\n",
    "                ctx.write_event_to_stream(LogEvent(msg=\">> Reading patient info\"))\n",
    "            patient_info = parse_synthea_patient(ev.patient_json_path)\n",
    "            \n",
    "            if not isinstance(patient_info, PatientInfo):\n",
    "                raise ValueError(f\"Invalid patient info: {patient_info}\")\n",
    "            # save patient info to file\n",
    "            with open(patient_info_path, \"w\") as fp:\n",
    "                fp.write(patient_info.model_dump_json())\n",
    "        if self._verbose:\n",
    "            ctx.write_event_to_stream(LogEvent(msg=f\">> Patient Info: {patient_info.dict()}\"))\n",
    "\n",
    "        await ctx.set(\"patient_info\", patient_info)\n",
    "\n",
    "        return PatientInfoEvent(patient_info=patient_info)\n",
    "\n",
    "    @step\n",
    "    async def create_condition_bundles(\n",
    "        self, ctx: Context, ev: PatientInfoEvent\n",
    "    ) -> ConditionBundleEvent:\n",
    "        \"\"\"Create condition bundles.\"\"\"\n",
    "        # load patient condition info from cache if exists, otherwise generate\n",
    "        condition_info_path = Path(\n",
    "            f\"{self.output_dir}/condition_bundles.json\"\n",
    "        )\n",
    "        if condition_info_path.exists():\n",
    "            condition_bundles = ConditionBundles.model_validate(\n",
    "                json.load(open(str(condition_info_path), \"r\"))\n",
    "            )\n",
    "        else:\n",
    "            condition_bundles = await create_condition_bundles(ev.patient_info)\n",
    "            with open(condition_info_path, \"w\") as fp:\n",
    "                fp.write(condition_bundles.model_dump_json())\n",
    "            \n",
    "        return ConditionBundleEvent(bundles=condition_bundles)\n",
    "\n",
    "    @step\n",
    "    async def dispatch_guideline_match(\n",
    "        self, ctx: Context, ev: ConditionBundleEvent\n",
    "    ) -> MatchGuidelineEvent:\n",
    "        \"\"\"For each condition + associated information, find relevant guidelines.\n",
    "\n",
    "        Use a map-reduce pattern. \n",
    "        \n",
    "        \"\"\"\n",
    "        await ctx.set(\"num_conditions\", len(ev.bundles.bundles))\n",
    "        \n",
    "        for bundle in ev.bundles.bundles:\n",
    "            ctx.send_event(MatchGuidelineEvent(bundle=bundle))\n",
    "\n",
    "    @step\n",
    "    async def handle_guideline_match(\n",
    "        self, ctx: Context, ev: MatchGuidelineEvent\n",
    "    ) -> MatchGuidelineResultEvent:\n",
    "        \"\"\"Generate guideline recommendation for each condition.\"\"\"\n",
    "        patient_info = await ctx.get(\"patient_info\")\n",
    "        \n",
    "        # We will first generate the right set of questions to ask given the patient info.\n",
    "        prompt = ChatPromptTemplate.from_messages([\n",
    "            (\"user\", GUIDELINE_QUERIES_PROMPT)\n",
    "        ])\n",
    "        guideline_queries = await llm.astructured_predict(\n",
    "            GuidelineQueries,\n",
    "            prompt,\n",
    "            patient_info=patient_info.demographic_str,\n",
    "            condition_info=ev.bundle.json()\n",
    "        )\n",
    "\n",
    "        guideline_docs_dict = {}\n",
    "        # fetch all relevant guidelines as text\n",
    "        for query in guideline_queries.queries:\n",
    "            if self._verbose:\n",
    "                ctx.write_event_to_stream(LogEvent(msg=f\">> Generating query: {query}\"))\n",
    "            cur_guideline_docs = self.guideline_retriever.retrieve(query)\n",
    "            guideline_docs_dict.update({\n",
    "                d.id_: d for d in cur_guideline_docs\n",
    "            })\n",
    "        guideline_docs = guideline_docs_dict.values()\n",
    "        guideline_text=\"\\n\\n\".join([g.get_content() for g in guideline_docs])\n",
    "        if self._verbose:\n",
    "            ctx.write_event_to_stream(\n",
    "                LogEvent(msg=f\">> Found guidelines: {guideline_text[:200]}...\")\n",
    "            )\n",
    "        \n",
    "        # generate guideline recommendation\n",
    "        prompt = ChatPromptTemplate.from_messages([\n",
    "            (\"user\", GUIDELINE_RECOMMENDATION_PROMPT)\n",
    "        ])\n",
    "        guideline_rec = await llm.astructured_predict(\n",
    "            GuidelineRecommendation,\n",
    "            prompt,\n",
    "            patient_info=patient_info.demographic_str,\n",
    "            condition_info=ev.bundle.json(),\n",
    "            guideline_text=guideline_text\n",
    "        )\n",
    "        if self._verbose:\n",
    "            ctx.write_event_to_stream(\n",
    "                LogEvent(msg=f\">> Guideline recommendation: {guideline_rec.json()}\")\n",
    "            )\n",
    "        \n",
    "        if not isinstance(guideline_rec, GuidelineRecommendation):\n",
    "            raise ValueError(f\"Invalid guideline recommendation: {guideline_rec}\")\n",
    "\n",
    "        return MatchGuidelineResultEvent(bundle=ev.bundle, rec=guideline_rec)\n",
    "\n",
    "    @step\n",
    "    async def gather_guideline_match(\n",
    "        self, ctx: Context, ev: MatchGuidelineResultEvent\n",
    "    ) -> GenerateCaseSummaryEvent:\n",
    "        \"\"\"Handle matching clause against guideline.\"\"\"\n",
    "        num_conditions = await ctx.get(\"num_conditions\")\n",
    "        events = ctx.collect_events(ev, [MatchGuidelineResultEvent] * num_conditions)\n",
    "        if events is None:\n",
    "            return\n",
    "\n",
    "        match_results = [(e.bundle, e.rec) for e in events]\n",
    "        # save match results\n",
    "        recs_path = Path(f\"{self.output_dir}/guideline_recommendations.jsonl\")\n",
    "        with open(recs_path, \"w\") as fp:\n",
    "            for _, rec in match_results:\n",
    "                fp.write(rec.model_dump_json() + \"\\n\")\n",
    "            \n",
    "            \n",
    "        return GenerateCaseSummaryEvent(condition_guideline_info=match_results)\n",
    "\n",
    "    @step\n",
    "    async def generate_output(\n",
    "        self, ctx: Context, ev: GenerateCaseSummaryEvent\n",
    "    ) -> StopEvent:\n",
    "        if self._verbose:\n",
    "            ctx.write_event_to_stream(LogEvent(msg=\">> Generating Case Summary\"))\n",
    "\n",
    "        patient_info = await ctx.get(\"patient_info\")\n",
    "        demographic_info = patient_info.demographic_str\n",
    "\n",
    "        condition_guideline_strs = []\n",
    "        for condition_bundle, guideline_rec in ev.condition_guideline_info:\n",
    "            condition_guideline_strs.append(\n",
    "                generate_condition_guideline_str(condition_bundle, guideline_rec)\n",
    "            )\n",
    "        condition_guideline_str = \"\\n\\n\".join(condition_guideline_strs)\n",
    "        \n",
    "        prompt = ChatPromptTemplate.from_messages([\n",
    "            (\"system\", CASE_SUMMARY_SYSTEM_PROMPT),\n",
    "            (\"user\", CASE_SUMMARY_USER_PROMPT)\n",
    "        ])\n",
    "        case_summary = await llm.astructured_predict(\n",
    "            CaseSummary,\n",
    "            prompt,\n",
    "            demographic_info=demographic_info,\n",
    "            condition_guideline_info=condition_guideline_str\n",
    "        )\n",
    "\n",
    "        return StopEvent(result={\"case_summary\": case_summary})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "8557f4a7-ce61-4757-8f35-6785574c57cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "from llama_index.llms.openai import OpenAI\n",
    "\n",
    "llm = OpenAI(model=\"gpt-4o\")\n",
    "workflow = GuidelineRecommendationWorkflow(\n",
    "    guideline_retriever=retriever,\n",
    "    llm=llm,\n",
    "    verbose=True,\n",
    "    timeout=None,  # don't worry about timeout to make sure it completes\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66d79ab2-1455-4f8f-bde3-8bbd51b7da51",
   "metadata": {},
   "source": [
    "#### Visualize the workflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "470f298b-c3a3-485e-a440-b0576e45134d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'NoneType'>\n",
      "<class '__main__.ConditionBundleEvent'>\n",
      "<class '__main__.MatchGuidelineEvent'>\n",
      "<class '__main__.GenerateCaseSummaryEvent'>\n",
      "<class 'llama_index.core.workflow.events.StopEvent'>\n",
      "<class '__main__.MatchGuidelineResultEvent'>\n",
      "<class '__main__.PatientInfoEvent'>\n",
      "guideline_rec_workflow.html\n"
     ]
    }
   ],
   "source": [
    "from llama_index.utils.workflow import draw_all_possible_flows\n",
    "\n",
    "draw_all_possible_flows(GuidelineRecommendationWorkflow, filename=\"guideline_rec_workflow.html\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f11484c-52b8-424f-9a64-7456068ff1b1",
   "metadata": {},
   "source": [
    "## Run the Workflow\n",
    "\n",
    "Let's run the full workflow and generate the output! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "b9a55b1b-8263-4365-b187-6204150ec4cb",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running step parse_patient_info\n",
      "Step parse_patient_info produced event PatientInfoEvent\n",
      ">> Loading patient info from cache\n",
      ">> Patient Info: {'given_name': 'Almeta56', 'family_name': 'Buckridge80', 'birth_date': '2010-12-31', 'gender': 'female', 'conditions': [{'code': '24079001', 'display': 'Atopic dermatitis (disorder)', 'clinical_status': 'active'}, {'code': '233678006', 'display': 'Childhood asthma (disorder)', 'clinical_status': 'active'}], 'recent_encounters': [{'date': '2024-01-26T01:38:45-08:00', 'reason_display': None, 'type_display': 'Well child visit (procedure)'}, {'date': '2024-02-09T01:38:45-08:00', 'reason_display': 'Patient referral for dental care (procedure)', 'type_display': 'Encounter for check up (procedure)'}, {'date': '2024-10-05T21:38:45-07:00', 'reason_display': 'Childhood asthma (disorder)', 'type_display': 'Asthma follow-up (regime/therapy)'}], 'current_medications': [{'name': 'Loratadine 5 MG Chewable Tablet', 'start_date': '2011-07-25T11:14:11-07:00', 'instructions': 'Take as needed.'}, {'name': 'NDA020800 0.3 ML Epinephrine 1 MG/ML Auto-Injector', 'start_date': '2011-07-25T11:14:11-07:00', 'instructions': 'Take as needed.'}, {'name': '120 ACTUAT fluticasone propionate 0.044 MG/ACTUAT Metered Dose Inhaler [Flovent]', 'start_date': '2024-01-26T01:38:45-08:00', 'instructions': 'Take as needed.'}, {'name': 'albuterol 0.417 MG/ML Inhalation Solution', 'start_date': '2024-01-26T01:38:45-08:00', 'instructions': 'Take as needed.'}]}\n",
      "Running step create_condition_bundles\n",
      "Step create_condition_bundles produced event ConditionBundleEvent\n",
      "Running step dispatch_guideline_match\n",
      "Step dispatch_guideline_match produced no event\n",
      "Running step handle_guideline_match\n",
      "Running step handle_guideline_match\n",
      ">> Generating query: Best practices for managing childhood asthma\n",
      ">> Generating query: Stepwise therapy guidelines for childhood asthma\n",
      ">> Generating query: Use of inhaled corticosteroids in childhood asthma\n",
      ">> Generating query: Guidelines for albuterol usage in asthma management\n",
      ">> Generating query: Recommended follow-up intervals for childhood asthma\n",
      ">> Found guidelines: # Figure I.b: Stepwise Approach for Management of Asthma in Individuals Ages 0–4 Years\n",
      "\n",
      "# Intermittent Asthma\n",
      "\n",
      "# Management of Persistent Asthma in Individuals Ages 0–4 Years\n",
      "\n",
      "|Treatment|STEP 1|STEP 2...\n",
      ">> Generating query: best practices for managing atopic dermatitis in children\n",
      ">> Generating query: guidelines for using loratadine in atopic dermatitis\n",
      ">> Generating query: recommended follow-up intervals for pediatric atopic dermatitis\n",
      ">> Generating query: patient education on trigger avoidance for atopic dermatitis\n",
      ">> Generating query: skincare routines for managing atopic dermatitis in children\n",
      ">> Found guidelines: # Davis et al\n",
      "\n",
      "# J AM ACAD D ERMATOL FEBRUARY 2024\n",
      "\n",
      "and mycophenolate, and against systemic corticosteroids.\n",
      "\n",
      "# Conflicts of interest\n",
      "\n",
      "Dr Drucker receives research grants paid to his institution from ...\n",
      "Step handle_guideline_match produced event MatchGuidelineResultEvent\n",
      ">> Guideline recommendation: {\"guideline_source\":\"2020 Focused Updates to the Asthma Management Guidelines\",\"recommendation_summary\":\"For children ages 0–4 years with recurrent wheezing triggered by respiratory tract infections and no wheezing between infections, start a short course of daily inhaled corticosteroids (ICS) at the onset of a respiratory tract infection with as-needed short-acting beta-agonist (SABA) for quick-relief therapy.\",\"reference_section\":\"Figure I.b: Stepwise Approach for Management of Asthma in Individuals Ages 0–4 Years\"}\n",
      "Running step gather_guideline_match\n",
      "Step gather_guideline_match produced no event\n",
      "Step handle_guideline_match produced event MatchGuidelineResultEvent\n",
      ">> Guideline recommendation: {\"guideline_source\":\"J AM ACAD DERMATOL FEBRUARY 2024\",\"recommendation_summary\":\"For adults with moderate to severe atopic dermatitis (AD), we make strong recommendations for the use of dupilumab, tralokinumab, abrocitinib, baricitinib, and upadacitinib. We make conditional recommendations in favor of using phototherapy, azathioprine, cyclosporine, methotrexate, and mycophenolate, and against the use of systemic corticosteroids.\",\"reference_section\":\"J Am Acad Dermatol 2024;90:e43-56.\"}\n",
      "Running step gather_guideline_match\n",
      "Step gather_guideline_match produced event GenerateCaseSummaryEvent\n",
      "Running step generate_output\n",
      ">> Generating Case Summary\n",
      "Step generate_output produced event StopEvent\n",
      "patient_name='Almeta56 Buckridge80' age=13 overall_assessment='Almeta56 Buckridge80 is a 13-year-old female with active childhood asthma and atopic dermatitis. Her asthma is currently managed with fluticasone propionate and albuterol, aligning with guidelines for children with recurrent wheezing. Atopic dermatitis is managed with loratadine, though current guidelines suggest other treatments for moderate to severe cases. Regular follow-ups for asthma and potential adjustments in dermatitis management are recommended.' condition_summaries=[ConditionSummary(condition_display='Childhood asthma (disorder)', summary=\"Almeta's asthma is actively managed with fluticasone propionate and albuterol, which are appropriate for her age and condition. She had a follow-up encounter on October 5, 2024, indicating ongoing management. The current treatment aligns with guidelines recommending inhaled corticosteroids and short-acting beta-agonists for children with recurrent wheezing.\"), ConditionSummary(condition_display='Atopic dermatitis (disorder)', summary=\"Almeta's atopic dermatitis is currently managed with loratadine, taken as needed. While this provides symptomatic relief, current guidelines for moderate to severe cases recommend considering other treatments such as dupilumab or phototherapy. No recent encounters suggest a need for reassessment of her treatment plan.\")]\n"
     ]
    }
   ],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "handler = workflow.run(patient_json_path=\"data/almeta_buckridge.json\")\n",
    "async for event in handler.stream_events():\n",
    "    if isinstance(event, LogEvent):\n",
    "        if event.delta:\n",
    "            print(event.msg, end=\"\")\n",
    "        else:\n",
    "            print(event.msg)\n",
    "\n",
    "response_dict = await handler\n",
    "print(str(response_dict[\"case_summary\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "bb0f5f52-ced9-49c2-82b9-131470fd291e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Patient Name: Almeta56 Buckridge80\n",
      "Age: 13 years\n",
      "\n",
      "Overall Assessment:\n",
      "Almeta56 Buckridge80 is a 13-year-old female with active childhood asthma and atopic dermatitis. Her asthma is currently managed with fluticasone propionate and albuterol, aligning with guidelines for children with recurrent wheezing. Atopic dermatitis is managed with loratadine, though current guidelines suggest other treatments for moderate to severe cases. Regular follow-ups for asthma and potential adjustments in dermatitis management are recommended.\n",
      "\n",
      "Condition Summaries:\n",
      "- Childhood asthma (disorder):\n",
      "  Almeta's asthma is actively managed with fluticasone propionate and albuterol, which are appropriate for her age and condition. She had a follow-up encounter on October 5, 2024, indicating ongoing management. The current treatment aligns with guidelines recommending inhaled corticosteroids and short-acting beta-agonists for children with recurrent wheezing.\n",
      "- Atopic dermatitis (disorder):\n",
      "  Almeta's atopic dermatitis is currently managed with loratadine, taken as needed. While this provides symptomatic relief, current guidelines for moderate to severe cases recommend considering other treatments such as dupilumab or phototherapy. No recent encounters suggest a need for reassessment of her treatment plan.\n"
     ]
    }
   ],
   "source": [
    "print(str(response_dict[\"case_summary\"].render()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "710ae172-b7e7-4d95-960f-f9cd90b40e3f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "llamacloud-demo",
   "language": "python",
   "name": "llamacloud-demo"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}