Spaces:
Running
Running
| 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("Cloud Native Agentic Workflows in Healthcare") | |
| st.markdown(""" | |
| Welcome to your preventative healthcare outreach agentic system, built using the open-source framework [AutoGen](https://github.com/microsoft/autogen). | |
| To improve patient health outcomes, healthcare providers are looking for ways to reach out to patients who may be eligible for preventative screenings. This system is designed to help you automate the process of identifying patients who meet specific screening criteria and generating personalized emails to encourage them to schedule their screenings. | |
| The user provides a very broad screening criteria, and then the system uses AI agents to generate patient-specific criteria, filter patients from a given database, and ultimately write outreach emails to suggest to patients that they schedule a screening. To get the agents working, you can use the sidebar on the left of the UI to: | |
| 1. Customize the prompts for the agents. They use natural language understanding to execute on a workflow. You can use the default ones to get started, and modify to your more specific needs. | |
| 2. Select default (synthetically generated) 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() | |
| # Remove metadata block (everything between the first pair of "---") | |
| if readme_content.startswith("---"): | |
| metadata_end = readme_content.find("---", 3) # Find the closing "---" | |
| if metadata_end != -1: | |
| readme_content = readme_content[metadata_end + 3:].strip() | |
| 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) | |
| st.markdown("For more information about medical screening tasks, you can visit the website below.") | |
| st.link_button("U.S. Preventive Services Task Force","https://www.uspreventiveservicestaskforce.org/uspstf/recommendation-topics/uspstf-a-and-b-recommendations") | |
| screening_task = st.text_input("Enter the medical screening task (e.g., 'Colonoscopy screening').", "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) | |