Upload 6 files

.dockerignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.git/
+data/huggingface-cache/*

Dockerfile

@@ -0,0 +1,33 @@
+# Use official Python base
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set locales and UTF-8
+ENV LANG=C.UTF-8
+ENV LC_ALL=C.UTF-8
+
+# Set Hugging Face cache
+ENV HF_HOME="/data/huggingface-cache"
+ENV TRANSFORMERS_CACHE="/data/huggingface-cache"
+
+# Install system dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git build-essential && \
+    rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app files
+COPY . .
+
+# Expose port
+EXPOSE 7860
+
+# Start Uvicorn
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

agent_langchain.py

@@ -0,0 +1,214 @@
+import os
+import requests
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import chromadb
+from chromadb.config import Settings
+from chromadb.utils import embedding_functions
+from langchain.agents import initialize_agent, Tool
+from langchain.agents import AgentType
+from langchain.memory import ConversationBufferMemory
+
+# -------------------------------
+# Environment & URLs
+# -------------------------------
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+GEMINI_API_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent"
+ROUTING_URL = os.environ.get("ROUTING_URL")  # Space 2 URL
+SPACE_URL = os.environ.get("SPACE_URL", "http://localhost:7860")
+
+# -------------------------------
+# Label Dictionary
+# -------------------------------
+LABEL_DICTIONARY = {
+    "I1": "Low Impact",
+    "I2": "Medium Impact",
+    "I3": "High Impact",
+    "I4": "Critical Impact",
+    "U1": "Low Urgency",
+    "U2": "Medium Urgency",
+    "U3": "High Urgency",
+    "U4": "Critical Urgency",
+    "T1": "Information",
+    "T2": "Incident",
+    "T3": "Problem",
+    "T4": "Request",
+    "T5": "Question"
+}
+
+# -------------------------------
+# Load Classification Model
+# -------------------------------
+clf_model_name = "DavinciTech/BERT_Categorizer"
+clf_tokenizer = AutoTokenizer.from_pretrained(clf_model_name)
+clf_model = AutoModelForSequenceClassification.from_pretrained(clf_model_name)
+
+# -------------------------------
+# Initialize ChromaDB Client for KB
+# -------------------------------
+chroma_client = chromadb.Client(Settings(
+    chroma_db_impl="duckdb+parquet",
+    persist_directory="/data/chroma_db"
+))
+
+COLLECTION_NAME = "kb_collection"
+try:
+    kb_collection = chroma_client.get_collection(COLLECTION_NAME)
+except:
+    kb_collection = None
+
+# -------------------------------
+# Classification Function
+# -------------------------------
+def classify_ticket(text):
+    inputs = clf_tokenizer(text, return_tensors="pt", truncation=True)
+    outputs = clf_model(**inputs)
+    logits = outputs.logits[0]
+
+    impact_idx = torch.argmax(logits[:4]).item() + 1
+    urgency_idx = torch.argmax(logits[4:8]).item() + 1
+    type_idx = torch.argmax(logits[8:]).item() + 1
+
+    return {
+        "impact": LABEL_DICTIONARY[f"I{impact_idx}"],
+        "urgency": LABEL_DICTIONARY[f"U{urgency_idx}"],
+        "type": LABEL_DICTIONARY[f"T{type_idx}"]
+    }
+
+# -------------------------------
+# Routing Function
+# -------------------------------
+def call_routing(text, retries=3, delay=1):
+    url = ROUTING_URL if ROUTING_URL else f"{SPACE_URL}/route"
+    for attempt in range(retries):
+        try:
+            resp = requests.post(url, json={"text": text}, timeout=5)
+            resp.raise_for_status()
+            data = resp.json()
+            return data.get("department", "General IT")
+        except Exception:
+            if attempt < retries - 1:
+                time.sleep(delay)
+            else:
+                return "General IT"
+
+# -------------------------------
+# KB Query
+# -------------------------------
+def query_kb(text, top_k=1):
+    if not kb_collection:
+        return {"answer": "⚠️ KB not set up. Call /setup first.", "confidence": 0.0}
+
+    results = kb_collection.query(query_texts=[text], n_results=top_k)
+    if not results or len(results['documents'][0]) == 0:
+        return {"answer": "No relevant KB found.", "confidence": 0.0}
+
+    return {
+        "answer": results['documents'][0][0],
+        "confidence": results['distances'][0][0] if results.get('distances') else 0.0,
+        "metadata": results['metadatas'][0][0] if results['metadatas'][0] else {}
+    }
+
+# -------------------------------
+# Gemini LLM Wrapper
+# -------------------------------
+class GeminiLLM:
+    def __init__(self, api_key=GEMINI_API_KEY):
+        self.api_key = api_key
+        self.api_url = GEMINI_API_URL
+
+    def __call__(self, prompt: str):
+        if not self.api_key:
+            return {"text": "⚠️ Gemini API key not set."}
+        payload = {"contents": [{"parts": [{"text": prompt}]}]}
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+        try:
+            resp = requests.post(self.api_url, json=payload, headers=headers)
+            resp.raise_for_status()
+            data = resp.json()
+            text = data.get("candidates", [{}])[0].get("content", {}).get("parts", [{}])[0].get("text", "")
+            return text
+        except:
+            return "⚠️ Gemini API call failed."
+
+# -------------------------------
+# Define LangChain Tools
+# -------------------------------
+tools = [
+    Tool(
+        name="TicketClassifier",
+        func=lambda text: classify_ticket(text),
+        description="Classifies a ticket into impact, urgency, and type. Mandatory tool."
+    ),
+    Tool(
+        name="RoutingTool",
+        func=lambda text: call_routing(text),
+        description="Assigns a department for the ticket via Space 2. Mandatory tool."
+    ),
+    Tool(
+        name="KnowledgeBaseTool",
+        func=lambda text: query_kb(text)["answer"],
+        description="Searches KB for relevant solution. Returns answer text."
+    )
+]
+
+# -------------------------------
+# Initialize Memory
+# -------------------------------
+memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+
+# -------------------------------
+# Initialize Agent
+# -------------------------------
+agent_executor = initialize_agent(
+    tools=tools,
+    llm=GeminiLLM(),
+    agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+    memory=memory,
+    verbose=False
+)
+
+# -------------------------------
+# Process Ticket Function
+# -------------------------------
+def process_ticket_langchain(ticket_text):
+    reasoning_trace = []
+
+    # Step 1: Classifier
+    classification = classify_ticket(ticket_text)
+    reasoning_trace.append(f"[Classifier] Impact: {classification['impact']}, Urgency: {classification['urgency']}, Type: {classification['type']}")
+
+    # Step 2: Routing
+    department = call_routing(ticket_text)
+    reasoning_trace.append(f"[Routing] Assigned Department: {department}")
+
+    # Step 3: KB Search
+    kb_result = query_kb(ticket_text)
+    reasoning_trace.append(f"[KB Search] Top answer: '{kb_result['answer']}' (confidence: {kb_result['confidence']})")
+
+    # Step 4: Decision KB vs LLM
+    if kb_result["confidence"] >= 0.75:
+        final_answer = kb_result["answer"]
+        status = "resolved"
+        reasoning_trace.append("[Decision] KB confidence high → ticket resolved via KB.")
+    else:
+        llm_prompt = f"""
+You are a professional IT helpdesk assistant.
+A user submitted the following ticket: "{ticket_text}"
+Ticket classification: {classification}
+Assigned department: {department}
+KB Search result: {kb_result['answer']} (confidence: {kb_result['confidence']})
+
+Provide a professional and descriptive solution or guidance based on this information.
+"""
+        final_answer = GeminiLLM()(llm_prompt)
+        status = "escalated"
+        reasoning_trace.append("[Decision] KB confidence low → ticket escalated via Gemini LLM.")
+
+    return {
+        "status": status,
+        "classification": classification,
+        "department": department,
+        "answer": final_answer,
+        "reasoning_trace": reasoning_trace
+    }

app.py

@@ -0,0 +1,121 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from agent_langchain import process_ticket_langchain, classify_ticket, call_routing, kb_collection
+import chromadb
+from chromadb.config import Settings
+from chromadb.utils import embedding_functions
+import json
+import os
+
+app = FastAPI(title="Smart Helpdesk AI Agent LangChain")
+
+# -------------------------------
+# Request Models
+# -------------------------------
+class TicketRequest(BaseModel):
+    text: str
+    user_email: str = None
+
+class SetupRequest(BaseModel):
+    kb_file: str  # path to KB.json
+
+# -------------------------------
+# KB Setup Endpoint
+# -------------------------------
+@app.post("/setup")
+async def setup_endpoint(req: SetupRequest):
+    """Embed KB.json and store in ChromaDB"""
+    global kb_collection
+    if not os.path.exists(req.kb_file):
+        raise HTTPException(status_code=404, detail="KB.json file not found")
+
+    # Load KB
+    with open(req.kb_file, "r") as f:
+        kb_data = json.load(f)
+
+    # Create ChromaDB collection if not exists
+    chroma_client = chromadb.Client(Settings(
+        chroma_db_impl="duckdb+parquet",
+        persist_directory="/data/chroma_db"
+    ))
+
+    try:
+        kb_collection = chroma_client.get_collection("kb_collection")
+    except:
+        kb_collection = chroma_client.create_collection("kb_collection")
+
+    # Setup embedding function
+    embedding_func = embedding_functions.SentenceTransformerEmbeddingFunction(
+        model_name="sentence-transformers/multi-qa-mpnet-base-dot-v1"
+    )
+
+    # Add KB entries
+    for entry in kb_data["knowledge_base"]:
+        kb_collection.add(
+            documents=[entry["answer"]],
+            metadatas=[{
+                "id": entry["id"],
+                "category": entry.get("category", ""),
+                "question_variations": entry.get("question_variations", []),
+                "keywords": entry.get("keywords", [])
+            }],
+            ids=[entry["id"]],
+            embedding_function=embedding_func
+        )
+
+    kb_collection.persist()
+    return {"status": "KB embedded and stored successfully"}
+
+# -------------------------------
+# Step-by-Step Endpoints
+# -------------------------------
+
+@app.post("/classify")
+async def classify_endpoint(ticket: TicketRequest):
+    """Classify the ticket (impact, urgency, type)"""
+    classification = classify_ticket(ticket.text)
+    return {"classification": classification}
+
+@app.post("/route")
+async def route_endpoint(ticket: TicketRequest):
+    """Route the ticket to department (Space 2)"""
+    department = call_routing(ticket.text)
+    return {"department": department}
+
+@app.post("/kb_query")
+async def kb_query_endpoint(ticket: TicketRequest):
+    """Query KB directly"""
+    if not kb_collection:
+        raise HTTPException(status_code=400, detail="KB not set up. Call /setup first.")
+    result = kb_collection.query(query_texts=[ticket.text], n_results=1)
+    if not result or len(result['documents'][0]) == 0:
+        return {"answer": "No relevant KB found."}
+    return {"answer": result['documents'][0][0], "confidence": result['distances'][0][0] if result.get('distances') else 0.0}
+
+# -------------------------------
+# Full Ticket Orchestration
+# -------------------------------
+@app.post("/orchestrate")
+async def orchestrate_endpoint(ticket: TicketRequest):
+    """Full ticket orchestration via LangChain agent with nicely formatted reasoning trace"""
+    result = process_ticket_langchain(ticket.text)
+
+    # Format reasoning trace for readability
+    formatted_trace = [{"step": idx + 1, "description": line} for idx, line in enumerate(result.get("reasoning_trace", []))]
+
+    response = {
+        "status": result["status"],
+        "classification": result["classification"],
+        "department": result["department"],
+        "answer": result["answer"],
+        "reasoning_trace": formatted_trace
+    }
+
+    return response
+
+# -------------------------------
+# Health Check
+# -------------------------------
+@app.get("/health")
+async def health():
+    return {"status": "ok"}

main.py

@@ -0,0 +1,121 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from agent_langchain import process_ticket_langchain, classify_ticket, call_routing, kb_collection
+import chromadb
+from chromadb.config import Settings
+from chromadb.utils import embedding_functions
+import json
+import os
+
+app = FastAPI(title="Smart Helpdesk AI Agent LangChain")
+
+# -------------------------------
+# Request Models
+# -------------------------------
+class TicketRequest(BaseModel):
+    text: str
+    user_email: str = None
+
+class SetupRequest(BaseModel):
+    kb_file: str  # path to KB.json
+
+# -------------------------------
+# KB Setup Endpoint
+# -------------------------------
+@app.post("/setup")
+async def setup_endpoint(req: SetupRequest):
+    """Embed KB.json and store in ChromaDB"""
+    global kb_collection
+    if not os.path.exists(req.kb_file):
+        raise HTTPException(status_code=404, detail="KB.json file not found")
+
+    # Load KB
+    with open(req.kb_file, "r") as f:
+        kb_data = json.load(f)
+
+    # Create ChromaDB collection if not exists
+    chroma_client = chromadb.Client(Settings(
+        chroma_db_impl="duckdb+parquet",
+        persist_directory="/data/chroma_db"
+    ))
+
+    try:
+        kb_collection = chroma_client.get_collection("kb_collection")
+    except:
+        kb_collection = chroma_client.create_collection("kb_collection")
+
+    # Setup embedding function
+    embedding_func = embedding_functions.SentenceTransformerEmbeddingFunction(
+        model_name="sentence-transformers/multi-qa-mpnet-base-dot-v1"
+    )
+
+    # Add KB entries
+    for entry in kb_data["knowledge_base"]:
+        kb_collection.add(
+            documents=[entry["answer"]],
+            metadatas=[{
+                "id": entry["id"],
+                "category": entry.get("category", ""),
+                "question_variations": entry.get("question_variations", []),
+                "keywords": entry.get("keywords", [])
+            }],
+            ids=[entry["id"]],
+            embedding_function=embedding_func
+        )
+
+    kb_collection.persist()
+    return {"status": "KB embedded and stored successfully"}
+
+# -------------------------------
+# Step-by-Step Endpoints
+# -------------------------------
+
+@app.post("/classify")
+async def classify_endpoint(ticket: TicketRequest):
+    """Classify the ticket (impact, urgency, type)"""
+    classification = classify_ticket(ticket.text)
+    return {"classification": classification}
+
+@app.post("/route")
+async def route_endpoint(ticket: TicketRequest):
+    """Route the ticket to department (Space 2)"""
+    department = call_routing(ticket.text)
+    return {"department": department}
+
+@app.post("/kb_query")
+async def kb_query_endpoint(ticket: TicketRequest):
+    """Query KB directly"""
+    if not kb_collection:
+        raise HTTPException(status_code=400, detail="KB not set up. Call /setup first.")
+    result = kb_collection.query(query_texts=[ticket.text], n_results=1)
+    if not result or len(result['documents'][0]) == 0:
+        return {"answer": "No relevant KB found."}
+    return {"answer": result['documents'][0][0], "confidence": result['distances'][0][0] if result.get('distances') else 0.0}
+
+# -------------------------------
+# Full Ticket Orchestration
+# -------------------------------
+@app.post("/orchestrate")
+async def orchestrate_endpoint(ticket: TicketRequest):
+    """Full ticket orchestration via LangChain agent with nicely formatted reasoning trace"""
+    result = process_ticket_langchain(ticket.text)
+
+    # Format reasoning trace for readability
+    formatted_trace = [{"step": idx + 1, "description": line} for idx, line in enumerate(result.get("reasoning_trace", []))]
+
+    response = {
+        "status": result["status"],
+        "classification": result["classification"],
+        "department": result["department"],
+        "answer": result["answer"],
+        "reasoning_trace": formatted_trace
+    }
+
+    return response
+
+# -------------------------------
+# Health Check
+# -------------------------------
+@app.get("/health")
+async def health():
+    return {"status": "ok"}

requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.109.1
+uvicorn[standard]==0.23.2
+transformers==4.34.0
+torch==2.2.0
+sentence-transformers==2.2.2
+requests==2.31.0
+pydantic==2.6.1
+chromadb==0.4.4
+langchain==0.1.0
+protobuf==4.23.4
+accelerate==0.23.0