v2.txt

import gradio as gr
import pandas as pd
import numpy as np
import os
import base64
from together import Together

def extract_medicines(api_key, image):
    """
    Extract medicine names from a prescription image using Together AI's Llama-Vision-Free model
    """
    # Check if API key is provided
    if not api_key:
        return "Please enter your Together API key."
    
    if image is None:
        return "Please upload an image."
    
    try:
        # Initialize Together client with the provided API key
        client = Together(api_key=api_key)
        
        # Convert image to base64
        with open(image, "rb") as img_file:
            img_data = img_file.read()
            b64_img = base64.b64encode(img_data).decode('utf-8')
        
        # Make API call with base64 encoded image
        response = client.chat.completions.create(
            model="meta-llama/Llama-Vision-Free",
            messages=[
                {
                    "role": "system",
                    "content": "You are an expert in identifying medicine names from prescription images."
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": "Please extract the names of the medicines only."
                        },
                        {
                            "type": "image_url",
                            "image_url": {
                                "url": f"data:image/jpeg;base64,{b64_img}"
                            }
                        }
                    ]
                }
            ]
        )
        
        # Extract medicine names from response
        medicine_list = response.choices[0].message.content
        return medicine_list
    
    except Exception as e:
        return f"Error: {str(e)}"

def recommend_medicine(api_key, medicine_name, csv_file=None):
    """
    Use Together API to recommend alternative medicines based on input medicine name
    using data from the provided CSV file with specific column structure.
    It will use AI to find similar medicines even if the exact name isn't in the dataset.
    """
    try:
        # If CSV file is provided, use it; otherwise use default
        if csv_file is not None:
            # Read the uploaded CSV
            if isinstance(csv_file, str):  # Path to default CSV
                df = pd.read_csv(csv_file)
            else:  # Uploaded file
                df = pd.read_csv(csv_file.name)
        else:
            # Use the default medicine_dataset.csv in the current directory
            try:
                df = pd.read_csv("medicine_dataset.csv")
            except FileNotFoundError:
                return "Error: Default medicine_dataset.csv not found. Please upload a CSV file."
        
        # Check if medicine is in the dataset
        medicine_exists = medicine_name in df['name'].values
        
        # Create a helpful context about the dataset to send to the LLM
        dataset_overview = f"The dataset contains {len(df)} medicines with columns for name, substitutes, side effects, uses, chemical class, etc."
        
        # Sample of medicine names to give the model context
        sample_names = df['name'].sample(min(20, len(df))).tolist()
        medicine_sample = f"Sample medicines in the dataset: {', '.join(sample_names)}"
        
        # Extract specific medicine data if available
        medicine_data = None
        medicine_info_str = ""
        if medicine_exists:
            medicine_data = df[df['name'] == medicine_name]
            medicine_info_str = medicine_data.to_string(index=False)
        
        # Create system prompt with dataset context
        system_prompt = f"""You are a pharmaceutical expert system that recommends alternative medicines based on a comprehensive medicine dataset. The user has provided the medicine name "{medicine_name}".
DATASET INFORMATION:
{dataset_overview}
{medicine_sample}
The dataset has the following columns:
- name: Medicine name
- substitute0 through substitute4: Potential substitute medicines
- sideEffect0 through sideEffect41: Possible side effects
- use0 through use4: Medical uses
- Chemical Class: The chemical classification
- Habit Forming: Whether the medicine is habit-forming
- Therapeutic Class: The therapeutic classification
- Action Class: How the medicine works
YOUR TASK:
{"The medicine was found in the dataset with the following information:" if medicine_exists else "The medicine was NOT found in the dataset with an exact match. Your task is to:"}
{medicine_info_str if medicine_exists else "1. Identify what kind of medicine this likely is based on its name (e.g., antibiotics, pain relievers, etc.)"}
{'' if medicine_exists else "2. Look for medicines in the sample list that might be similar or serve similar purposes"}
Please recommend alternative medicines for "{medicine_name}" with the following details for each:
1. Name of the alternative medicine
2. Why it's a good alternative (similar chemical composition, therapeutic use, etc.)
3. Potential side effects to be aware of
4. Usage recommendations
5. Similarity to the original medicine (high, medium, low)
Include at least 3-5 alternatives if possible.
IMPORTANT:
- If the medicine name contains strength or formulation (like "500mg" or "Duo"), focus on finding the base medicine first
- Explain why these alternatives might be suitable replacements
- Include appropriate medical disclaimers
- Format your response clearly with headings for each alternative medicine
"""

        # Initialize Together client with the API key
        client = Together(api_key=api_key)
        
        # Make API call
        response = client.chat.completions.create(
            model="meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
            messages=[
                {
                    "role": "system",
                    "content": system_prompt
                },
                {
                    "role": "user",
                    "content": f"Please recommend alternatives for {medicine_name} based on the available information."
                }
            ],
            max_tokens=2000,
            temperature=0.7  # Slightly higher temperature for creative recommendations
        )
        
        # Get the raw response
        recommendation_text = response.choices[0].message.content
        
        # Add disclaimer
        final_response = recommendation_text + "\n\n---\n\n**DISCLAIMER:** This information is for educational purposes only. Always consult with a healthcare professional before making any changes to your medication."
        
        return final_response
    
    except Exception as e:
        return f"Error: {str(e)}"

