Upload 3 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data.csv filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,342 @@
+# -*- coding: utf-8 -*-
+"""
+IT Support Chatbot (Hugging Face Spaces)
+- Matches Colab pipeline with Hybrid Retrieval (Dense + BM25) and Reranking
+- Uses Qdrant as vector store (build or serve depending on BUILD_MODE)
+- Embeddings kept consistent across build & query via EMBED_MODEL_ID
+- GPU/CPU-safe LLaMA loading (4-bit on GPU, smaller instruct model on CPU)
+- Minimal Gradio UI (Chat + Clear), optional context viewer
+
+Environment variables (Spaces → Settings → Variables):
+  QDRANT_HOST, QDRANT_API_KEY, HF_TOKEN
+  EMBED_MODEL_ID          (default: BAAI/bge-large-en-v1.5)
+  QDRANT_COLLECTION       (default: it_support_rag)
+  MODEL_ID                (default: meta-llama/Llama-3.1-8B-Instruct)
+  CPU_MODEL_ID            (default: meta-llama/Llama-3.2-3B-Instruct)
+  BUILD_MODE              ("true" to build/rebuild from data.csv; default: "false")
+  OMP_NUM_THREADS         (default: "1")
+  SHOW_CONTEXT            ("true" to show retrieved context; default: "true")
+"""
+
+# --- Imports & setup ---
+import os
+import random
+import logging
+import numpy as np
+import torch
+import nest_asyncio
+import pandas as pd
+import gradio as gr
+from typing import List
+
+from huggingface_hub import login
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, BitsAndBytesConfig
+
+from llama_index.core import (
+    VectorStoreIndex, StorageContext, Settings, QueryBundle, Document
+)
+from llama_index.core.node_parser import SentenceSplitter
+from llama_index.core.retrievers import BaseRetriever
+from llama_index.core.postprocessor import SentenceTransformerRerank
+from llama_index.core.query_engine import RetrieverQueryEngine
+
+from llama_index.vector_stores.qdrant import QdrantVectorStore
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+from llama_index.retrievers.bm25 import BM25Retriever
+
+import qdrant_client
+
+# --- Logging ---
+logging.basicConfig(format="%(asctime)s %(levelname)s: %(message)s", level=logging.INFO)
+logger = logging.getLogger("it_support_app")
+
+# --- Reproducibility & asyncio ---
+SEED = 42
+random.seed(SEED); np.random.seed(SEED); torch.manual_seed(SEED)
+nest_asyncio.apply()
+
+# --- Env vars & sane defaults ---
+os.environ.setdefault("OMP_NUM_THREADS", os.getenv("OMP_NUM_THREADS", "1"))
+
+QDRANT_HOST       = os.getenv("QDRANT_HOST")
+QDRANT_API_KEY    = os.getenv("QDRANT_API_KEY")
+HF_TOKEN          = os.getenv("HF_TOKEN")
+
+EMBED_MODEL_ID    = os.getenv("EMBED_MODEL_ID", "BAAI/bge-large-en-v1.5")
+COLLECTION_NAME   = os.getenv("QDRANT_COLLECTION", "it_support_rag")
+BUILD_MODE        = os.getenv("BUILD_MODE", "false").lower() == "true"
+SHOW_CONTEXT      = os.getenv("SHOW_CONTEXT", "true").lower() == "true"
+
+GPU_MODEL_ID      = os.getenv("MODEL_ID",     "meta-llama/Llama-3.1-8B-Instruct")
+CPU_MODEL_ID      = os.getenv("CPU_MODEL_ID", "meta-llama/Llama-3.2-3B-Instruct")
+
+if not all([QDRANT_HOST, QDRANT_API_KEY, HF_TOKEN]):
+    raise EnvironmentError("Set QDRANT_HOST, QDRANT_API_KEY, and HF_TOKEN in Space variables.")
+
+# --- Auth & clients ---
+login(token=HF_TOKEN)
+qdrant = qdrant_client.QdrantClient(url=QDRANT_HOST, api_key=QDRANT_API_KEY, prefer_grpc=False)
+
+# --- Embeddings (keep consistent across build & serve) ---
+Settings.embed_model = HuggingFaceEmbedding(model_name=EMBED_MODEL_ID)
+logger.info(f"✅ Embedding model set: {EMBED_MODEL_ID}")
+
+# --- Node parser (token-ish chunks) ---
+node_parser = SentenceSplitter(chunk_size=1024, chunk_overlap=100, paragraph_separator="\n\n")
+
+# --- Optional: load CSV for BM25 and/or BUILD_MODE ---
+CSV_PATH = "data.csv"
+case_docs: List[Document] = []
+bm25_retriever = None
+
+if os.path.exists(CSV_PATH):
+    try:
+        df = pd.read_csv(CSV_PATH, encoding="ISO-8859-1")
+        for _, row in df.iterrows():
+            text = str(row.get("text_chunk", ""))
+            meta = {
+                "source_dataset": str(row.get("source_dataset", ""))[:50],
+                "category":       str(row.get("category", ""))[:100],
+                "orig_query":     str(row.get("original_query", ""))[:200],
+                "orig_solution":  str(row.get("original_solution", ""))[:200],
+            }
+            case_docs.append(Document(text=text, metadata=meta))
+        logger.info(f"Loaded {len(case_docs)} documents from {CSV_PATH}.")
+
+        # BM25 (optional; uses local docs only)
+        bm25_nodes = node_parser.get_nodes_from_documents(case_docs)
+        bm25_retriever = BM25Retriever.from_defaults(nodes=bm25_nodes, similarity_top_k=10)
+        logger.info("✅ BM25 retriever initialized.")
+    except Exception as e:
+        logger.warning(f"BM25 setup skipped due to error: {e}")
+else:
+    logger.warning("data.csv not found — proceeding WITHOUT BM25 (dense-only).")
+
+# --- Qdrant vector store & index ---
+vector_store = QdrantVectorStore(client=qdrant, collection_name=COLLECTION_NAME, prefer_grpc=False)
+storage_context = StorageContext.from_defaults(vector_store=vector_store)
+
+if BUILD_MODE:
+    if not case_docs:
+        raise FileNotFoundError(
+            "BUILD_MODE=true but data.csv is missing or empty. "
+            "Commit data.csv to the Space repo or disable BUILD_MODE."
+        )
+    logger.info(f"BUILD_MODE=true → indexing {len(case_docs)} docs into Qdrant collection '{COLLECTION_NAME}'")
+    index = VectorStoreIndex.from_documents(
+        documents=case_docs,
+        storage_context=storage_context,
+        embed_model=Settings.embed_model,
+        node_parser=node_parser,
+    )
+else:
+    index = VectorStoreIndex.from_vector_store(vector_store=vector_store)
+    logger.info(f"✅ Loaded existing index from Qdrant collection '{COLLECTION_NAME}'")
+
+# --- Dense retriever + hybrid wrapper ---
+dense_retriever = index.as_retriever(similarity_top_k=10)
+
+class HybridRetriever(BaseRetriever):
+    def __init__(self, dense, bm25=None, top_k=10):
+        super().__init__()
+        self.dense = dense
+        self.bm25 = bm25
+        self.top_k = top_k
+
+    def _retrieve(self, query_bundle: QueryBundle):
+        dense_hits = []
+        try:
+            dense_hits = self.dense.retrieve(query_bundle)
+        except Exception as e:
+            logger.error(f"Dense retrieval error: {e}")
+
+        bm25_hits = []
+        if self.bm25:
+            try:
+                bm25_hits = self.bm25.retrieve(query_bundle)
+            except Exception as e:
+                logger.warning(f"BM25 retrieval error: {e}")
+
+        # Merge & de-duplicate by node_id
+        combined = dense_hits + bm25_hits
+        unique, seen = [], set()
+        for hit in combined:
+            nid = hit.node.node_id
+            if nid not in seen:
+                seen.add(nid); unique.append(hit)
+        return unique[: self.top_k]
+
+hybrid_retriever = HybridRetriever(dense=dense_retriever, bm25=bm25_retriever, top_k=10)
+
+# --- Reranker ---
+reranker = SentenceTransformerRerank(
+    model="cross-encoder/ms-marco-MiniLM-L-2-v2",
+    top_n=4,
+    device=("cuda" if torch.cuda.is_available() else "cpu")
+)
+
+# --- Query Engine (use the hybrid retriever) ---
+query_engine = RetrieverQueryEngine(retriever=hybrid_retriever, node_postprocessors=[reranker])
+
+# --- LLM loading (GPU: 4-bit 8B; CPU: smaller instruct model) ---
+use_cuda = torch.cuda.is_available()
+if use_cuda:
+    quant_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_compute_dtype=torch.bfloat16,
+    )
+    tokenizer = AutoTokenizer.from_pretrained(GPU_MODEL_ID, use_fast=True)
+    llm = AutoModelForCausalLM.from_pretrained(GPU_MODEL_ID, quantization_config=quant_config, device_map="auto")
+    generator = pipeline("text-generation", model=llm, tokenizer=tokenizer)
+    logger.info(f"✅ Loaded GPU model in 4-bit: {GPU_MODEL_ID}")
+else:
+    tokenizer = AutoTokenizer.from_pretrained(CPU_MODEL_ID, use_fast=True)
+    llm = AutoModelForCausalLM.from_pretrained(CPU_MODEL_ID)
+    generator = pipeline("text-generation", model=llm, tokenizer=tokenizer, device=-1)
+    logger.info(f"✅ Loaded CPU model: {CPU_MODEL_ID}")
+
+# --- Prompt scaffolding ---
+SYSTEM_PROMPT = (
+    "You are a friendly and helpful Level 0 IT Support Assistant. "
+    "Use a conversational tone and guide users step-by-step. "
+    "If the user's question lacks details or clarity, ask a concise follow-up question "
+    "to gather the information you need before providing a solution. "
+    "Once clarified, then:\n"
+    "1) Diagnose the problem.\n"
+    "2) Provide step-by-step solutions with bullet points.\n"
+    "3) Offer additional recommendations or safety warnings.\n"
+    "4) End with a polite closing.\n"
+    "5) If it is out of level 0 IT support, direct users to contact IT support."
+)
+
+HDR = {
+    "sys": "<|start_header_id|>system<|end_header_id|>",
+    "usr": "<|start_header_id|>user<|end_header_id|>",
+    "ast": "<|start_header_id|>assistant<|end_header_id|>",
+    "eot": "<|eot_id|>",
+}
+
+chat_history = []
+GREETINGS = {"hello", "hi", "hey", "good morning", "good afternoon", "good evening"}
+
+def format_history(history):
+    return "".join(
+        f"{HDR['usr']}\n{u}{HDR['eot']}{HDR['ast']}\n{a}{HDR['eot']}"
+        for u, a in history
+    )
+
+def _nodes_to_text(nodes):
+    parts = []
+    for i, n in enumerate(nodes or []):
+        score = getattr(n, "score", 0.0)
+        text  = n.node.get_content() if hasattr(n, "node") else n.get_content()
+        parts.append(f"**Source {i+1} (Score: {score:.4f})**\n{text}")
+    return "\n\n---\n\n".join(parts) if parts else ""
+
+def build_prompt(query, context_nodes, history):
+    q = query.strip()
+    if q.lower() in GREETINGS:
+        return None, "greeting"
+    if len(q.split()) < 3:
+        return (
+            "Could you provide more detail about what you're experiencing? "
+            "Any error messages or steps you've tried will help me assist you."
+        ), "clarify"
+
+    ctx_text = "\n---\n".join(
+        (n.node.get_content() if hasattr(n, "node") else n.get_content())
+        for n in (context_nodes or [])
+    ) or "No context provided."
+    hist_str = format_history(history[-3:])
+    prompt = (
+        "<|begin_of_text|>"
+        f"{HDR['sys']}\n{SYSTEM_PROMPT}{HDR['eot']}"
+        f"{hist_str}"
+        f"{HDR['usr']}\nContext:\n{ctx_text}{HDR['eot']}"
+        f"{HDR['usr']}\nQuestion: {q}{HDR['eot']}"
+        f"{HDR['ast']}\n"
+    )
+    return prompt, "rag"
+
+def chat(query, temperature=0.7, top_p=0.9, max_new_tokens=350):
+    global chat_history
+    # Pre-check (greeting/clarify)
+    prompt, mode = build_prompt(query, [], chat_history)
+    if mode == "greeting":
+        reply = "Hello there! How can I help with your IT support question today?"
+        chat_history.append((query, reply))
+        return reply, []
+    if mode == "clarify":
+        reply = prompt
+        chat_history.append((query, reply))
+        return reply, []
+
+    # Retrieve → Rerank → Build prompt with context → Generate
+    response = query_engine.query(query)
+    context_nodes = response.source_nodes
+    prompt, _ = build_prompt(query, context_nodes, chat_history)
+    gen_args = {
+        "do_sample": True,
+        "max_new_tokens": max_new_tokens,
+        "temperature": temperature,
+        "top_p": top_p,
+        "eos_token_id": tokenizer.eos_token_id,
+    }
+    out = generator(prompt, **gen_args)
+    text = out[0]["generated_text"]
+    answer = text.split(HDR["ast"])[-1].strip()
+    chat_history.append((query, answer))
+    return answer, context_nodes
+
+# --- Gradio UI (minimal; optional context viewer) ---
+with gr.Blocks(theme=gr.themes.Soft(), title="💬 Level 0 IT Support Chatbot") as demo:
+    gr.Markdown("### 🤖 Level 0 IT Support Chatbot (RAG + Qdrant + LLaMA3)")
+
+    with gr.Row():
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(label="Chat", height=500, bubble_full_width=False)
+            inp = gr.Textbox(placeholder="Ask your IT support question...", label="Your Message", lines=2)
+            with gr.Row():
+                send_btn  = gr.Button("Send", variant="primary")
+                clear_btn = gr.Button("Clear", variant="secondary")
+        if SHOW_CONTEXT:
+            with gr.Column(scale=1):
+                with gr.Accordion("Show Retrieved Context", open=False):
+                    context_box = gr.Markdown(value="")
+
+    def respond(message, history):
+        # Fixed defaults; keep UI minimal (like your Colab)
+        reply, context_nodes = chat(message, temperature=0.7, top_p=0.9)
+        history = history or []
+        history.append([message, reply])
+        if SHOW_CONTEXT:
+            return "", history, _nodes_to_text(context_nodes)
+        else:
+            return "", history
+
+    def clear_chat():
+        global chat_history
+        chat_history = []
+        if SHOW_CONTEXT:
+            return [], ""
+        else:
+            return []
+
+    if SHOW_CONTEXT:
+        inp.submit(respond, [inp, chatbot], [inp, chatbot, context_box])
+        send_btn.click(respond, [inp, chatbot], [inp, chatbot, context_box])
+        clear_btn.click(clear_chat, None, [chatbot, context_box], queue=False)
+    else:
+        inp.submit(respond, [inp, chatbot], [inp, chatbot])
+        send_btn.click(respond, [inp, chatbot], [inp, chatbot])
+        clear_btn.click(clear_chat, None, [chatbot], queue=False)
+
+# Keep the UI responsive on Spaces
+demo.queue(concurrency_count=2, max_size=32)
+
+if __name__ == "__main__":
+    logger.info("Launching Gradio interface...")
+    # On Spaces, these are auto-handled; still safe to specify:
+    demo.launch(server_name="0.0.0.0", server_port=7860, debug=True)

data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53c181a92f7d7a203f66e535021210625cc7bf34afb56ccab94d2a5daf537215
+size 21023207

requirements.txt

@@ -0,0 +1,20 @@
+llama-index-core
+llama-index-vector-stores-qdrant
+llama-index-embeddings-huggingface
+llama-index-retrievers-bm25
+llama-index-llms-huggingface
+sentence-transformers
+transformers
+accelerate
+gradio
+qdrant-client
+bitsandbytes
+rouge-score
+bert-score
+evaluate
+nest_asyncio
+torch
+pandas
+numpy
+tf-keras
+python-dotenv