first app commit

Dockerfile

@@ -1,21 +0,0 @@
-FROM python:3.9-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

OAI_CONFIG_LIST.json

@@ -0,0 +1,14 @@
+[
+    {
+        "model": "meta-llama/Llama-3.3-70B-Instruct",
+        "base_url": "https://api.inference.denvrdata.com/v1/",
+        "api_key": "",
+        "price": [0.0, 0.0]
+    },
+    {
+        "model": "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
+        "base_url": "https://api.inference.denvrdata.com/v1/",
+        "api_key": "",
+        "price": [0.0, 0.0]
+    }
+]

README.md

@@ -1,20 +1,153 @@
 ---
-title: Preventative Healthcare
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
+title: Preventative Healthcare with AutoGen
+emoji: 🔥
+colorFrom: yellow
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.42.2
+app_file: app.py
 pinned: false
-short_description: Streamlit template space
 license: apache-2.0
+short_description: Using AI agents for preventative healthcare maintenance
 ---
+[//]: <Add samples here https://github.com/microsoft/autogen/tree/main/python/samples> 
 
-# Welcome to Streamlit!
+## AutoGen Multi-Agent Chat Preventative Healthcare
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+This is a multi-agent system built on top of AutoGen agents designed to automate and optimize preventative healthcare outreach. It uses multiple agents, large language models (LLMs) and asynchronous programming to streamline the process of identifying patients who meet specific screening criteria, filter patient data, and generate personalized outreach emails. 
+
+The system uses model endpoints hosted by [Denvr Dataworks](https://www.denvrdata.com/intel) on Intel® Gaudi® accelerators, and an OpenAI-compatible API key.
+
+Credit: Though heavily modified, the original idea comes from Mike Lynch on his [Medium blog](https://medium.com/@micklynch_6905/hospitalgpt-managing-a-patient-population-with-autogen-powered-by-gpt-4-mixtral-8x7b-ef9f54f275f1). 
+
+### Workflow:
+
+<p align="center">
+  <img width="700" src="images/prev_healthcare_4.drawio.svg">
+</p>
+
+1. **Define Screening Criteria**: After getting the general screening task from the user, the User Proxy Agent starts a conversation between the Epidemiologist Agent and the Doctor Critic Agent to define the criteria for patient outreach based on the target screening type. The output criteria is age range (e.g., 40–70), gender, and relevant medical history.
+
+2. **Filter Patients**: The Data Analyst Agent filters patient data from a CSV file based on the defined criteria, including age range, gender, and medical conditions. The patient data are synthetically generated. You can find the sample data under [data/patients.csv](data/patients.csv).
+
+3. **Generate Outreach Emails**: The program generates outreach emails for the filtered patients using LLMs and saves them as text files. 
+
+### Setup
+
+If you want a local copy of the application to run, you can clone the repository and then navigate into the folder with:
+
+```bash
+git clone https://huggingface.co/spaces/Intel/preventative_healthcare
+cd preventative_healthcare
+```
+
+
+You can use the `uv` package to manage your virtual environment and dependencies. Just initialize the `uv` project, and create the virtual environment:
+
+```bash
+uv init
+uv venv
+```
+
+Activate the virtual environment
+```bash
+source .venv/bin/activate
+```
+
+Install dependencies:
+```bash
+uv sync
+```
+
+To deactivate the virtual environment when finished running the application:
+```bash
+deactivate
+```
+
+### OpenAI API Key, Model Name, and Endpoint URL
+
+1. Add your OpenAI-compatible API key to the `OAI_CONFIG_LIST.json` file.
+2. Modify the `model` and `base_url` to the model name and endpoint URL that you are using. The `OAI_CONFIG_LIST.json` should look like:
+```json
+[
+    {
+        "model": "meta-llama/Llama-3.3-70B-Instruct",
+        "base_url": "https://api.inference.denvrdata.com/v1/",
+        "api_key": "",
+        "price": [0.0, 0.0]
+    },
+    {
+        "model": "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
+        "base_url": "https://api.inference.denvrdata.com/v1/",
+        "api_key": "",
+        "price": [0.0, 0.0]
+    }
+]
+```
+
+### Modifying prompts
+To modify prompts, you can edit them in the UI, or you can edit the following files:
+
+1. User proxy agent: the agent responsible for passing along the user's preventative healthcare task to the other agents.
+[prompts/user_proxy_prompt.py](prompts/user_proxy_prompt.py)
+2. Epidemiologist agent: The disease specialist agent who will gather the preventative healthcare task and decide on patient criteria.
+[prompts/epidemiologist_prompt.py](prompts/epidemiologist_prompt.py)
+3. Doctor Critic agent: The doctor critic agent reviews the criteria from the epidemiologist and passes this along. The output will be used to filter actual patients from the patient data.
+[prompts/doctor_critic_prompt.py](prompts/doctor_critic_prompt.py)
+4. Outreach email: This is not an agent, but still uses an LLM to build the outreach email. 
+[prompts/outreach_email_prompt.py](prompts/outreach_email_prompt.py)
+
+### Example Usage
+
+If you want to run the app with streamlit, you can run using:
+
+```bash
+streamlit run app.py
+```
+
+If you want to just run the script locally from the command line, use the following command:
+
+```bash
+python intelpreventativehealthcare.py \
+    --oai_config "OAI_CONFIG_LIST.json" \
+    --target_screening "Type 2 Diabetes" \
+    --patients_file "data/patients.csv" \
+    --phone "123-456-7890" \
+    --email "[email protected]" \
+    --name "Benjamin Consolvo"
+```
+
+The arguments are defined as follows:
+
+- `--oai_config`: Path to the `OAI_CONFIG_LIST.json` file, which contains the model endpoints, model name, and api key.
+- `--target_screening`: The type of screening task (e.g., "Type 2 Diabetes screening").
+- `--patients_file`: Path to the CSV file containing patient data. Default is `data/patients.csv`.
+- `--phone`: Phone number to include in the outreach emails. Default is `123-456-7890`.
+- `--email`: Reply email address to include in the outreach emails. Default is `[email protected]`.
+- `--name`: Name to include in the outreach emails. Default is `Benjamin Consolvo`.
+
+This will process the patient data, filter based on the specified criteria, and generate outreach emails for the patients. The emails will be saved as text files in the `data/` directory.
+
+### 6 Lessons Learned
+
+1. Some LLMs perform better than others at certain tasks. While this may seem obvious, in practice, you often need to adjust which LLMs you use after seeing the results. In my case, I found that [meta-llama/Llama-3.3-70B-Instruct](https://huggingface.co/meta-llama/Llama-3.3-70B-Instruct) model was much more consistent and hallucinated less than [mistralai/Mixtral-8x7B-v0.1](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1) for email generation.
+2. Setting temperature to 0 is important for getting a consistent output response from LLMs. In my use-case, I ended up setting this creativity level to 0 across all models. 
+3. Prompt engineering is very important in the age of instructing LLMs on what to do. My top 3 tips:
+    - Be specific and detailed
+    - Give exact output format examples
+    - Tell the LLM what to do, rather than telling it everything it should not do
+
+    You can read more about prompt engineering on [OpenAI's blog here](https://help.openai.com/en/articles/6654000-best-practices-for-prompt-engineering-with-the-openai-api)
+
+4. Certain tasks are easier to manage with traditional programming rather than building an agent to do it. In the case of getting data consistently from a database with a specified format, write a function rather than building an agent. The LLM may hallucinate and not carry out the task correctly. I implemented this after fighting with the agents in a function called `get_patients_from_criteria`. When I started this project, the LLMs were inventing data that were not a part of the database, even though I clearly instructed the agent to only use data from the database! To resolve this, I made sure that the agent was using a specific function to read from the database with a tool-call.
+5. Do operations asynchronously wherever possible. Instead of writing emails one by one in a for loop, write them all at once with `async`. 
+6. Code writing tools like GitHub Copilot, Cursor, and Windsurf can save a lot of time, but you still need to pay attention to the output and understand what is going on with the code. A lot of unecessary lines of code and technical debt will be accumulated by relying purely on code generation tools.
+
+### Follow Up
+
+Get your own OpenAI-compatible API key and connect your agents to LLMs on Intel® Gaudi® accelerators with just an endpoint, courtesy of cloud-provider Denvr Dataworks: https://www.denvrdata.com/intel
+
+Chat with 6K+ fellow developers on the Intel DevHub Discord: https://discord.gg/kfJ3NKEw5t
+
+Connect with me on LinkedIn: https://linkedin.com/in/bconsolvo
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).

app.py

@@ -0,0 +1,551 @@
+import streamlit as st
+import pandas as pd
+import asyncio
+import io
+import contextlib
+import os
+from pathlib import Path
+from intelpreventativehealthcare import (
+    target_patients_outreach,
+    find_patients,
+    write_outreach_emails,
+    get_configs,
+)
+# Import the prompt templates
+from intelpreventativehealthcare import (
+    USER_PROXY_PROMPT,
+    EPIDEMIOLOGIST_PROMPT,
+    DOCTOR_CRITIC_PROMPT,
+    OUTREACH_EMAIL_PROMPT_TEMPLATE,
+)
+from openai import OpenAI
+import streamlit.components.v1 as components  # Add this import for custom HTML
+
+# Streamlit app configuration
+st.set_page_config(page_title="Preventative Healthcare Outreach", layout="wide")
+
+# Title at the top of the app
+st.title("Preventative Healthcare Outreach")
+st.markdown("""
+    Visit the README page below to learn how the agentic system works. The system uses AI agents to generate outreach criteria, filter patients, and ultimately write outreach emails. To get the agents working, you can follow these steps:
+    1. Optionally, customize the prompts of the agents, or just use the default ones to get started.
+    2. Select default patient data, or upload your own CSV file.
+    3. Describe a medical screening task.
+    4. Click on "Generate Outreach Emails" to create draft emails to patients (.txt files with email drafts).
+    """)
+
+# Function to read README.md file
+def read_readme():
+    readme_path = Path(__file__).parent / "README.md"
+    
+    if readme_path.exists():
+        with open(readme_path, 'r') as f:
+            readme_content = f.read()
+            return readme_content
+    else:
+        return "README.md file not found in the project directory."
+
+# Function to embed SVG images directly into the markdown content
+def fix_svg_images_in_markdown(markdown_content):
+    import re
+    
+    # Find SVG image tags in the markdown content
+    svg_pattern = r'<img[^>]*src="([^"]*\.svg)"[^>]*>'
+    
+    def replace_with_embedded_svg(match):
+        img_tag = match.group(0)
+        src_match = re.search(r'src="([^"]*)"', img_tag)
+        if not src_match:
+            return img_tag
+            
+        src_path = src_match.group(1)
+        width_match = re.search(r'width="([^"]*)"', img_tag)
+        width = width_match.group(1) if width_match else "100%"
+        
+        # Construct full path to the image
+        img_path = Path(__file__).parent / src_path
+        
+        if img_path.exists():
+            try:
+                # Read SVG content directly
+                with open(img_path, 'r') as f:
+                    svg_content = f.read()
+                
+                # Create a custom HTML component for the SVG with proper styling
+                return f"""<div style="text-align:center; margin:20px 0;">
+                    <div style="max-width:{width}px; margin:0 auto;">
+                        {svg_content}
+                    </div>
+                </div>"""
+            except Exception as e:
+                return f"""<div style="text-align:center; color:red; padding:10px;">
+                    Error loading SVG image: {e}
+                </div>"""
+        else:
+            return f"""<div style="text-align:center; color:red; padding:10px;">
+                Image not found: {src_path}
+            </div>"""
+    
+    # Replace all SVG image tags with embedded SVG content
+    return re.sub(svg_pattern, replace_with_embedded_svg, markdown_content)
+
+# Create tabs
+tab1, tab2 = st.tabs(["Healthcare Outreach App", "README"])
+
+# Initialize session state for prompts if not already present
+if 'user_proxy_prompt' not in st.session_state:
+    st.session_state.user_proxy_prompt = USER_PROXY_PROMPT
+if 'epidemiologist_prompt' not in st.session_state:
+    st.session_state.epidemiologist_prompt = EPIDEMIOLOGIST_PROMPT
+if 'doctor_critic_prompt' not in st.session_state:
+    st.session_state.doctor_critic_prompt = DOCTOR_CRITIC_PROMPT
+if 'outreach_email_prompt' not in st.session_state:
+    st.session_state.outreach_email_prompt = OUTREACH_EMAIL_PROMPT_TEMPLATE
+
+# Main Healthcare App Tab (Tab 1)
+with tab1:
+    # --- Activity/log screen for agent communication ---
+    st.markdown("### Activity Log")
+    # Create a container with fixed height and scrollbar for logs
+    log_container = st.container()
+    with log_container:
+        # Use an expander that's open by default to contain the log
+        with st.expander("Real-time Log", expanded=True):
+            log_placeholder = st.empty()
+
+    # --- Move user inputs, instructions, and CSV column info to sidebar ---
+    with st.sidebar:
+        # Add a section for customizing prompts at the top of the sidebar
+        st.markdown("### Customize Agent Prompts")
+        st.caption("The agents use LLMs and natural language understanding (NLU) to organize the tasks they need to accomplish. You can modify the prompts for each agent below; these prompts are given to the agents so that they can work together to produce the final outreach emails for the preventative healthcare task at hand.")
+        
+        # User Proxy Prompt
+        with st.expander("User Proxy Prompt"):
+            user_prompt = st.text_area(
+                "User Proxy Prompt",
+                value=st.session_state.user_proxy_prompt, 
+                height=300,
+                key="user_proxy_input",
+                label_visibility="hidden",
+                # Add these style properties to preserve whitespace formatting
+                help="",
+                placeholder="",
+                disabled=False,
+                # Use CSS to preserve whitespace formatting
+                max_chars=None
+            )
+            st.session_state.user_proxy_prompt = user_prompt
+        
+        # Epidemiologist Prompt
+        with st.expander("Epidemiologist Prompt"):
+            epi_prompt = st.text_area(
+                "Epidemiologist Prompt", 
+                value=st.session_state.epidemiologist_prompt, 
+                height=300,
+                key="epidemiologist_input",
+                label_visibility="hidden",
+                help="",
+                placeholder="",
+                disabled=False,
+                max_chars=None
+            )
+            st.session_state.epidemiologist_prompt = epi_prompt
+        
+        # Doctor Critic Prompt
+        with st.expander("Doctor Critic Prompt"):
+            doc_prompt = st.text_area(
+                "Doctor Critic Prompt", 
+                value=st.session_state.doctor_critic_prompt, 
+                height=300,
+                key="doctor_critic_input",
+                label_visibility="hidden",
+                help="",
+                placeholder="",
+                disabled=False,
+                max_chars=None
+            )
+            st.session_state.doctor_critic_prompt = doc_prompt
+        
+        # Outreach Email Prompt Template
+        with st.expander("Email Template Prompt"):
+            email_prompt = st.text_area(
+                "Email Template Prompt", 
+                value=st.session_state.outreach_email_prompt, 
+                height=300,
+                key="email_template_input",
+                label_visibility="hidden",
+                help="",
+                placeholder="",
+                disabled=False,
+                max_chars=None
+            )
+            st.session_state.outreach_email_prompt = email_prompt
+        
+        # Add custom CSS to preserve whitespace in text areas while ensuring content fits
+        st.markdown("""
+        <style>
+        .stTextArea textarea {
+            font-family: monospace;
+            white-space: pre-wrap !important;  /* Use pre-wrap to preserve whitespace but allow wrapping */
+            word-wrap: break-word !important;  /* Ensure words break to next line if needed */
+            line-height: 1.4;
+            tab-size: 2;                       /* Reduce tab size to save space */
+            padding: 8px;
+            font-size: 0.9em;                  /* Slightly smaller font to fit more content */
+        }
+        </style>
+        """, unsafe_allow_html=True)
+        
+        # Reset prompts button
+        if st.button("Reset Prompts to Default"):
+            st.session_state.user_proxy_prompt = USER_PROXY_PROMPT
+            st.session_state.epidemiologist_prompt = EPIDEMIOLOGIST_PROMPT
+            st.session_state.doctor_critic_prompt = DOCTOR_CRITIC_PROMPT
+            st.session_state.outreach_email_prompt = OUTREACH_EMAIL_PROMPT_TEMPLATE
+            st.rerun()
+        
+        st.markdown("---")
+        
+        # Now add the "Get started" section after the prompts
+        st.header("Patient Data and Screening Task")
+    
+        st.caption("Required CSV columns: patient_id, First Name, Last Name, Email, Patient diagnosis summary, age, gender, condition")
+        
+        # Create a container for the default dataset option to control its appearance
+        default_dataset_container = st.container()
+        
+        # Add the file upload option after the default dataset option
+        uploaded_file = st.file_uploader("Upload your own CSV file with patient data", type=["csv"])
+        
+        # If a file is uploaded, show a message and disable the default checkbox
+        if uploaded_file is not None:
+            # Visual indication that custom data is being used
+            st.success("✅ Using your uploaded file")
+            
+            # Disable the default dataset option with clear visual feedback
+            with default_dataset_container:
+                st.markdown("""
+                <div style="opacity: 0.5; pointer-events: none;">
+                    <input type="checkbox" disabled> Use default dataset (data/patients.csv)
+                    <div style="font-size: 0.8em; color: #999; font-style: italic;">
+                        Disabled because custom file is uploaded
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            # Set use_default to False when a file is uploaded
+            use_default = False
+        else:
+            # No file uploaded, show normal checkbox
+            with default_dataset_container:
+                use_default = st.checkbox("Use default dataset (data/patients.csv)", value=True)
+        
+        screening_task = st.text_input("Enter the medical screening task (e.g., 'Colonoscopy screening')", "")
+        
+        # Add contact information section
+        st.markdown("---")
+        st.subheader("Healthcare Provider Contact Information")
+        st.caption("This information will appear in the emails sent to patients")
+        
+        # Create three columns for contact info fields
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            provider_name = st.text_input("Provider Name", "Benjamin Consolvo")
+            
+        with col2:
+            provider_email = st.text_input("Provider Email", "[email protected]")
+            
+        with col3:
+            provider_phone = st.text_input("Provider Phone", "123-456-7890")
+        
+        # Validate input fields before enabling the button
+        required_fields_empty = (
+            screening_task.strip() == "" or
+            provider_name.strip() == "" or
+            provider_email.strip() == "" or
+            provider_phone.strip() == ""
+        )
+        
+        if required_fields_empty:
+            st.warning("Please fill in all required fields before proceeding.")
+        st.markdown("---")
+        # Move the button to the sidebar - disabled if required fields are empty
+        generate = st.button("Generate Outreach Emails", disabled=required_fields_empty)
+
+    # Explicitly set environment variable to avoid TTY errors
+    os.environ["PYTHONUNBUFFERED"] = "1"
+
+    # Only run the generation logic if we're on the first tab
+    if tab1._active and generate:
+        # Since the button can only be clicked when all fields are filled,
+        # we don't need additional validation here
+        
+        # Hugging Face secrets
+        api_key = st.secrets["OPENAI_API_KEY"]
+        base_url = st.secrets["OPENAI_BASE_URL"]
+
+        # --- Initialize log ---
+        log_messages = []
+        def log(msg):
+            log_messages.append(msg)
+            # Show all messages in the scrollable container with better contrast
+            log_placeholder.markdown(
+                f"""
+                <div style="height: 400px; overflow-y: auto; border: 1px solid #cccccc; 
+                     padding: 15px; border-radius: 5px; background-color: rgba(240, 242, 246, 0.4); 
+                     color: inherit; font-family: monospace;">
+                    {"<br>".join(log_messages)}
+                </div>
+                """, 
+                unsafe_allow_html=True
+            )
+
+        # Capture stdout/stderr during the workflow
+        stdout_buffer = io.StringIO()
+        stderr_buffer = io.StringIO()
+        with contextlib.redirect_stdout(stdout_buffer), contextlib.redirect_stderr(stderr_buffer):
+            if not screening_task:
+                st.error("Please enter a medical screening task.")
+            elif not uploaded_file and not use_default:
+                st.error("Please upload a CSV file or select the default dataset.")
+            else:
+                # Load patient data
+                if uploaded_file:
+                    patients_file = uploaded_file
+                else:
+                    # Use absolute path for default dataset
+                    patients_file = os.path.join(os.path.dirname(__file__), "data/patients.csv")
+
+                try:
+                    patients_df = pd.read_csv(patients_file)
+                except Exception as e:
+                    st.error(f"Error reading the CSV file: {e}")
+                    st.stop()
+
+                # Validate required columns
+                required_columns = [
+                    'patient_id', 'First Name', 'Last Name', 'Email',
+                    'Patient diagnosis summary', 'age', 'gender', 'condition'
+                ]
+                if not all(col in patients_df.columns for col in required_columns):
+                    st.error(f"The uploaded CSV file is missing required columns: {required_columns}")
+                    st.stop()
+
+                # Load configurations
+                llama_filter_dict = {"model": ["meta-llama/Llama-3.3-70B-Instruct"]}
+                deepseek_filter_dict = {"model": ["deepseek-ai/DeepSeek-R1-Distill-Llama-70B"]}
+                config_list_llama = get_configs("OAI_CONFIG_LIST.json", llama_filter_dict)
+                config_list_deepseek = get_configs("OAI_CONFIG_LIST.json", deepseek_filter_dict)
+
+                # Ensure the API key from secrets is used
+                for config in config_list_llama:
+                    config["api_key"] = api_key
+                for config in config_list_deepseek:
+                    config["api_key"] = api_key
+
+                # --- Log agent communication ---
+                log("🟢 <b>Starting agent workflow...</b>")
+                log("🧑‍⚕️ <b>Screening task:</b> " + screening_task)
+                log("📄 <b>Loaded patient data:</b> {} records".format(len(patients_df)))
+
+                # Generate criteria for outreach - Pass the custom prompts
+                log("🤖 <b>Agent (Llama):</b> Generating outreach criteria...")
+                criteria = asyncio.run(target_patients_outreach(
+                    screening_task, config_list_llama, config_list_deepseek,
+                    log_fn=log if "log_fn" in target_patients_outreach.__code__.co_varnames else None,
+                    user_proxy_prompt=st.session_state.user_proxy_prompt,
+                    epidemiologist_prompt=st.session_state.epidemiologist_prompt,
+                    doctor_critic_prompt=st.session_state.doctor_critic_prompt
+                ))
+                log("✅ <b>Criteria generated.</b>")
+
+                # Find patients matching criteria
+                log("🤖 <b>Agent (Llama):</b> Filtering patients based on criteria...")
+                filtered_patients, arguments_criteria = asyncio.run(find_patients(
+                    criteria, config_list_llama,
+                    log_fn=log if "log_fn" in find_patients.__code__.co_varnames else None,
+                    patients_file_path=patients_file  # Use correct parameter name: patients_file_path
+                ))
+                log("✅ <b>Patients filtered.</b>")
+
+                if filtered_patients.empty:
+                    log("⚠️ <b>No patients matched the criteria.</b>")
+                    st.warning("No patients matched the criteria.")
+                else:
+                    # Initialize OpenAI client
+                    openai_client = OpenAI(api_key=api_key, base_url=base_url)
+
+                    # Generate outreach emails - Pass the custom email template
+                    log("🤖 <b>Agent (Llama):</b> Generating outreach emails...")
+                    asyncio.run(write_outreach_emails(
+                        filtered_patients,
+                        screening_task,
+                        arguments_criteria,
+                        openai_client,
+                        config_list_llama[0]['model'],
+                        phone=provider_phone,  # Pass the provider's phone from form
+                        email=provider_email,  # Pass the provider's email from form
+                        name=provider_name,    # Pass the provider's name from form
+                        log_fn=log if "log_fn" in write_outreach_emails.__code__.co_varnames else None,
+                        outreach_email_prompt_template=st.session_state.outreach_email_prompt
+                    ))
+                    
+                    # Make sure data directory exists (for Hugging Face Spaces)
+                    data_dir = os.path.join(os.path.dirname(__file__), "data")
+                    os.makedirs(data_dir, exist_ok=True)
+                    
+                    # Generate expected email filenames based on filtered patients
+                    expected_email_files = []
+                    for _, patient in filtered_patients.iterrows():
+                        # Construct the expected filename based on patient data
+                        firstname = patient['First Name']
+                        lastname = patient['Last Name']
+                        filename = f"{firstname}_{lastname}_email.txt"
+                        if os.path.exists(os.path.join(data_dir, filename)):
+                            expected_email_files.append(filename)
+                    
+                    # Use only the email files for patients in the filtered DataFrame
+                    email_files = expected_email_files
+                    
+                    if email_files:
+                        log("✅ <b>Outreach emails generated successfully:</b> {} emails created".format(len(email_files)))
+                        st.success(f"{len(email_files)} outreach emails have been generated!")
+                        
+                        # Create a section for downloads
+                        st.markdown("### Download Generated Emails")
+                        
+                        # Store email content in session state to persist across interactions
+                        if 'email_contents' not in st.session_state:
+                            st.session_state.email_contents = {}
+                            for email_file in email_files:
+                                with open(os.path.join(data_dir, email_file), 'r') as f:
+                                    st.session_state.email_contents[email_file] = f.read()
+                        
+                        # Create ZIP file only once and store in session state
+                        if 'zip_buffer' not in st.session_state:
+                            import zipfile
+                            zip_buffer = io.BytesIO()
+                            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+                                for email_file, content in st.session_state.email_contents.items():
+                                    zip_file.writestr(email_file, content)
+                            st.session_state.zip_buffer = zip_buffer.getvalue()
+                        
+                        # Create base64 encoding of zip file
+                        import base64
+                        b64_zip = base64.b64encode(st.session_state.zip_buffer).decode()
+                        
+                        # Create HTML for ZIP download - Use components.html instead of st.markdown
+                        zip_html = f"""
+                        <div style="margin-bottom: 20px;">
+                            <a href="data:application/zip;base64,{b64_zip}" 
+                               download="patient_emails.zip" 
+                               style="text-decoration: none; display: inline-block; padding: 12px 18px; 
+                               border: 1px solid #ddd; border-radius: 4px; background-color: #4CAF50; 
+                               color: white; font-size: 16px; font-weight: bold; text-align: center;">
+                                📦 Download All Emails as ZIP
+                            </a>
+                        </div>
+                        """
+                        
+                        # Use components.html instead of st.markdown for ZIP download
+                        components.html(zip_html, height=70)
+                        
+                        st.markdown("---")
+                        st.markdown("#### Individual Email Downloads")
+                        
+                        # Generate HTML for individual email downloads
+                        individual_html = """
+                        <div style="display: flex; flex-wrap: wrap; gap: 8px;">
+                        """
+                        
+                        # Generate download links for all emails
+                        for i, email_file in enumerate(email_files):
+                            file_content = st.session_state.email_contents.get(email_file, "")
+                            # Create a base64 encoded version of the file content
+                            b64_content = base64.b64encode(file_content.encode()).decode()
+                            
+                            # Extract a more complete display name (First + Last name)
+                            name_parts = email_file.split('_')[:2]  # Get first and last name parts
+                            display_name = " ".join(name_parts)  # Join with space to create "First Last"
+                            
+                            # Add download link to HTML
+                            individual_html += f"""
+                            <a href="data:text/plain;base64,{b64_content}" 
+                               download="{email_file}" 
+                               style="text-decoration: none; display: inline-block; margin: 4px; padding: 8px 12px; 
+                               border: 1px solid #ddd; border-radius: 4px; background-color: #f0f2f6; 
+                               color: #262730; font-size: 14px; text-align: center; min-width: 120px;">
+                                {display_name}
+                            </a>
+                            """
+                        
+                        individual_html += """
+                        </div>
+                        """
+                        
+                        # Use components.html for individual downloads - estimate height based on number of emails
+                        # Increase height calculation to account for potentially longer names
+                        components.html(individual_html, height=100 + (len(email_files) // 4) * 60)
+                        
+                    else:
+                        log("⚠️ <b>Email generation process completed but no email files were found.</b>")
+                        st.warning("The email generation process completed but no email files were found in the data directory. This might indicate an issue with the email generation or file saving process.")
+
+        # After workflow, append captured output
+        std_output = stdout_buffer.getvalue()
+        std_error = stderr_buffer.getvalue()
+        
+        if std_output:
+            log_messages.append("<b>Terminal Output:</b>")
+            for line in std_output.splitlines():
+                if line.strip():  # Skip empty lines
+                    log_messages.append(line)
+            # Update the log display with all messages using better contrast
+            log_placeholder.markdown(
+                f"""
+                <div style="height: 400px; overflow-y: auto; border: 1px solid #cccccc; 
+                     padding: 15px; border-radius: 5px; background-color: rgba(240, 242, 246, 0.4); 
+                     color: inherit; font-family: monospace;">
+                    {"<br>".join(log_messages)}
+                </div>
+                """, 
+                unsafe_allow_html=True
+            )
+            
+        if std_error:
+            log_messages.append("<b style='color:#ff6b6b;'>Terminal Error:</b>")
+            for line in std_error.splitlines():
+                if line.strip():  # Skip empty lines
+                    log_messages.append(f"<span style='color:#ff6b6b;'>{line}</span>")
+            # Update the log display with all messages
+            log_placeholder.markdown(
+                f"""
+                <div style="height: 400px; overflow-y: auto; border: 1px solid #cccccc; 
+                     padding: 15px; border-radius: 5px; background-color: rgba(240, 242, 246, 0.4);
+                     color: inherit; font-family: monospace;">
+                    {"<br>".join(log_messages)}
+                </div>
+                """, 
+                unsafe_allow_html=True
+            )
+
+# README Tab (Tab 2)
+with tab2:
+    readme_content = read_readme()
+    
+    # Process the README content to properly handle SVG images
+    readme_with_embedded_svgs = fix_svg_images_in_markdown(readme_content)
+    
+    # Use unsafe_allow_html=True to render HTML content properly
+    st.markdown(readme_with_embedded_svgs, unsafe_allow_html=True)
+    
+    # Add CSS to ensure SVGs are responsive and display properly
+    st.markdown("""
+    <style>
+    svg {
+        max-width: 100%;
+        height: auto;
+    }
+    </style>
+    """, unsafe_allow_html=True)

intelpreventativehealthcare.py

@@ -0,0 +1,649 @@
+# The code is a simulation of a healthcare system that uses AI agents to manage patient outreach
+# Author: Benjamin Consolvo
+# Originally created in 2025
+# Original code and idea from Mike Lynch on Medium here. Heavily modified.
+# https://medium.com/@micklynch_6905/hospitalgpt-managing-a-patient-population-with-autogen-powered-by-gpt-4-mixtral-8x7b-ef9f54f275f1
+# https://github.com/micklynch/hospitalgpt
+
+import os
+import asyncio
+import pandas as pd
+import json
+import argparse
+from typing import Callable, Dict, Any
+from autogen import (
+    AssistantAgent,
+    UserProxyAgent,
+    config_list_from_json,
+    GroupChat,
+    GroupChatManager,
+    register_function,
+)
+from openai import OpenAI
+from prompts.epidemiologist_prompt import EPIDEMIOLOGIST_PROMPT
+from prompts.doctor_critic_prompt import DOCTOR_CRITIC_PROMPT
+from prompts.user_proxy_prompt import USER_PROXY_PROMPT
+from prompts.outreach_email_prompt import OUTREACH_EMAIL_PROMPT_TEMPLATE
+import aiofiles  # For asynchronous file writing
+import functools  # For wrapping synchronous functions in async
+
+# Export the prompt variables for use in the app
+__all__ = [
+    "get_configs", "target_patients_outreach", "find_patients", 
+    "write_outreach_emails", "USER_PROXY_PROMPT", "EPIDEMIOLOGIST_PROMPT", 
+    "DOCTOR_CRITIC_PROMPT", "OUTREACH_EMAIL_PROMPT_TEMPLATE"
+]
+
+def get_configs(
+    env_or_file: str,
+    filter_dict: Dict[str, Any]
+    ) -> Dict[str, Any]:
+    """
+    Load configuration from a JSON file.
+
+    Args:
+        env_or_file (str): Path to the JSON file or environment variable name.
+        filter_dict (Dict[str, Any]): Dictionary to filter the configuration file.
+
+    Returns:
+        Dict[str, Any]: Filtered configuration dictionary.
+    """
+    return config_list_from_json(env_or_file=env_or_file, filter_dict=filter_dict)
+
+async def target_patients_outreach(
+    target_screening: str,
+    config_list_llama: Dict[str, Any],
+    config_list_deepseek: Dict[str, Any],
+    log_fn=None,
+    user_proxy_prompt=USER_PROXY_PROMPT,
+    epidemiologist_prompt=EPIDEMIOLOGIST_PROMPT,
+    doctor_critic_prompt=DOCTOR_CRITIC_PROMPT
+    ) -> str:
+    """
+    Determines the criteria for patient outreach based on a screening task.
+
+    This function facilitates a conversation between a user, an epidemiologist, 
+    and a doctor critic to define the criteria for patient outreach. The output 
+    criteria from the doctor and epidemiologist include minimum age, maximum age, 
+    gender, and a possible previous condition.
+
+    Example:
+
+        criteria = asyncio.run(target_patients_outreach("Type 2 diabetes screening"))
+
+    Args:
+        target_screening (str): The type of screening task (e.g., "Type 2 diabetes screening").
+        config_list_llama (Dict[str, Any]): Configuration for the Llama model.
+        config_list_deepseek (Dict[str, Any]): Configuration for the Deepseek model.
+        log_fn (callable, optional): Function for logging messages.
+        user_proxy_prompt (str, optional): Custom prompt for the user proxy agent.
+        epidemiologist_prompt (str, optional): Custom prompt for the epidemiologist agent.
+        doctor_critic_prompt (str, optional): Custom prompt for the doctor critic agent.
+
+    Returns:
+        str: The defined criteria for patient outreach.
+    """
+    llm_config_llama: Dict[str, Any] = {
+        "cache_seed": 41,
+        "temperature": 0,
+        "config_list": config_list_llama,
+        "timeout": 120,
+    }
+
+    llm_config_deepseek: Dict[str, Any] = {
+        "cache_seed": 42,
+        "temperature": 0,
+        "config_list": config_list_deepseek,
+        "timeout": 120,
+    }
+
+    user_proxy = UserProxyAgent(
+        name="User",
+        is_termination_msg=lambda x: (
+            x.get("content", "") and x.get("content", "").rstrip().endswith("TERMINATE")
+        ),
+        human_input_mode="NEVER",
+        description=user_proxy_prompt,  # Use custom prompt
+        code_execution_config=False,
+        max_consecutive_auto_reply=1,
+    )
+
+    epidemiologist = AssistantAgent(
+        name="Epidemiologist",
+        system_message=epidemiologist_prompt,  # Use custom prompt
+        llm_config=llm_config_llama,
+        code_execution_config=False,
+        is_termination_msg=lambda x: (
+            x.get("content", "") and x.get("content", "").rstrip().endswith("TERMINATE")
+        ),
+    )
+
+    critic = AssistantAgent(
+        name="DoctorCritic",
+        system_message=doctor_critic_prompt,  # Use custom prompt
+        llm_config=llm_config_deepseek,
+        human_input_mode="NEVER",
+        code_execution_config=False,
+        is_termination_msg=lambda x: (
+            x.get("content", "") and x.get("content", "").rstrip().endswith("TERMINATE")
+        ),
+    )
+
+    groupchat = GroupChat(
+        agents=[user_proxy, epidemiologist, critic],
+        messages=[]
+    )
+    manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config_llama)
+
+    user_proxy.initiate_chat(
+        manager,
+        message=target_screening,
+    )
+    if log_fn:
+        log_fn("Agent conversation complete.")
+    user_proxy.stop_reply_at_receive(manager)
+    result = user_proxy.last_message()["content"]
+    if log_fn:
+        log_fn(f"Criteria result: {result}")
+    return result
+
+def get_patients_from_criteria(
+    patients_file: str,
+    min_age: int,
+    max_age: int,
+    criteria: str,
+    gender: str
+    ) -> pd.DataFrame:
+    """
+    Filters patient data from a CSV file based on specified criteria.
+
+    This function reads patient data from a CSV file and filters it based on 
+    age range, gender, and a specific condition.
+
+    Example:
+
+        filtered_patients = get_patients_from_criteria(
+            patients_file="data/patients.csv",
+            min_age=40,
+            max_age=70,
+            criteria="Adenomatous Polyps",
+            gender="None"
+        )
+
+    Args:
+        patients_file (str): Path to the CSV file containing patient data.
+        min_age (int): Minimum age for filtering.
+        max_age (int): Maximum age for filtering.
+        criteria (str): Condition to filter patients by.
+        gender (str, optional): Gender to filter patients by. Defaults to None.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing the filtered patient data.
+    """
+    required_columns = [
+        'patient_id', 'First Name', 'Last Name', 'Email',
+        'Patient diagnosis summary', 'age', 'gender', 'condition'
+    ]
+
+    # Support both file path (str) and file-like object (e.g., from Streamlit)
+    if hasattr(patients_file, "read"):
+        # Reset pointer in case it's been read before
+        patients_file.seek(0)
+        patients_df = pd.read_csv(patients_file)
+    else:
+        patients_df = pd.read_csv(patients_file)
+
+    for column in required_columns:
+        if column not in patients_df.columns:
+            raise ValueError(f"Missing required column: {column}")
+
+    # Ensure all text is lowercase for case-insensitive matching
+    patients_df['condition'] = patients_df['condition'].str.lower()
+    criteria = criteria.lower()
+
+    # Filter by condition matching
+    condition_filter = patients_df['condition'].str.contains(criteria, na=False)
+
+    # Filter by age range
+    age_filter = (patients_df['age'] >= min_age) & (patients_df['age'] <= max_age)
+
+    # Combine filters with OR logic
+    combined_filter = age_filter | condition_filter
+    
+    if gender in ['M', 'F']:
+        gender_filter = patients_df['gender'].str.upper() == gender.upper()
+        combined_filter = combined_filter & gender_filter
+
+    return patients_df[combined_filter]
+
+def register_function(
+    assistant: AssistantAgent,
+    user_proxy: UserProxyAgent,
+    func: Callable,
+    name: str,
+    description: str
+    ) -> None:
+    """
+    This function allows an assistant agent and a user proxy agent to execute 
+    a specified function.
+
+    Example:
+        register_function(
+            assistant=assistant_agent,
+            user_proxy=user_proxy_agent,
+            func=my_function,
+            name="my_function",
+            description="This is a test function."
+        )
+
+    Args:
+        assistant (AssistantAgent): The assistant agent to register the function.
+        user_proxy (UserProxyAgent): The user proxy agent to register the function.
+        func (Callable): The function to register.
+        name (str): The name of the function.
+        description (str): A description of the function.
+    """
+
+    assistant.register_for_llm(
+        name=name,
+        description=description
+        )(func)
+
+    user_proxy.register_for_execution(
+        name=name
+        )(func)
+
+    return None
+
+async def find_patients(
+    criteria: str,
+    config_list_llama: Dict[str, Any],
+    log_fn=None,
+    patients_file_path=None  # Can be a path or a file-like object
+    ) -> pd.DataFrame:
+    """
+    Finds patients matching specific criteria using agents.
+    
+    This function uses a user proxy agent and a data analyst agent to filter 
+    patient data based on the provided criteria.
+
+    Example:
+        patients_df = asyncio.run(find_patients(criteria="Patients aged 40 to 70"))
+
+    Args:
+        criteria (str): The criteria for filtering patients.
+        config_list_llama (Dict[str, Any]): Configuration for the Llama model.
+        log_fn (callable, optional): Function for logging messages.
+        patients_file_path: Path to patient data file or file-like object.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing the filtered patient data.
+    """
+    # Set up a temporary file path for the agent to use
+    temp_file_path = None
+    
+    # If we have a file-like object (from Streamlit), save it to a temp file
+    if patients_file_path is not None and hasattr(patients_file_path, "read"):
+        try:
+            # Create data directory if it doesn't exist
+            os.makedirs("data", exist_ok=True)
+            temp_file_path = os.path.join("data", "temp_patients.csv")
+            
+            # Reset the file pointer and read with pandas
+            patients_file_path.seek(0)
+            temp_df = pd.read_csv(patients_file_path)
+            
+            # Save to the temp location
+            temp_df.to_csv(temp_file_path, index=False)
+            
+            if log_fn:
+                log_fn(f"Saved uploaded file to temporary location: {temp_file_path}")
+                
+            # Update the criteria to include the file path
+            criteria = f"The patient data is available at {temp_file_path}. " + criteria
+        except Exception as e:
+            if log_fn:
+                log_fn(f"Error preparing patient file: {str(e)}")
+            raise
+    elif isinstance(patients_file_path, str):
+        # It's a regular file path
+        temp_file_path = patients_file_path
+        criteria = f"The patient data is available at {temp_file_path}. " + criteria
+    
+    # Configure the LLM
+    llm_config_llama: Dict[str, Any] = {
+        "cache_seed": 43,
+        "temperature": 0,
+        "config_list": config_list_llama,
+        "timeout": 120,
+        "tools": []
+    }
+
+    user_proxy = UserProxyAgent(
+        name="user_proxy",
+        code_execution_config={"last_n_messages": 2, "work_dir": "data/", "use_docker": False},
+        is_termination_msg=lambda x: x.get("content", "") and x.get(
+            "content", "").rstrip().endswith("TERMINATE"),
+        human_input_mode="NEVER",
+        llm_config=llm_config_llama,
+        # reflect_on_tool_use=True
+    )
+
+    data_analyst = AssistantAgent(
+        name="data_analyst",
+        code_execution_config={
+            "last_n_messages": 2, 
+            "work_dir": "data/", 
+            "use_docker": False},
+        llm_config=llm_config_llama,
+        # reflect_on_tool_use=True
+    )
+
+    register_function(
+        data_analyst, 
+        user_proxy, 
+        get_patients_from_criteria, 
+        "get_patients_from_criteria", 
+        "Extract and filter patient information based on criteria."
+    )
+    # --- Fix: Properly extract arguments from the agent conversation ---
+    arguments = None  # Ensure arguments is defined in this scope
+
+    def user_proxy_reply(message: str):
+        nonlocal temp_file_path
+        try:
+            if "arguments:" in message:
+                arguments_str = message.split("arguments:")[1].strip().split("\n")[0]
+                args = eval(arguments_str)
+                
+                # Override the file path with our temp file if available
+                if temp_file_path:
+                    args['patients_file'] = temp_file_path
+                    if log_fn:
+                        log_fn(f"Using patient data from: {temp_file_path}")
+                
+                return "Tool call received. \nTERMINATE", args
+        except Exception as e:
+            if log_fn:
+                log_fn(f"Error extracting arguments: {e}")
+            return f"Error executing function: {str(e)} \nTERMINATE"
+        return "Function call not recognized. \nTERMINATE"
+
+    user_proxy.reply_handler = user_proxy_reply
+    if log_fn:
+        log_fn(f"Set up reply handler with temp file path: {temp_file_path}")
+
+    groupchat = GroupChat(agents=[user_proxy, data_analyst], messages=[])
+    manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config_llama)
+
+    chat_output = user_proxy.initiate_chat(data_analyst, message=f"{criteria}")
+    user_proxy.stop_reply_at_receive(manager)
+    if log_fn:
+        log_fn("Agent conversation for patient filtering complete.")
+
+    # Always extract arguments from chat history after chat
+    if chat_output and hasattr(chat_output, "chat_history"):
+        chat_history = chat_output.chat_history
+        for message in chat_history:
+            if "tool_calls" in message:
+                tool_calls = message["tool_calls"]
+                for tool_call in tool_calls:
+                    function = tool_call.get("function", {})
+                    try:
+                        arguments = json.loads(function.get("arguments", None))
+                    except Exception:
+                        arguments = None
+                    if arguments:
+                        break
+            if arguments:
+                break
+
+    if not arguments:
+        if log_fn:
+            log_fn("Arguments were not populated during the chat process.")
+        raise ValueError("Arguments were not populated during the chat process.")
+
+    # Always use the temp file path for the actual data load if available
+    if temp_file_path and arguments:
+        arguments['patients_file'] = temp_file_path
+
+    filtered_df = get_patients_from_criteria(
+        patients_file=arguments['patients_file'],
+        min_age=arguments['min_age'],
+        max_age=arguments['max_age'],
+        criteria=arguments['criteria'],
+        gender=arguments['gender']
+    )
+    if log_fn:
+        log_fn(f"Filtered {len(filtered_df)} patients.")
+    return filtered_df, arguments
+
+async def generate_email(openai_client, patient, email_prompt, model):
+    """
+    Asynchronously generate an email using the OpenAI client.
+
+    Args:
+        openai_client (OpenAI): The OpenAI client instance.
+        patient (dict): The patient data.
+        email_prompt (str): The email prompt to send to the model.
+        model (str): The model to use for generation.
+
+    Returns:
+        str: The generated email content.
+    """
+    # Wrap the synchronous `create` method in an async function
+    create_completion = functools.partial(
+        openai_client.chat.completions.create,
+        model=model,  # Use model from the OpenAI client
+        messages=[{"role": "user", "content": email_prompt}],
+        stream=False,
+        seed=42,
+        temperature=0  # Ensures a consistent output for email (limiting creativity)
+    )
+    chat_completion = await asyncio.get_event_loop().run_in_executor(None, create_completion)
+    return chat_completion.choices[0].message.content
+
+
+async def write_email_to_file(file_path, patient, email_content):
+    """
+    Asynchronously write an email to a file.
+
+    Args:
+        file_path (str): The path to the file.
+        patient (dict): The patient data.
+        email_content (str): The email content to write.
+
+    Returns:
+        None
+    """
+    async with aiofiles.open(file_path, "w") as f:
+        await f.write(f"Name: {patient['First Name']} {patient['Last Name']}\n")
+        await f.write(f"Patient ID: {patient['patient_id']}\n")
+        await f.write(f"Email: {patient['Email']}\n")
+        await f.write(email_content)
+        await f.write("\n")
+        await f.write("-----------------------------------------")
+
+
+async def write_outreach_emails(
+    patient_details: pd.DataFrame,
+    user_proposal: str,
+    arguments_criteria: Dict[str, Any],
+    openai_client: OpenAI,
+    model: str,
+    phone: str = "123-456-7890",
+    email: str = "[email protected]",
+    name: str = "Benjamin Consolvo",
+    log_fn=None,
+    outreach_email_prompt_template=OUTREACH_EMAIL_PROMPT_TEMPLATE
+    ) -> None:
+    """
+    Asynchronously generates and writes outreach emails for patients.
+
+    This function generates personalized emails for patients based on their 
+    details and the specified screening criteria. The emails are written to 
+    individual text files asynchronously.
+
+    Args:
+        patient_details (pd.DataFrame): DataFrame containing patient details.
+        user_proposal (str): The type of screening task (e.g., "Colonoscopy screening").
+        arguments_criteria (Dict[str, Any]): The criteria used for filtering patients.
+        openai_client (OpenAI): The OpenAI client instance.
+        model (str): Model name to use for generation.
+        phone (str): Phone number to include in the outreach emails.
+        email (str): Email address to include in the outreach emails.
+        name (str): Name to include in the outreach emails.
+        log_fn (callable, optional): Function for logging messages.
+        outreach_email_prompt_template (str): Custom template for outreach emails.
+
+    Returns:
+        None
+    """
+    os.makedirs("data", exist_ok=True)
+    if patient_details.empty:
+        msg = "No patients found"
+        print(msg)
+        if log_fn:
+            log_fn(msg)
+        return
+
+    async def process_patient(patient):
+        # Ensure all required fields are present in the patient record
+        required_fields = ['First Name', 'Last Name', 'patient_id', 'Email']
+        for field in required_fields:
+            if field not in patient or pd.isna(patient[field]):
+                msg = f"Skipping patient record due to missing field: {field}"
+                print(msg)
+                if log_fn:
+                    log_fn(msg)
+                return
+
+        # Validate the prompt template
+        try:
+            # Use the custom template instead of the default
+            email_prompt = outreach_email_prompt_template.format(
+                patient=patient.to_dict(),
+                arguments_criteria=arguments_criteria,
+                first_name=patient["First Name"],
+                last_name=patient["Last Name"],
+                user_proposal=user_proposal,
+                name=name,
+                phone=phone,
+                email=email
+            )
+        except KeyError as e:
+            msg = f"Error formatting email prompt: Missing key {e}. Skipping patient."
+            print(msg)
+            if log_fn:
+                log_fn(msg)
+            return
+
+        msg = f'Generating email for {patient["First Name"]} {patient["Last Name"]}'
+        print(msg)
+        if log_fn:
+            log_fn(msg)
+        email_content = await generate_email(openai_client, patient, email_prompt, model)
+
+        file_path = f"data/{patient['First Name']}_{patient['Last Name']}_email.txt"
+        await write_email_to_file(file_path, patient, email_content)
+        if log_fn:
+            log_fn(f"Wrote email to {file_path}")
+
+    tasks = [process_patient(patient) for _, patient in patient_details.iterrows()]
+    await asyncio.gather(*tasks)
+
+    msg = f"All emails have been written to the 'data/' directory."
+    print(msg)
+    if log_fn:
+        log_fn(msg)
+
+def parse_arguments():
+    """
+    Parse command-line arguments for the script.
+
+    Returns:
+        argparse.Namespace: Parsed arguments.
+    """
+    parser = argparse.ArgumentParser(description="Run the Preventative Healthcare Intel script.")
+    parser.add_argument(
+        "--oai_config",
+        type=str,
+        required=True,
+        help="Path to the OAI_CONFIG_LIST.json file."
+    )
+    parser.add_argument(
+        "--target_screening",
+        type=str,
+        required=True,
+        help="The type of screening task (e.g., 'Colonoscopy screening')."
+    )
+    parser.add_argument(
+        "--patients_file",
+        type=str,
+        default="data/patients.csv",
+        help="Path to the CSV file containing patient data. Default is 'data/patients.csv'."
+    )
+    parser.add_argument(
+        "--phone",
+        type=str,
+        default="123-456-7890",
+        help="Phone number to include in the outreach emails. Default is '123-456-7890'."
+    )
+    parser.add_argument(
+        "--email",
+        type=str,
+        default="[email protected]",
+        help="Email address to include in the outreach emails. Default is '[email protected]'."
+    )
+    parser.add_argument(
+        "--name",
+        type=str,
+        default="Benjamin Consolvo",
+        help="Name to include in the outreach emails. Default is 'Benjamin Consolvo'."
+    )
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    # Parse command-line arguments
+    args = parse_arguments()
+
+    llama_filter_dict = {"model": ["meta-llama/Llama-3.3-70B-Instruct"]}
+    config_list_llama = get_configs(args.oai_config,llama_filter_dict)
+
+    deepseek_filter_dict = {"model": ["deepseek-ai/DeepSeek-R1-Distill-Llama-70B"]}
+    config_list_deepseek = get_configs(args.oai_config,deepseek_filter_dict)
+    
+    # Validate API key before initializing OpenAI client
+    api_key = config_list_llama[0].get('api_key')
+    
+    if not api_key:
+        config_list_llama[0]['api_key'] = config_list_deepseek[0]['api_key'] = api_key = os.environ.get("OPENAI_API_KEY")
+
+    # Get the criteria for the target screening
+    # The user provides the screening task.
+    # The epidemiologist and doctor critic will then define the criteria for the outreach.
+    filepath = os.path.join(os.getcwd(), args.patients_file)
+    criteria = f"The patient data is located here: {filepath}."
+    criteria += asyncio.run(target_patients_outreach(args.target_screening,config_list_llama, config_list_deepseek))
+    
+    # The user proxy agent and data analyst
+    # will filter the patients based on the criteria defined by the epidemiologist and doctor critic.
+    patients_df, arguments_criteria = asyncio.run(find_patients(criteria,config_list_llama, patient_data_path=filepath))
+    
+    # Initialize OpenAI client
+    openai_client = OpenAI(
+        api_key=api_key,
+        base_url=config_list_llama[0]['base_url']
+    )
+    
+    #Use LLM to write the outreach emails to text files.
+    asyncio.run(write_outreach_emails(
+        patients_df, 
+        args.target_screening, 
+        arguments_criteria, 
+        openai_client,
+        config_list_llama[0]['model'],
+        phone=args.phone,
+        email=args.email,
+        name=args.name
+    ))

pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "agentchat-intel-preventative-healthcare"
+version = "0.1.0"
+description = "AutoGen Agents for Preventative Healthcare"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "aiofiles>=24.1.0",
+    "anyio>=4.9.0",
+    "argparse>=1.4.0",
+    "asyncio>=3.4.3",
+    "autogen>=0.9",
+    "autogen-ext[openai]>=0.5.6",
+    "distro>=1.9.0",
+    "litellm[proxy]>=1.68.0",
+    "markitdown>=0.1.1",
+    "openai>=1.75.0",
+    "pandas>=2.2.3",
+    "streamlit>=1.25.0",
+]

requirements.txt

@@ -1,3 +1,12 @@
-altair
+distro
+autogen
+autogen-ext[openai]
+litellm[proxy]
+anyio
+markitdown
 pandas
+aiofiles
+argparse
+openai
+asyncio
 streamlit

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))