def send_medicine_to_recommender(api_key, medicine_names, csv_file):
    """
    Takes medicine names extracted from prescription and gets recommendations
    """
    if not medicine_names or medicine_names.startswith("Error") or medicine_names.startswith("Please"):
        return "Please extract valid medicine names first"
    
    # Extract the first medicine name from the list (assuming it's the first line or first item)
    medicine_lines = medicine_names.strip().split('\n')
    if not medicine_lines:
        return "No valid medicine name found in extraction results"
    
    # Get the first medicine name (remove any bullet points or numbers)
    first_medicine = medicine_lines[0]
    # Clean up the medicine name (remove bullets, numbers, etc.)
    first_medicine = first_medicine.lstrip('•-*0123456789. ').strip()
    
    # Check if we have a valid medicine name
    if not first_medicine:
        return "Could not identify a valid medicine name from extraction"
    
    # Call the recommend medicine function with the first extracted medicine
    return recommend_medicine(api_key, first_medicine, csv_file)

def analyze_full_prescription(api_key, medicine_names, csv_file):
    """
    Takes all extracted medicine names and analyzes their interactions and provides comprehensive information
    """
    if not medicine_names or medicine_names.startswith("Error") or medicine_names.startswith("Please"):
        return "Please extract valid medicine names first"
    
    try:
        # Parse the medicine names from the extracted text
        medicine_lines = medicine_names.strip().split('\n')
        cleaned_medicines = []
        
        # Clean up medicine names (remove bullets, numbers, etc.)
        for medicine in medicine_lines:
            cleaned_medicine = medicine.lstrip('•-*0123456789. ').strip()
            if cleaned_medicine:
                cleaned_medicines.append(cleaned_medicine)
        
        if not cleaned_medicines:
            return "No valid medicine names found in extraction"
        
        # Create a prompt for the LLM to analyze the full prescription
        medicines_list = ", ".join(cleaned_medicines)
        
        system_prompt = f"""You are a pharmaceutical expert analyzing a full prescription containing the following medicines: {medicines_list}.
Please provide a comprehensive analysis including:
1. Purpose: The likely medical condition(s) being treated with this combination of medicines
2. Potential interactions: Any known drug interactions between these medicines
3. Side effects: Common side effects to watch for when taking this combination
4. Recommendations: General advice for the patient taking these medicines
5. Questions for the doctor: Important questions the patient should ask their healthcare provider
Base your analysis on pharmacological knowledge about these medicines and their typical uses.
"""

        # Initialize Together client with the API key
        client = Together(api_key=api_key)
        
        # Make API call
        response = client.chat.completions.create(
            model="meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
            messages=[
                {
                    "role": "system",
                    "content": system_prompt
                },
                {
                    "role": "user",
                    "content": f"Please analyze this prescription with the following medicines: {medicines_list}"
                }
            ],
            max_tokens=2000,
            temperature=0.3  # Lower temperature for more factual responses
        )
        
        analysis_text = response.choices[0].message.content
        
        # Add disclaimer
        final_response = analysis_text + "\n\n---\n\n**DISCLAIMER:** This analysis is for informational purposes only and should not replace professional medical advice. Always consult with your healthcare provider about your prescription."
        
        return final_response
        
    except Exception as e:
        return f"Error: {str(e)}"

