Initial commit: Hosptal Assistant

.gitignore

@@ -0,0 +1,4 @@
+.env
+__pycache__/
+*.pyc
+.cache/

README.md

@@ -1,14 +1,84 @@
----
-title: HospitalAssitant
-emoji: 🐨
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.1.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: Hospital Query Assistant using AutoGen and GroqCloud API
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Hospital Query Assistant
+
+This project implements a Hospital Query Assistant using AutoGen and GroqCloud API, with a Gradio-based user interface. The assistant helps users with queries about hospital services, appointments, and general medical information.
+
+## Features
+
+- Natural language processing for hospital-related queries
+- Content moderation to ensure safe and appropriate responses
+- Token usage tracking
+- User-friendly chat interface
+
+## Implementation Details
+
+### Backend (`hospital_query_app.py`)
+
+The backend is implemented using AutoGen and the GroqCloud API. Key components include:
+
+1. **AutoGen Agents**:
+   - User Proxy Agent: Represents the user in the conversation.
+   - Hospital Assistant Agent: Provides responses to user queries.
+
+2. **Content Moderation**:
+   - Uses the Mixtral-8x7b-32768 model to check for inappropriate content.
+   - Ensures queries are safe and relevant before processing.
+
+3. **Query Handling**:
+   - Sanitizes user input to remove potential security risks.
+   - Processes queries using the Hospital Assistant Agent.
+   - Tracks token usage for each query.
+
+### Frontend (`hospital_query_ui.py`)
+
+The frontend is built using Gradio, providing a web-based user interface. Features include:
+
+1. **Chat Interface**:
+   - Displays conversation history.
+   - Allows users to input queries easily.
+
+2. **Token Usage Display**:
+   - Shows tokens used in the last query.
+   - Displays total tokens used in the session.
+
+3. **Clear Functionality**:
+   - Allows users to reset the conversation and token counters.
+
+## Setup and Installation
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/vpingale077/hospital-query-assistant.git
+   ```
+
+2. Install required dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+
+3. Set up environment variables:
+   - Create a `.env` file in the project root.
+   - Add your GroqCloud API key:
+     ```
+     GROQ_API_KEY=your_api_key_here
+     ```
+
+4. Run the application:
+   ```
+   python hospital_query_ui.py
+   ```
+
+## Usage
+
+1. Launch the application using the command above.
+2. Open the provided URL in your web browser.
+3. Type your hospital-related query in the input box and press Enter.
+4. View the assistant's response in the chat interface.
+5. Check token usage information on the right side of the interface.
+
+## Note
+
+This assistant is designed for general information purposes only and should not be used for personal medical advice or diagnoses.
+
+## License
+
+[MIT License](LICENSE)

app.py

@@ -0,0 +1,66 @@
+import gradio as gr
+import os
+from dotenv import load_dotenv
+from hospital_query_app import handle_hospital_query, set_groq_api_key
+import logging
+
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Initialize token counter
+total_tokens_used = 0
+tokens_used = 0
+
+def process_query(message, history, api_key):
+    global total_tokens_used, tokens_used
+    
+    if not api_key:
+        return history + [("System", "Please enter your GROQ API key in the input field below.")]
+    
+    set_groq_api_key(api_key)
+    result = handle_hospital_query(message)
+    response = result['response']
+    tokens_used = result['tokens_used']
+    
+    total_tokens_used += tokens_used
+    
+    history.append((message, response))
+    return history
+
+def update_token_info():
+    return f"Tokens used in last query: {tokens_used}", f"Total tokens used: {total_tokens_used}"
+
+# Custom CSS for smaller font and larger chatbot
+custom_css = """
+.chatbot-container {
+    font-size: 0.5em;
+}
+"""
+
+with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as demo:
+    gr.Markdown("# Hospital Query Assistant")
+    gr.Markdown("Ask questions about hospital services, appointments, and general medical information.")
+    
+    with gr.Row():
+        with gr.Column(scale=4):
+            chatbot = gr.Chatbot(height=500, elem_classes="chatbot-container")
+            msg = gr.Textbox(placeholder="Type your message here...", label="User Input")
+            clear = gr.Button("Clear")
+        
+        with gr.Column(scale=1):
+            token_last = gr.Markdown("Tokens used in last query: 0")
+            token_total = gr.Markdown("Total tokens used: 0")
+            api_key = gr.Textbox(placeholder="Enter your GROQ API key here", label="GROQ API Key", type="password")
+    
+    msg.submit(process_query, [msg, chatbot, api_key], chatbot)
+    msg.submit(update_token_info, None, [token_last, token_total])
+    msg.submit(lambda: "", None, msg)
+    clear.click(lambda: None, None, chatbot)
+    clear.click(lambda: ("Tokens used in last query: 0", "Total tokens used: 0"), None, [token_last, token_total])
+    clear.click(lambda: 0, None, msg)
+
+if __name__ == "__main__":
+    demo.launch()

hospital_query_app.py

@@ -0,0 +1,162 @@
+import os
+import autogen
+from groq import Groq
+from dotenv import load_dotenv
+from typing import Dict, Any
+import logging
+import re
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Load environment variables
+load_dotenv()
+
+# Initialize GroqCloud client and agents
+groq_client = None
+GROQ_API_KEY = None
+user_proxy = None
+hospital_assistant = None
+
+def set_groq_api_key(api_key: str):
+    global groq_client, GROQ_API_KEY, user_proxy, hospital_assistant
+    GROQ_API_KEY = api_key
+    groq_client = Groq(api_key=GROQ_API_KEY)
+    os.environ["OPENAI_API_KEY"] = GROQ_API_KEY  # Set the environment variable for OpenAI compatibility
+
+    # Configuration for AutoGen agents
+    config_list = [
+        {
+            "model": "mixtral-8x7b-32768",
+            "api_key": GROQ_API_KEY,
+        }
+    ]
+
+    llm_config = {
+        "config_list": config_list,
+        "cache_seed": 42,
+        "temperature": 0.5,
+        "base_url": "https://api.groq.com/openai/v1",
+    }
+
+    # Disable Docker for code execution
+    code_execution_config = {"use_docker": False}
+
+    # Create User Proxy Agent
+    user_proxy = autogen.UserProxyAgent(
+        name="User_Proxy",
+        system_message="A human user interacting with the hospital query system.",
+        human_input_mode="NEVER",
+        code_execution_config=code_execution_config,
+    )
+
+    # Create Hospital Query Assistant
+    hospital_assistant = autogen.AssistantAgent(
+        name="Hospital_Assistant",
+        system_message="You are a hospital assistant AI. You help users with their queries about hospital services, appointments, and general medical information. Provide concise and helpful responses. Do not provide any personal medical advice or diagnoses.",
+        llm_config=llm_config,
+    )
+
+    logging.info("AutoGen agents created successfully with the provided API key.")
+
+# Define LLAMA_GUARD_PROMPT
+LLAMA_GUARD_PROMPT = """
+You are an AI content moderation system. Your task is to analyze the given text and determine if it contains any inappropriate content, such as profanity, hate speech, or sensitive medical information. Respond with either "SAFE" or "UNSAFE", followed by a brief explanation.
+
+Text to moderate: {text}
+
+Response:
+"""
+
+def sanitize_input(text: str) -> str:
+    # Remove any potential HTML or script tags
+    text = re.sub(r'<[^>]*?>', '', text)
+    # Remove any non-alphanumeric characters except common punctuation
+    text = re.sub(r'[^a-zA-Z0-9\s.,!?-]', '', text)
+    return text.strip()
+
+def moderate_content(text: str) -> Dict[str, Any]:
+    try:
+        response = groq_client.chat.completions.create(
+            model="mixtral-8x7b-32768",  # Using Mixtral as Llama Guard is not available on Groq
+            messages=[
+                {"role": "system", "content": "You are a content moderation system."},
+                {"role": "user", "content": LLAMA_GUARD_PROMPT.format(text=text)},
+            ],
+            max_tokens=100,
+        )
+        moderation_result = response.choices[0].message.content.strip()
+        is_safe = moderation_result.lower().startswith("safe")
+        logging.info(f"Moderation result: {moderation_result}")
+        return {
+            "is_safe": is_safe, 
+            "explanation": moderation_result,
+            "tokens_used": response.usage.total_tokens
+        }
+    except Exception as e:
+        logging.error(f"Error in content moderation: {str(e)}")
+        return {"is_safe": False, "explanation": "Error in content moderation", "tokens_used": 0}
+
+def handle_hospital_query(user_input: str) -> Dict[str, Any]:
+    global groq_client, GROQ_API_KEY, user_proxy, hospital_assistant
+    if not groq_client or not GROQ_API_KEY or not user_proxy or not hospital_assistant:
+        return {
+            "response": "Please enter your GROQ API key in the input field above.",
+            "tokens_used": 0
+        }
+    
+    try:
+        sanitized_input = sanitize_input(user_input)
+        
+        moderation_result = moderate_content(sanitized_input)
+        if not moderation_result["is_safe"]:
+            return {
+                "response": f"I apologize, but I cannot process this query. {moderation_result['explanation']}",
+                "tokens_used": moderation_result["tokens_used"]
+            }
+
+        response = hospital_assistant.generate_reply(
+            messages=[{"role": "user", "content": sanitized_input}],
+            sender=user_proxy,
+        )
+        
+        # Assuming the response is a string, we need to get token usage from the Groq client
+        assistant_response = groq_client.chat.completions.create(
+            model="mixtral-8x7b-32768",
+            messages=[{"role": "user", "content": sanitized_input}],
+            max_tokens=500,
+        )
+        
+        return {
+            "response": response,
+            "tokens_used": moderation_result["tokens_used"] + assistant_response.usage.total_tokens
+        }
+    except Exception as e:
+        logging.error(f"Error in handling hospital query: {str(e)}")
+        return {
+            "response": f"I apologize, but I encountered an error while processing your query: {str(e)}. Please try again later.",
+            "tokens_used": 0
+        }
+
+# Main application loop (if running directly)
+if __name__ == "__main__":
+    print("Welcome to the Hospital Query System. Type 'exit' to quit.")
+    api_key = input("Please enter your GROQ API key: ")
+    set_groq_api_key(api_key)
+    total_tokens = 0
+    while True:
+        try:
+            user_input = input("User: ")
+            if user_input.lower() == "exit":
+                break
+            result = handle_hospital_query(user_input)
+            print(f"Assistant: {result['response']}")
+            print(f"Tokens used: {result['tokens_used']}")
+            total_tokens += result['tokens_used']
+            print(f"Total tokens used: {total_tokens}")
+        except KeyboardInterrupt:
+            print("\nExiting the application...")
+            break
+        except Exception as e:
+            logging.error(f"Unexpected error: {str(e)}")
+            print("An unexpected error occurred. Please try again.")