Upload 4 files

Dockerfile

@@ -0,0 +1,30 @@
+# Use a lightweight Python base image
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    bash \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create a non-root user
+RUN useradd -m -u 1000 user
+
+# Copy application files
+COPY app.py .
+COPY chunks.txt .
+
+# Switch to non-root user
+USER user
+
+# Set environment variable for Gemini API key (to be provided via Hugging Face Secrets)
+ENV GEMINI_API_KEY=AIzaSyDteeiTCZIt9J-NntBUrdWLG3WuXGhules
+
+# Run the Streamlit app
+CMD ["streamlit", "run", "app.py", "--server.port", "7860", "--server.address", "0.0.0.0"]

app.py

@@ -0,0 +1,134 @@
+import streamlit as st
+import os
+import requests
+import time
+
+# Config
+CHUNKS_FILE = "chunks.txt"  # Updated to match Dockerfile structure
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "AIzaSyDteeiTCZIt9J-NntBUrdWLG3WuXGhules")
+GEMINI_API_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
+MAX_CONTEXT_LENGTH = 1000
+MAX_RESPONSE_LENGTH = 300
+
+# Load chunks
+def load_chunks(chunks_file):
+    chunks = []
+    try:
+        with open(chunks_file, 'r', encoding='utf-8') as file:
+            current_chunk = ""
+            for line in file:
+                if line.startswith("Chunk"):
+                    if current_chunk:
+                        chunks.append(current_chunk.strip())
+                    current_chunk = ""
+                else:
+                    current_chunk += line
+            if current_chunk:
+                chunks.append(current_chunk.strip())
+        return chunks
+    except Exception as e:
+        st.error(f"⚠️ Error loading chunks: {e}")
+        return []
+
+# Basic keyword search
+def search_messages(query, chunks, top_k=3):
+    query_words = set(query.lower().split())
+    scores = []
+    for chunk in chunks:
+        chunk_words = set(chunk.lower().split())
+        match_count = len(query_words.intersection(chunk_words))
+        score = match_count / max(len(chunk_words), 1)
+        scores.append((score, chunk))
+    scores.sort(reverse=True)
+    return [chunk for _, chunk in scores[:top_k]]
+
+# Call Gemini
+def generate_response(query, chunks):
+    try:
+        context = "\n".join(chunks)[:MAX_CONTEXT_LENGTH]
+        prompt = f"""
+You are a professional customer support assistant. You resolve user issues by analyzing previous customer interactions and providing clear, helpful, and empathetic responses.
+
+Instructions:
+- Use the provided chat history as your internal knowledge base.
+- Do not mention or reference the history directly.
+- Understand recurring issues and recognize patterns from similar past cases.
+- For the given user query:
+  - Greet and acknowledge the concern professionally.
+  - Suggest a solution or steps, based on insights from similar historical interactions.
+  - If the solution is uncertain, offer best practices or next steps.
+  - End with a polite closing and an offer for further help.
+  - don't mention about past history or previous tickets.
+
+Chat History:
+{context}
+
+User Query:
+"{query}"
+
+Your Response:
+        """.strip()
+
+        headers = {
+            "Content-Type": "application/json",
+            "X-goog-api-key": GEMINI_API_KEY
+        }
+
+        data = {
+            "contents": [{"parts": [{"text": prompt}]}],
+            "generationConfig": {"maxOutputTokens": MAX_RESPONSE_LENGTH}
+        }
+
+        response = requests.post(GEMINI_API_URL, headers=headers, json=data)
+        response.raise_for_status()
+        response_data = response.json()
+        return response_data["candidates"][0]["content"]["parts"][0]["text"].strip()
+
+    except Exception as e:
+        return f"⚠️ Error generating response: {e}"
+
+# App UI
+def main():
+    st.set_page_config(page_title=" Support Assistant", layout="centered")
+    st.title("✅ Assistant ✅")
+    st.caption("Submit support questions that are related to previously resolved tickets to ensure efficient and accurate assistance")
+
+    # Load chunks and history
+    if "chunks" not in st.session_state:
+        st.session_state.chunks = load_chunks(CHUNKS_FILE)
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+
+    # Show chat history
+    for message in st.session_state.messages:
+        role, content = message["role"], message["content"]
+        with st.chat_message("user" if role == "user" else "assistant"):
+            st.markdown(content)
+            if role == "assistant":
+                with st.expander("📋 Copy Response"):
+                    st.code(content, language="markdown")
+
+    # User input
+    user_input = st.chat_input("Type your support question here...")
+
+    if user_input:
+        # Display user message
+        with st.chat_message("user"):
+            st.markdown(user_input)
+        st.session_state.messages.append({"role": "user", "content": user_input})
+
+        # Show bot is thinking...
+        with st.chat_message("assistant"):
+            with st.spinner("🧠 Thinking..."):
+                relevant_chunks = search_messages(user_input, st.session_state.chunks)
+                bot_reply = generate_response(user_input, relevant_chunks)
+                time.sleep(0.5)  # simulate delay
+                st.markdown(bot_reply)
+                with st.expander("📋 Copy Response"):
+                    st.code(bot_reply, language="markdown")
+
+        # Save bot reply
+        st.session_state.messages.append({"role": "assistant", "content": bot_reply})
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,2 @@
+streamlit==1.32.0
+requests==2.32.3