# Create Gradio interface with tabs for all functionalities
with gr.Blocks(title="Medicine Assistant") as app:
    gr.Markdown("# Medicine Assistant")
    gr.Markdown("This application helps you extract medicine names from prescriptions, find alternative medicines, and analyze full prescriptions.")
    
    # API key input (shared between tabs)
    api_key_input = gr.Textbox(
        label="Together API Key", 
        placeholder="Enter your Together API key here...",
        type="password"
    )
    
    # Create a file input for CSV that can be shared between tabs
    csv_file_input = gr.File(
        label="Upload Medicine CSV (Optional)", 
        file_types=[".csv"],
        type="filepath"  
    )
    gr.Markdown("If no CSV is uploaded, the app will use the default 'medicine_dataset.csv' file.")
    
    with gr.Tabs():
        with gr.Tab("Prescription Medicine Extractor"):
            gr.Markdown("## Prescription Medicine Extractor")
            gr.Markdown("Upload a prescription image to extract medicine names using Together AI's Llama-Vision-Free model.")
            
            with gr.Row():
                with gr.Column():
                    image_input = gr.Image(type="filepath", label="Upload Prescription Image")
                    extract_btn = gr.Button("Extract Medicines")
                    
                with gr.Column():
                    extracted_output = gr.Textbox(label="Extracted Medicines", lines=10)
            
            with gr.Row():
                with gr.Column(scale=1):
                    recommend_from_extract_btn = gr.Button("Get Recommendations for First Medicine", variant="primary")
                    analyze_full_btn = gr.Button("Analyze Full Prescription", variant="secondary")
                
                with gr.Column(scale=2):
                    output_tabs = gr.Tabs()
                    with output_tabs:
                        with gr.Tab("Recommendations"):
                            recommendation_from_extract_output = gr.Markdown()
                        with gr.Tab("Full Analysis"):
                            full_analysis_output = gr.Markdown()
            
            # Connect the buttons to functions
            extract_btn.click(
                fn=extract_medicines, 
                inputs=[api_key_input, image_input], 
                outputs=extracted_output
            )
            
            recommend_from_extract_btn.click(
                fn=send_medicine_to_recommender,
                inputs=[api_key_input, extracted_output, csv_file_input],
                outputs=recommendation_from_extract_output
            )
            
            analyze_full_btn.click(
                fn=analyze_full_prescription,
                inputs=[api_key_input, extracted_output, csv_file_input],
                outputs=full_analysis_output
            )
            
            gr.Markdown("""
            ### How to use:
            1. Enter your Together API key
            2. Upload a clear image of a prescription
            3. Click 'Extract Medicines' to see the identified medicines
            4. Optionally upload a custom medicine dataset CSV
            5. Choose to:
               - Get alternatives for the first medicine
               - Analyze the entire prescription for interactions and information
            
            ### Note:
            - Your API key is used only for the current session
            - For best results, ensure the prescription image is clear and readable
            """)
        
        with gr.Tab("Medicine Alternative Recommender"):
            gr.Markdown("## Medicine Alternative Recommender")
            gr.Markdown("This tool recommends alternative medicines based on an input medicine name using the Together API.")
            
            with gr.Row():
                with gr.Column():
                    medicine_name = gr.Textbox(
                        label="Medicine Name", 
                        placeholder="Enter a medicine name (e.g., Augmentin 625 Duo)"
                    )
                    submit_btn = gr.Button("Get Recommendations", variant="primary")
                
                with gr.Column():
                    recommendation_output = gr.Markdown()
            
            submit_btn.click(
                recommend_medicine,
                inputs=[api_key_input, medicine_name, csv_file_input],
                outputs=recommendation_output
            )

            gr.Markdown("""
            ## How to use this tool:
            1. Enter your Together API key (same key used across the application)
            2. Enter a medicine name - the AI will find it or match similar alternatives
            3. Click "Get Recommendations" to see alternatives
            
            ### Features:
            - Even if the exact medicine isn't in the database, the AI will try to find similar alternatives
            - The system analyzes the medicine name to determine its likely purpose and composition
            - Recommendations include substitutes, side effects, and usage information
            """)
    
    gr.Markdown("""
    ## About This Application
    
    This Medicine Assistant application combines powerful tools powered by Large Language Models:
    
    1. **Prescription Medicine Extractor**: Uses computer vision AI to identify medicine names from prescription images
    2. **Medicine Alternative Recommender**: Provides detailed information about alternative medications
    3. **Prescription Analyzer**: Analyzes entire prescriptions for potential interactions and insights
    
    All tools utilize the Together AI platform for advanced AI capabilities. Your API key is not stored and is only used to make API calls during your active session.
    
    ### Important Note
    
    This application is for informational purposes only. Always consult with a healthcare professional before making any changes to your medication regimen.
    """)

# Launch the app
if __name__ == "__main__":
    app.launch()