Upload 3 files

Dockerfile

@@ -0,0 +1,23 @@
+
+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 app.py ./
+COPY src/ ./src/
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,255 @@
+
+import streamlit as st
+import pandas as pd
+import json
+import os
+from openai import OpenAI
+
+# Load OpenAI API key and base URL from Colab secrets
+try:
+    OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+    OPENAI_API_BASE = os.environ.get("OPENAI_API_BASE")
+    openai_client = OpenAI(api_key=OPENAI_API_KEY, base_url=OPENAI_API_BASE)
+except Exception as e:
+    st.error(f"Error loading OpenAI credentials: {e}")
+    st.stop()
+
+
+# Define the functions for categorization, metadata extraction, priority prediction, and response generation
+def query_openai(prompt, query):
+    """
+    Queries the OpenAI model with a given prompt and query.
+    Args:
+        prompt (str): The prompt for the model.
+        query (str): The query to be answered by the model.
+    Returns:
+        str: The model's response.
+    """
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": query}
+    ]
+    response = openai_client.chat.completions.create(
+        model="gpt-3.5-turbo",  # Or another suitable OpenAI model
+        messages=messages,
+        max_tokens=100  # Adjust max_tokens as needed
+    )
+    return response.choices[0].message.content
+
+def classify_ticket(prompt, query):
+    """
+    Classifies a support ticket using the OpenAI model and returns the result in JSON format.
+    Args:
+        prompt (str): The classification prompt for the model.
+        query (str): The support ticket text to be classified.
+    Returns:
+        dict: A dictionary containing the classification result, or None if classification fails.
+    """
+    try:
+        response_text = query_openai(prompt, query)
+        # Attempt to parse the response text as JSON
+        classification_result = json.loads(response_text)
+        return classification_result
+    except json.JSONDecodeError as e:
+        st.error(f"Error decoding JSON from OpenAI response: {e}")
+        st.text(f"Raw OpenAI response: {response_text}")
+        return None
+    except Exception as e:
+        st.error(f"An unexpected error occurred during classification: {e}")
+        return None
+
+def extract_metadata(prompt, query):
+    """
+    Extracts metadata from a support ticket using the OpenAI model and returns the result in JSON format.
+    Args:
+        prompt (str): The metadata extraction prompt for the model.
+        query (str): The support ticket text to extract metadata from.
+    Returns:
+        dict: A dictionary containing the extracted metadata, or None if extraction fails.
+    """
+    try:
+        response_text = query_openai(prompt, query)
+        # Attempt to parse the response text as JSON
+        metadata_result = json.loads(response_text)
+        return metadata_result
+    except json.JSONDecodeError as e:
+        st.error(f"Error decoding JSON from OpenAI response: {e}")
+        st.text(f"Raw OpenAI response: {response_text}")
+        return None
+    except Exception as e:
+        st.error(f"An unexpected error occurred during metadata extraction: {e}")
+        return None
+
+def predict_priority(prompt, query, problem_type, user_impact):
+    """
+    Predicts the priority of a support ticket using the OpenAI model and returns the result in JSON format.
+    Args:
+        prompt (str): The priority prediction prompt for the model.
+        query (str): The support ticket text to predict the priority for.
+        problem_type (str): The extracted problem type.
+        user_impact (str): The extracted user impact.
+    Returns:
+        dict: A dictionary containing the predicted priority, or None if prediction fails.
+    """
+    try:
+        # Include problem_type and user_impact in the query sent to the model
+        full_query = f"""
+        Support Ticket: {query}
+        Problem Type: {problem_type}
+        User Impact: {user_impact}
+        Based on the support ticket, problem type, and user impact, predict the priority: Low, Medium, High, or Urgent.
+        Return only a structured JSON output in the following format:
+        {{"priority": "priority_prediction"}}
+        """
+        response_text = query_openai(prompt, full_query)
+        priority_result = json.loads(response_text)
+        return priority_result
+    except json.JSONDecodeError as e:
+        st.error(f"Error decoding JSON from OpenAI response: {e}")
+        st.text(f"Raw OpenAI response: {response_text}")
+        return None
+    except Exception as e:
+        st.error(f"An unexpected error occurred during priority prediction: {e}")
+        return None
+
+def generate_response(response_prompt, query, category, metadata_tags, priority):
+    """
+    Generates a draft response for a support ticket using the OpenAI model.
+    Args:
+        response_prompt (str): The prompt for generating the response.
+        query (str): The original support ticket text.
+        category (str): The predicted category of the ticket.
+        metadata_tags (dict): The extracted metadata tags (Device, Problem Type, User Impact).
+        priority (str): The predicted priority of the ticket.
+    Returns:
+        str: The generated response text, or None if response generation fails.
+    """
+    # Combine the inputs into a single message for the model
+    user_message = f"""
+    Support Ticket: {query}
+    Category: {category}
+    Metadata Tags: {metadata_tags}
+    Priority: {priority}
+    """
+
+    try:
+        # Pass the combined message to the query_openai function
+        response_text = query_openai(response_prompt, user_message)
+        return response_text
+    except Exception as e:
+        st.error(f"An unexpected error occurred during response generation: {e}")
+        return None
+
+# Define the prompts
+classification_prompt = """
+ You are a technical assistant. Classify the support ticket based on the Support Ticket Text presented in the input into the following categories and not any other.
+      - Technical issues
+      - Hardware issues
+      - Data recovery
+  Return only a structured JSON output in the following format:
+  {"Category": "category_prediction"}
+"""
+
+metadata_prompt = f"""
+You are an intelligent assistant that extracts structured metadata from technical support queries.
+Analyze the query and extract the following information:
+
+* Device (e.g., Laptop, Phone, Router, etc.)
+* Problem Type (e.g., Not Turning On, Lost Internet, Deleted Files)
+* User Impact - Estimate based on how severely the issue affects the user's ability to continue working or using the device:
+
+    - * Major: The user cannot proceed with work at all.
+    - * Moderate: The user is impacted but may have a workaround.
+    - * Minor: The issue is present but does not significantly hinder usage.
+
+Use the following examples as guidance.
+
+Query Text: My phone battery is draining rapidly even on battery saver mode. I barely use it and it drops 50% in a few hours.
+Output: {{"Device": "Phone", "Problem Type": "Battery Draining", "User Impact": "Minor"}}
+
+Query Text: I accidentally deleted a folder containing all project files. Please help me recover it.
+Output: {{"Device": "Laptop", "Problem Type": "Deleted Files", "User Impact": "Major"}}
+
+Query Text: My router is not working.
+Output: {{"Device": "Router", "Problem Type": "Lost Internet", "User Impact": "Moderate"}}
+
+Return the final output only in a valid JSON format without any additional explanation.
+"""
+
+priority_prompt ="""
+You are an intelligent assistant that determines the priority level of a support ticket.
+For any given ticket, follow this step-by-step reasoning process to assign the correct priority level: Low, Medium, High.
+Step-by-step Evaluation:
+Is the device or service completely unusable?
+Is the issue blocking critical or time-sensitive work?
+Is there a specific deadline or urgency mentioned by the user?
+Does the user mention partial functionality or ongoing work?
+Is the tone or language expressing frustration or emergency?
+After evaluating each step, decide the most appropriate priority level based on the impact and urgency.
+Finally, return only the structured output in valid JSON format, like this:
+{"priority": "High"}
+Do not include your reasoning in the output — just the JSON.
+"""
+
+response_prompt = """
+You are provided with a support ticket's text along with its Category, Tags, and assigned Priority level.
+
+Follow these steps before generating your final response:
+
+1. Analyze the ticket text to understand the customer's sentiment and main concern.
+2. Identify the issue type using the provided Category and Tags.
+3. Determine the appropriate ETA based on the Priority level.
+4. Compose a short, empathetic response that reassures the customer, acknowledges their concern, and includes the ETA.
+
+Ensure the final response:
+
+1. Is under 50 words
+2. Has a polite and empathetic tone
+3. Addresses the issue clearly
+
+Return only the final response to the customer. Do not include your reasoning steps in the output.
+"""
+
+
+# Streamlit App
+st.title("Support Ticket Categorization System")
+
+st.write("Enter the support ticket text below:")
+
+support_ticket_input = st.text_area("Support Ticket Text", height=200)
+
+if st.button("Process Ticket"):
+    if support_ticket_input:
+        st.write("Processing...")
+
+        # Categorization
+        category_result = classify_ticket(classification_prompt, support_ticket_input)
+        category = category_result.get('Category') if category_result else "N/A"
+        st.subheader("Category:")
+        st.write(category)
+
+        # Metadata Extraction
+        metadata_result = extract_metadata(metadata_prompt, support_ticket_input)
+        device = metadata_result.get('Device') if metadata_result else "N/A"
+        problem_type = metadata_result.get('Problem Type') if metadata_result else "N/A"
+        user_impact = metadata_result.get('User Impact') if metadata_result else "N/A"
+
+        st.subheader("Metadata:")
+        st.write(f"Device: {device}")
+        st.write(f"Problem Type: {problem_type}")
+        st.write(f"User Impact: {user_impact}")
+
+        # Priority Prediction
+        priority_result = predict_priority(priority_prompt, support_ticket_input, problem_type, user_impact)
+        priority = priority_result.get('priority') if priority_result else "N/A"
+        st.subheader("Priority:")
+        st.write(priority)
+
+        # Draft Response Generation
+        draft_response = generate_response(response_prompt, support_ticket_input, category, metadata_result, priority)
+        st.subheader("Draft Response:")
+        st.write(draft_response)
+
+
+    else:
+        st.warning("Please enter support ticket text to process.")

requirements.txt

@@ -0,0 +1,4 @@
+altair==5.5.0
+pandas==2.2.2
+streamlit==1.47.1
+openai==1.97.1