Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,7 @@
+chroma_db
+.venv
+__pycache__
+.env
+data.csv
+evaluation_results.csv
+tariff.pdf

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.11-slim
+
+# Create a user to run the app
+RUN useradd -m -u 1000 user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+# Copy the application code
+COPY --chown=user:user . $HOME/app/
+
+# Switch to the new user
+USER user
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose the default Hugging Face Spaces port
+EXPOSE 7860
+
+# Command to run the FastApi application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,114 @@
+# Multi-Agent Canadian HTS Classification System
+
+This repository contains a sophisticated, multi-agent AI pipeline designed to intelligently predict Canadian Harmonized Tariff Schedule (HTS) codes from plain-text item descriptions. The system leverages **LangGraph**, **LangChain**, and **Chroma** vector databases to achieve high-accuracy classifications through a combination of live web research, official document retrieval, and self-consistency voting.
+
+## 🚀 Key Features
+
+*   **Multi-Agent Orchestration**: Powered by LangGraph for structured, stateful workflows.
+*   **Search Agent**: Real-time web browsing using DuckDuckGo and BeautifulSoup to gather material composition and industry context.
+*   **RAG Agent**: Contextual retrieval from the official 2024 Canadian Tariff Schedule (PDF) via ChromaDB.
+*   **Self-Consistency Voting**: Uses a 3-instance ensemble with prompt perturbations to calculate confidence scores for each digit of the HTS code.
+*   **Human-in-the-Loop Escalation**: Automatically triggers a clarification chat interface if the AI's confidence in any HTS element falls below 60%.
+*   **Modern Web UI**: A glassmorphic, responsive web interface built with FastAPI and Vanilla CSS/JS for real-time interaction and reasoning visualization.
+*   **Model Agnostic**: Supports Google Gemini (Cloud) and Ollama (Local) pipelines.
+
+---
+
+## 🏗️ Architecture
+
+The classification workflow follows a directed acyclic graph (DAG):
+
+1.  **Search Node**: Formulates optimized queries, scrapes results, and extracts relevant technical specifications.
+2.  **RAG Node**: Vectorizes the item description to pull specific legal headings and subheadings from the local 1,500+ page tariff schedule.
+3.  **Decision Node**:
+    *   Synthesizes Web + PDF context.
+    *   Runs 3 independent classification attempts.
+    *   Performs element-wise voting to determine the final 10-digit code (`XXXX.XX.XX.XX`).
+    *   Calculates a confidence score for each segment (Chapter, Heading, Subheading, etc.).
+4.  **Escalation Logic**: If consensus is not reached, it prepares a targeted clarifying question for the user.
+
 ---
-title: Hts
-emoji: 💻
-colorFrom: pink
-colorTo: yellow
-sdk: docker
-pinned: false
-short_description: Canadian Harmonized Tariff Schedule (HTS) Code Identifier
+
+## 🛠️ Setup & Installation
+
+### 1. Environment Configuration
+
+Ensure you have Python 3.11+ installed. We recommend using a virtual environment.
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+# Note: Ensure fastapi, uvicorn, and duckduckgo-search (ddgs) are also installed.
+```
+
+### 2. API Credentials
+
+Create a `.env` file in the root directory:
+
+```env
+GEMINI_API_KEY=your_google_ai_studio_api_key
+```
+
+### 3. Data Ingestion (First-Time Only)
+
+Populate the Chroma vector store with extracts from the official `tariff.pdf`:
+
+```bash
+python data_ingestion.py
+```
+*This creates the `chroma_db/` directory.*
+
+---
+
+## 🖥️ Usage
+
+### Option A: The Web Application (Recommended)
+
+Start the interactive web interface to experience the human-escalation chatbot and visual reasoning chain.
+
+```bash
+python app.py
+```
+Access the UI at: `http://localhost:8001`
+
+### Option B: Interactive CLI Wrappers
+
+Test individual descriptions and view full internal logs in the terminal.
+
+*   **Gemini (Cloud)**: `python run_gemini.py`
+*   **Ollama (Local)**: `python run_ollama.py`
+
+### Option C: Batch Evaluation
+
+Benchmark the system against `data.csv` to calculate accuracy and generate performance reports for a specific model. You must specify the model using the `--model` argument:
+
+**For Gemini:**
+```bash
+python evaluate.py --model gemini-3.1-flash-lite-preview
+```
+
+**For Ollama:**
+```bash
+python evaluate.py --model qwen3:4b
+```
+*Results are saved to a dynamically named CSV, e.g., `gemini-3.1-flash-lite-preview_evaluation_results.csv`.*
+
+---
+
+## 📂 Project Structure
+
+| File | Description |
+| :--- | :--- |
+| `app.py` | FastAPI application serving the Web UI and API endpoints. |
+| `graph.py` | Core LangGraph logic, agent node definitions, and escalation chat. |
+| `data_ingestion.py` | PDF parsing and vector database (RAG) initialization. |
+| `evaluate.py` | Metric generation and batch testing script. |
+| `run_*.py` | CLI entry points for specific LLM backends. |
+| `static/` | Frontend assets (HTML/CSS/JS) for the web interface. |
+| `tariff.pdf` | The official reference document for Canadian HTS codes. |
+| `requirements.txt` | Python dependencies. |
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## ⚖️ License
+This project is intended for research and internal logistical optimization. Always verify final HTS codes with official customs documentation for legal compliance.

app.py

@@ -0,0 +1,79 @@
+import os
+from fastapi import FastAPI, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from dotenv import load_dotenv
+from langchain_google_genai import ChatGoogleGenerativeAI
+from graph import run_pipeline, process_escalation_chat
+from typing import List, Dict
+
+# Initialize FastAPI
+app = FastAPI(title="HTS Code Generator API")
+
+# Load Env
+load_dotenv()
+gemini_api_key = os.environ.get("GEMINI_API_KEY")
+os.environ["GOOGLE_API_KEY"] = gemini_api_key
+
+# Mount static directory for the frontend
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# LLM setup
+gemini_llm = ChatGoogleGenerativeAI(
+    model="gemini-3.1-flash-lite-preview",
+    disable_streaming=True
+)
+
+class ClassifyRequest(BaseModel):
+    description: str
+
+class EscalationRequest(BaseModel):
+    description: str
+    search_results: str
+    rag_context: str
+    chat_history: List[Dict[str, str]]
+
+@app.get("/")
+def read_index():
+    return FileResponse("static/index.html")
+
+@app.post("/api/classify")
+def classify_hts(request: ClassifyRequest):
+    if not request.description.strip():
+        raise HTTPException(status_code=400, detail="Description is required.")
+        
+    try:
+        # Run the LangGraph Pipeline
+        result = run_pipeline(request.description, gemini_llm)
+        return {
+            "success": True,
+            "final_hts_code": result.get("final_hts_code"),
+            "element_confidences": result.get("element_confidences"),
+            "escalation_needed": result.get("escalation_needed"),
+            "escalation_question": result.get("escalation_question"),
+            "reasoning_steps": result.get("reasoning_steps"),
+            "search_results": result.get("search_results"),
+            "rag_context": result.get("rag_context"),
+            "search_queries": result.get("search_queries")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/escalation")
+def handle_escalation(request: EscalationRequest):
+    try:
+        result = process_escalation_chat(
+            request.description,
+            request.search_results,
+            request.rag_context,
+            request.chat_history,
+            gemini_llm
+        )
+        return {"success": True, "result": result}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001)

data_ingestion.py

@@ -0,0 +1,38 @@
+import os
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_chroma import Chroma
+
+def ingest_data(pdf_path="tariff.pdf", persist_directory="./chroma_db"):
+    print(f"Loading {pdf_path}...")
+    loader = PyPDFLoader(pdf_path)
+    documents = loader.load()
+    
+    print(f"Loaded {len(documents)} pages. Splitting text...")
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    splits = text_splitter.split_documents(documents)
+    
+    print(f"Created {len(splits)} chunks. Generating embeddings and storing in VectorDB...")
+    
+    # Using a fast, local embedding model that both Gemini and Ollama agents can share
+    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+    
+    vectorstore = Chroma.from_documents(
+        documents=splits,
+        embedding=embeddings,
+        persist_directory=persist_directory
+    )
+    
+    print(f"Successfully ingested {len(splits)} chunks into {persist_directory}")
+    return vectorstore
+
+if __name__ == "__main__":
+    # Ensure current working directory is the project root
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(script_dir)
+    
+    if os.path.exists("./chroma_db"):
+        print("VectorDB already exists at ./chroma_db. Skipping ingestion.")
+    else:
+        ingest_data()

deploy_to_hf.py

@@ -0,0 +1,42 @@
+import os
+import argparse
+from huggingface_hub import HfApi
+
+def deploy(token, repo_id):
+    api = HfApi(token=token)
+    
+    print(f"Deploying to {repo_id}...")
+    
+    # Create the repo if it doesn't exist yet
+    try:
+        api.create_repo(repo_id=repo_id, repo_type="space", space_sdk="docker", exist_ok=True)
+        print(f"Ensured Space repo {repo_id} exists.")
+    except Exception as e:
+        print(f"Note on create_repo: {e}")
+        
+    # Upload all files in the current directory
+    # excluding secret or unnecessary files
+    api.upload_folder(
+        folder_path=".",
+        repo_id=repo_id,
+        repo_type="space",
+        ignore_patterns=[
+            ".git", 
+            ".git/*",
+            ".venv", 
+            ".venv/*",
+            "__pycache__", 
+            "__pycache__/*", 
+            ".env",
+            "*.pyc"
+        ],
+    )
+    print(f"Deployment successful! Check out your Space at: https://huggingface.co/spaces/{repo_id}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Deploy app to Hugging Face Spaces")
+    parser.add_argument("--token", required=True, help="Your Hugging Face User Access Token (with Write permissions)")
+    parser.add_argument("--repo-id", default="minatosnow/hts", help="The Hugging Face Space ID (e.g., username/repo_name)")
+    args = parser.parse_args()
+    
+    deploy(args.token, args.repo_id)

evaluate.py

@@ -0,0 +1,107 @@
+import os
+import argparse
+import pandas as pd
+from dotenv import load_dotenv
+from graph import run_pipeline
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_ollama import ChatOllama
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate HTS Classification Pipeline")
+    parser.add_argument("--model", type=str, required=True, help="Model name to evaluate (e.g., gemini-3.1-flash-lite-preview, qwen3:4b)")
+    args = parser.parse_args()
+    
+    model_name = args.model
+
+    load_dotenv()
+    if "gemini" in model_name.lower():
+        gemini_api_key = os.environ.get("GEMINI_API_KEY")
+        if gemini_api_key:
+            os.environ["GOOGLE_API_KEY"] = gemini_api_key
+        
+        print(f"Initializing Gemini pipeline with model: {model_name}")
+        llm = ChatGoogleGenerativeAI(
+            model=model_name,
+            disable_streaming=True
+        )
+    else:
+        print(f"Initializing Ollama pipeline with model: {model_name}")
+        llm = ChatOllama(model=model_name)
+    
+    # Load dataset
+    df = pd.read_csv("data.csv")
+    
+    results = []
+    element_correct = {
+        "Chapter (first 2)": 0,
+        "Heading (next 2)": 0,
+        "Subheading 1 (next 2)": 0,
+        "Subheading 2 (next 2)": 0,
+        "Statistical Suffix (last 2)": 0,
+        "Whole (10 digits)": 0
+    }
+    total = len(df)
+    
+    for idx, row in df.iterrows():
+        desc = str(row['desc'])
+        label = str(row['label']).strip()
+        print(f"\n[{idx+1}/{total}] Processing item: {desc}")
+        print(f"Target Label: {label}")
+        
+        try:
+            result = run_pipeline(desc, llm, disable_escalation=True)
+            pred = result["final_hts_code"]
+        except Exception as e:
+            print(f"Error ({model_name}): {e}")
+            pred = "ERROR"
+            
+        print(f"Prediction: {pred}")
+        
+        # Evaluation logic
+        # Some HTS codes might have spaces or dashes, keep only digits
+        clean_label = ''.join(filter(str.isdigit, label)).ljust(10, '0')[:10]
+        
+        # Clean predictions to match the label format exactly (10 digits)
+        clean_pred = ''.join(filter(str.isdigit, pred)).ljust(10, '0')[:10]
+        
+        match_chapter = clean_label[0:2] == clean_pred[0:2]
+        match_heading = clean_label[2:4] == clean_pred[2:4]
+        match_subheading1 = clean_label[4:6] == clean_pred[4:6]
+        match_subheading2 = clean_label[6:8] == clean_pred[6:8]
+        match_statistical_suffix = clean_label[8:10] == clean_pred[8:10]
+        match_whole = clean_label == clean_pred
+        
+        if match_chapter: element_correct["Chapter (first 2)"] += 1
+        if match_heading: element_correct["Heading (next 2)"] += 1
+        if match_subheading1: element_correct["Subheading 1 (next 2)"] += 1
+        if match_subheading2: element_correct["Subheading 2 (next 2)"] += 1
+        if match_statistical_suffix: element_correct["Statistical Suffix (last 2)"] += 1
+        if match_whole: element_correct["Whole (10 digits)"] += 1
+            
+        results.append({
+            "Description": desc,
+            "Target_HTS": clean_label,
+            "Prediction": clean_pred,
+            "Correct_Chapter": match_chapter,
+            "Correct_Heading": match_heading,
+            "Correct_Subheading_1": match_subheading1,
+            "Correct_Subheading_2": match_subheading2,
+            "Correct_Statistical_Suffix": match_statistical_suffix,
+            "Correct_Whole": match_whole
+        })
+        
+    print("\n--- Final Evaluation ---")
+    print(f"Model: {model_name}")
+    print(f"Total Items: {total}")
+    for el, count in element_correct.items():
+        print(f"{el} Accuracy: {count}/{total} ({count/total*100:.2f}%)")
+    
+    safe_model_name = model_name.replace(":", "_").replace("/", "_")
+    output_filename = f"{safe_model_name}_evaluation_results.csv"
+    
+    results_df = pd.DataFrame(results)
+    results_df.to_csv(output_filename, index=False)
+    print(f"Saved results to {output_filename}")
+
+if __name__ == "__main__":
+    main()

graph.py

@@ -0,0 +1,318 @@
+import os
+import json
+import requests
+from bs4 import BeautifulSoup
+from typing import TypedDict, List, Any, Dict
+from langgraph.graph import StateGraph, START, END
+from ddgs import DDGS
+from langchain_chroma import Chroma
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_core.messages import SystemMessage, HumanMessage
+import logging
+import warnings
+
+# Suppress harmless warnings
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["TRANSFORMERS_VERBOSITY"] = "error"
+logging.getLogger("transformers").setLevel(logging.ERROR)
+logging.getLogger("transformers.modeling_utils").setLevel(logging.ERROR)
+logging.getLogger("sentence_transformers").setLevel(logging.ERROR)
+warnings.filterwarnings("ignore")
+
+class GraphState(TypedDict):
+    item_description: str
+    search_queries: List[str]
+    search_results: str
+    rag_context: str
+    reasoning_steps: str
+    final_hts_code: str
+    element_confidences: Dict[str, Any]
+    escalation_needed: bool
+    escalation_question: str
+    disable_escalation: bool
+    llm: Any
+
+def search_node(state: GraphState):
+    llm = state["llm"]
+    item_desc = state["item_description"]
+    
+    # 1. Ask LLM to generate a search query
+    sys_msg = SystemMessage(content="You are an expert search assistant. Given an item description, generate a concise DuckDuckGo search query to find its Canadian HTS code, material composition, or tariff classification. Output ONLY the query string. Do not include quotes or extra text.")
+    user_msg = HumanMessage(content=item_desc)
+    
+    response = llm.invoke([sys_msg, user_msg])
+    content = response.content
+    if isinstance(content, list):
+        content = content[0].get("text", "") if isinstance(content[0], dict) else str(content[0])
+    query = content.strip().strip('"').strip("'")
+    
+    # 2. Search DDG
+    ddgs = DDGS()
+    try:
+        results = list(ddgs.text(query + " Canadian HTS code", max_results=3))
+    except Exception as e:
+        results = []
+        
+    # 3. Scrape results
+    scraped_content = ""
+    for r in results:
+        url = r.get("href")
+        if not url: continue
+        try:
+            resp = requests.get(url, timeout=5)
+            soup = BeautifulSoup(resp.content, "html.parser")
+            text = " ".join([p.text for p in soup.find_all("p")])
+            scraped_content += f"\nSource ({url}):\n{text[:1000]}\n"
+        except:
+            scraped_content += f"\nSource ({url}): {r.get('body')}\n"
+            
+    if not scraped_content.strip():
+        scraped_content = "No relevant web results found."
+        
+    return {"search_queries": [query], "search_results": scraped_content}
+
+def rag_node(state: GraphState):
+    item_desc = state["item_description"]
+    
+    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+    vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
+    
+    docs = retriever.invoke(item_desc)
+    rag_context = "\n\n".join([d.page_content for d in docs])
+    
+    return {"rag_context": rag_context}
+    
+def decision_node(state: GraphState):
+    # Retrieve base LLM
+    base_llm = state["llm"]
+    item_desc = state["item_description"]
+    search_results = state["search_results"]
+    rag_context = state["rag_context"]
+    
+    sys_msg = SystemMessage(content="""You are an expert Canadian customs classification agent. 
+    Analyze the item description, web search context, and official Canadian Tariff PDF context to determine the 10-digit Canadian HTS code.
+    Output your response as STRICT JSON with the following structure:
+    {
+    "reasoning": "Step-by-step logic for the classification...",
+    "chapter": "First 2 digits",
+    "heading": "Next 2 digits",
+    "subheading": "Next 2 digits",
+    "additional_subheading": "Next 2 digits",
+    "statistical_suffix": "Last 2 digits"
+    }
+    Ensure all digits combined make exactly 10 digits. Do not include markdown formatting like ```json. Output ONLY the raw JSON object.
+    """)
+    user_msg = HumanMessage(content=f"Item Description: {item_desc}\n\nWeb Search Context:\n{search_results}\n\nTariff Context:\n{rag_context}")
+    
+    # 5-Ensemble Voting for Self-Consistency
+    # We will simulate perturbations using 5 different variations of the prompt slightly.
+    perturbations = [
+        "What is the HTS code for this item?",
+        "Carefully re-evaluate the material composition and function. What is the 10-digit HTS code?",
+        "Please provide the most accurate 10-digit Tariff classification based on the provided evidence.",
+        "Considering all the retrieved context and the item's main characteristics, determine its exact 10-digit HTS code.",
+        "Synthesize the search context and tariff information to deduce the most specific 10-digit Canadian HTS classification."
+    ]
+    
+    results_list = []
+    first_reasoning = ""
+    
+    for i, pert in enumerate(perturbations):
+        perturbed_user_msg = HumanMessage(content=f"{user_msg.content}\n\n{pert}")
+        # Note: Ideally we'd vary temperature, but LangChain's ChatGoogleGenerativeAI might need re-instantiation for that. 
+        # Using altered user prompts is a standard perturbation.
+        try:
+            response = base_llm.invoke([sys_msg, perturbed_user_msg])
+            content = response.content
+            if isinstance(content, list):
+                content = content[0].get("text", "") if isinstance(content[0], dict) else str(content[0])
+            
+            # clean json
+            start = content.find('{')
+            end = content.rfind('}') + 1
+            json_str = content[start:end] if start != -1 and end != 0 else content
+            
+            data = None
+            try:
+                data = json.loads(json_str)
+            except Exception:
+                try:
+                    import ast
+                    # Fallback for Python dict strings (e.g. single quotes)
+                    data = ast.literal_eval(json_str)
+                except Exception:
+                    try:
+                        # Fallback for minor quote replacement
+                        data = json.loads(json_str.replace("'", '"'))
+                    except Exception:
+                        pass # Parsing completely failed
+                
+            if not isinstance(data, dict):
+                continue # Skip this ensemble run if it didn't produce a dictionary
+                
+            if i == 0:
+                first_reasoning = data.get("reasoning", "")
+            results_list.append(data)
+        except Exception:
+            # Silently pass on this ensemble run if there was an API or severe extraction error
+            pass
+    # Voting logic
+    elements = ["chapter", "heading", "subheading", "additional_subheading", "statistical_suffix"]
+    votes = {el: {} for el in elements}
+    
+    for res in results_list:
+        if not isinstance(res, dict): continue
+        for el in elements:
+            val = res.get(el, "")
+            # Ensure it's exactly 2 digits
+            val = ''.join(filter(str.isdigit, str(val)))[:2].zfill(2)
+            votes[el][val] = votes[el].get(val, 0) + 1
+            
+    final_elements = {}
+    element_confidences = {}
+    escalation_needed = False
+    
+    for el in elements:
+        if not votes[el]:
+            # Fallback if all failed
+            final_elements[el] = "00"
+            element_confidences[el] = {"value": "00", "confidence": "0% (0/5)", "score": 0.0}
+            escalation_needed = True
+            continue
+            
+        # Get max voted value
+        top_val = max(votes[el], key=votes[el].get)
+        vote_count = votes[el][top_val]
+        total_runs = len(results_list) if len(results_list) > 0 else 5
+        confidence_fraction = vote_count / total_runs
+        
+        final_elements[el] = top_val
+        element_confidences[el] = {
+            "value": top_val, 
+            "confidence": f"{int(confidence_fraction*100)}% ({vote_count}/{total_runs})",
+            "score": confidence_fraction
+        }
+        
+        # If not unanimous or at least 2/3, we escalate
+        if confidence_fraction < 0.6:  # Less than 2 out of 3
+            escalation_needed = True
+            
+    final_hts_code = f"{final_elements['chapter']}{final_elements['heading']}.{final_elements['subheading']}.{final_elements['additional_subheading']}.{final_elements['statistical_suffix']}"
+    
+    escalation_question = ""
+    # Check disable_escalation flag to conditionally override question generation
+    disable_escalation = state.get("disable_escalation", False)
+    
+    if escalation_needed and not disable_escalation:
+        # Generate the first escalation question
+        esc_sys_msg = SystemMessage(content="You are an expert Canadian customs classification assistant. Our AI ensemble could not confidently classify an item. Given the item context and the elements we are struggling with, ask the user ONE targeted, clarifying question to help determine the correct 10-digit HTS code.")
+        esc_user_msg = HumanMessage(content=f"Item: {item_desc}\n\nSearch Context: {search_results}\n\nTariff Context: {rag_context}\n\nCurrent Best Confidences:\n{json.dumps(element_confidences, indent=2)}\n\nWhat ONE question should I ask the user to clarify the classification?")
+        try:
+            esc_response = base_llm.invoke([esc_sys_msg, esc_user_msg])
+            content = esc_response.content
+            escalation_question = content[0].get("text", "") if isinstance(content, list) else str(content).strip()
+        except:
+            escalation_question = "Could you please provide more details about the material composition or specific function of this item?"
+
+    return {
+        "final_hts_code": final_hts_code,
+        "reasoning_steps": first_reasoning,
+        "element_confidences": element_confidences,
+        "escalation_needed": escalation_needed,
+        "escalation_question": escalation_question
+    }
+    
+def process_escalation_chat(item_desc: str, search_results: str, rag_context: str, chat_history: List[Dict[str, str]], llm: Any):
+    # Chat history is a list of dicts: [{"role": "user"|"assistant", "content": "..."}]
+    
+    sys_msg = SystemMessage(content="""You are an expert Canadian customs classification agent interacting with a human. 
+    Your goal is to determine the 10-digit Canadian HTS code.
+    If you are still unsure, ask ONE clarifying question.
+    If you are confident you know the 10-digit code, you MUST output a STRICT JSON payload with exactly this structure:
+    {
+    "reasoning": "Step-by-step logic",
+    "chapter": "First 2 digits",
+    "heading": "Next 2 digits",
+    "subheading": "Next 2 digits",
+    "additional_subheading": "Next 2 digits",
+    "statistical_suffix": "Last 2 digits",
+    "final_hts_code": "XXXX.XX.XX.XX",
+    "element_confidences": {
+        "chapter": { "value": "XX", "confidence": "100% (Human Verified)", "score": 1.0 },
+        "heading": { "value": "XX", "confidence": "100% (Human Verified)", "score": 1.0 },
+        "subheading": { "value": "XX", "confidence": "100% (Human Verified)", "score": 1.0 },
+        "additional_subheading": { "value": "XX", "confidence": "100% (Human Verified)", "score": 1.0 },
+        "statistical_suffix": { "value": "XX", "confidence": "100% (Human Verified)", "score": 1.0 }
+    },
+    "is_final": true
+    }
+    Do NOT output JSON until you are absolutely confident. Otherwise, just output conversational text asking the clarifying question.
+    """)
+    
+    messages = [sys_msg]
+    messages.append(HumanMessage(content=f"Initial Item Description: {item_desc}\n\nWeb Search Context:\n{search_results}\n\nTariff Context:\n{rag_context}"))
+    
+    for msg in chat_history:
+        if msg["role"] == "user":
+            messages.append(HumanMessage(content=msg["content"]))
+        elif msg["role"] == "assistant":
+            messages.append(SystemMessage(content=f"Assistant previously said: {msg['content']}")) # Use SystemMessage or AIMessage. AIMessage is better if available. Doing SystemMessage for simplicity/safety
+
+    response = llm.invoke(messages)
+    content = response.content
+    if isinstance(content, list):
+        content = content[0].get("text", "") if isinstance(content[0], dict) else str(content[0])
+        
+    content = content.strip()
+    
+    # Try parsing as JSON
+    try:
+        start = content.find('{')
+        end = content.rfind('}') + 1
+        if start != -1 and end != 0:
+            json_str = content[start:end]
+            data = json.loads(json_str)
+            if data.get("is_final") or data.get("final_hts_code"):
+                return {"is_final": True, "data": data}
+    except:
+        pass
+        
+    # If not JSON or failed to parse, it's a question
+    return {"is_final": False, "message": content}
+
+def build_graph():
+    builder = StateGraph(GraphState)
+    # builder.add_node("search", search_node)
+    builder.add_node("rag", rag_node)
+    builder.add_node("decision", decision_node)
+    
+    # builder.add_edge(START, "search")
+    # builder.add_edge("search", "rag")
+    builder.add_edge(START, "rag")
+    builder.add_edge("rag", "decision")
+    builder.add_edge("decision", END)
+    
+    return builder.compile()
+
+# Instantiate the executable graph
+graph = build_graph()
+
+def run_pipeline(item_description: str, llm: Any, disable_escalation: bool = False):
+    initial_state = {
+        "item_description": item_description, 
+        "llm": llm, 
+        "search_queries": [], 
+        "search_results": "", 
+        "rag_context": "", 
+        "reasoning_steps": "", 
+        "final_hts_code": "", 
+        "element_confidences": {}, 
+        "escalation_needed": False, 
+        "escalation_question": "",
+        "disable_escalation": disable_escalation
+    }
+    result = graph.invoke(initial_state)
+    return result
+
+

knowledge.md

@@ -0,0 +1,3 @@
+To activate the Python environment:
+- run `bash` command
+- run `source .venv/bin/activate` command

requirements.txt

@@ -0,0 +1,15 @@
+langchain
+langgraph
+langchain-google-genai
+langchain-ollama
+chromadb
+pypdf
+sentence-transformers
+ddgs
+pandas
+beautifulsoup4
+requests
+fastapi
+uvicorn
+python-multipart
+langchain-huggingface

results.md

@@ -0,0 +1,8 @@
+Model: gemini-3.1-flash-lite-preview
+Total Items: 144
+Chapter (first 2) Accuracy: 107/144 (74.31%)
+Heading (next 2) Accuracy: 89/144 (61.81%)
+Subheading 1 (next 2) Accuracy: 75/144 (52.08%)
+Subheading 2 (next 2) Accuracy: 88/144 (61.11%)
+Statistical Suffix (last 2) Accuracy: 69/144 (47.92%)
+Whole (10 digits) Accuracy: 28/144 (19.44%)

run_gemini.py

@@ -0,0 +1,42 @@
+import os
+from dotenv import load_dotenv
+from graph import run_pipeline
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+def main():
+    load_dotenv()
+    gemini_api_key = os.environ.get("GEMINI_API_KEY")
+    os.environ["GOOGLE_API_KEY"] = gemini_api_key
+
+    # Initialize Gemini LLM
+    gemini_llm = ChatGoogleGenerativeAI(
+        model="gemini-3.1-flash-lite-preview",
+        disable_streaming=True
+    )
+    
+    print("Welcome to the Gemini HTS Code Generator!")
+    print("Enter 'quit' to exit.")
+    
+    while True:
+        desc = input("\nEnter item description: ")
+        if desc.lower() in ["quit", "exit", "q"]:
+            break
+            
+        print("Running pipeline (Search + RAG)...")
+        try:
+            result = run_pipeline(desc, gemini_llm)
+            print("\n" + "="*50)
+            print("REASONING STEPS & CONTEXT")
+            print("="*50)
+            print(f"Generated Search Queries: {result.get('search_queries', [])}")
+            print("\n--- Websites Read (Search Context) ---")
+            print(result.get("search_results", "None"))
+            print("\n--- Tariff PDF (RAG Context) ---")
+            print(result.get("rag_context", "None"))
+            print("="*50)
+            print(f"\n=> Predicted HTS Code: {result.get('final_hts_code', 'ERROR')}")
+        except Exception as e:
+            print(f"An error occurred: {e}")
+
+if __name__ == "__main__":
+    main()

run_ollama.py

@@ -0,0 +1,35 @@
+import os
+from graph import run_pipeline
+from langchain_ollama import ChatOllama
+
+def main():
+    # Initialize Ollama LLM
+    ollama_llm = ChatOllama(model="qwen3:4b")
+    
+    print("Welcome to the Ollama (Qwen) HTS Code Generator!")
+    print("Note: Ensure you have run 'ollama serve' and have the model pulled.")
+    print("Enter 'quit' to exit.")
+    
+    while True:
+        desc = input("\nEnter item description: ")
+        if desc.lower() in ["quit", "exit", "q"]:
+            break
+            
+        print("Running pipeline (Search + RAG)...")
+        try:
+            result = run_pipeline(desc, ollama_llm)
+            print("\n" + "="*50)
+            print("REASONING STEPS & CONTEXT")
+            print("="*50)
+            print(f"Generated Search Queries: {result.get('search_queries', [])}")
+            print("\n--- Websites Read (Search Context) ---")
+            print(result.get("search_results", "None"))
+            print("\n--- Tariff PDF (RAG Context) ---")
+            print(result.get("rag_context", "None"))
+            print("="*50)
+            print(f"\n=> Predicted HTS Code: {result.get('final_hts_code', 'ERROR')}")
+        except Exception as e:
+            print(f"An error occurred: {e}")
+
+if __name__ == "__main__":
+    main()

static/index.html

@@ -0,0 +1,108 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI HTS Code Generator</title>
+    <link rel="stylesheet" href="/static/style.css">
+    <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;600;700&display=swap" rel="stylesheet">
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+</head>
+
+<body>
+    <div class="blob shape1"></div>
+    <div class="blob shape2"></div>
+
+    <div class="container">
+        <header>
+            <h1>Global Trade HTS Assistant</h1>
+            <p>Describe your product to generate a 10-digit Harmonized Tariff Schedule code using self-consistency AI.
+            </p>
+        </header>
+
+        <main>
+            <div class="input-section glass-panel">
+                <textarea id="product-desc" placeholder="e.g., Men's 100% cotton woven long sleeve shirt..."
+                    rows="3"></textarea>
+                <button id="generate-btn" class="primary-btn">Lookup HTS Code</button>
+            </div>
+
+            <div id="results-section" class="results-section hidden">
+                <div class="glass-panel output-panel">
+                    <div id="final-code-container">
+                        <h2>Final HTS Code</h2>
+                        <div id="hts-code-display" class="hts-code-display"></div>
+                        <div class="confidence-grid" id="confidence-grid">
+                            <!-- Confidence bars injected here -->
+                        </div>
+                    </div>
+
+                    <div id="escalation-warning" class="hidden warning-box">
+                        <svg viewBox="0 0 24 24" class="icon">
+                            <path fill="currentColor" d="M12 2L1 21h22M12 6l7.5 13h-15M11 10v4h2v-4m-2 6v2h2v-2"></path>
+                        </svg>
+                        <span>Human Review Escalation Required: Our AI needs your help to finalize this code.</span>
+                    </div>
+
+                    <!-- Chatbot UI for Escalation -->
+                    <div id="escalation-chat-container" class="hidden">
+                        <div class="accordion">
+                            <div class="accordion-item active" id="chat-accordion-item">
+                                <button class="accordion-header" id="chat-accordion-btn">
+                                    Clarification Chat
+                                    <span class="arrow">▼</span>
+                                </button>
+                                <div class="accordion-content">
+                                    <div class="escalation-chat">
+                                        <div id="chat-messages" class="chat-messages">
+                                            <!-- Messages injected here -->
+                                        </div>
+                                        <div class="chat-input-area" id="chat-input-area">
+                                            <input type="text" id="chat-input"
+                                                placeholder="Type your response here..." />
+                                            <button id="send-chat-btn" class="chat-btn">Send</button>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="glass-panel reasoning-panel" id="reasoning-panel-container">
+                    <h3>AI Reasoning Chain</h3>
+                    <div id="reasoning-text" class="markdown-body"></div>
+
+                    <div class="accordion">
+                        <div class="accordion-item">
+                            <button class="accordion-header">
+                                View Search & RAG References
+                                <span class="arrow">▼</span>
+                            </button>
+                            <div class="accordion-content">
+                                <h4>Search Queries Used</h4>
+                                <ul id="search-queries"></ul>
+
+                                <h4>Web Context</h4>
+                                <pre id="web-context"></pre>
+
+                                <h4>Canadian Tariff PDF Context</h4>
+                                <pre id="rag-context"></pre>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <div id="loader" class="loader-container hidden">
+                <div class="spinner"></div>
+                <p id="loader-message">Analyzing product context...</p>
+            </div>
+        </main>
+    </div>
+
+    <script src="/static/script.js"></script>
+</body>
+
+</html>

static/script.js

@@ -0,0 +1,250 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const generateBtn = document.getElementById('generate-btn');
+    const productDesc = document.getElementById('product-desc');
+    const resultsSection = document.getElementById('results-section');
+    const loader = document.getElementById('loader');
+
+    // Accordion Logic
+    document.querySelectorAll('.accordion-header').forEach(header => {
+        header.addEventListener('click', () => {
+            const item = header.parentElement;
+            item.classList.toggle('active');
+            const content = item.querySelector('.accordion-content');
+            if (item.classList.contains('active')) {
+                content.style.maxHeight = content.scrollHeight + "px";
+            } else {
+                content.style.maxHeight = "0";
+            }
+        });
+    });
+
+    generateBtn.addEventListener('click', async () => {
+        const desc = productDesc.value.trim();
+        if (!desc) return alert("Please enter a product description!");
+
+        // UI Reset
+        resultsSection.classList.add('hidden');
+        loader.classList.remove('hidden');
+        generateBtn.disabled = true;
+
+        const loaderMessage = document.getElementById('loader-message');
+        const loadingSteps = [
+            "Parsing item description...",
+            "Searching DuckDuckGo for context...",
+            "Retrieving official Canadian Tariff schedules...",
+            "Running self-consistency ensemble 1 of 3...",
+            "Running self-consistency ensemble 2 of 3...",
+            "Running self-consistency ensemble 3 of 3...",
+            "Cross-verifying confidence and vote share...",
+            "Finalizing HTS code and extracting reasoning..."
+        ];
+        let stepIdx = 0;
+        loaderMessage.textContent = loadingSteps[0];
+
+        const loaderInterval = setInterval(() => {
+            stepIdx++;
+            if (stepIdx < loadingSteps.length) {
+                loaderMessage.style.opacity = '0';
+                setTimeout(() => {
+                    loaderMessage.textContent = loadingSteps[stepIdx];
+                    loaderMessage.style.transition = 'opacity 0.3s ease';
+                    loaderMessage.style.opacity = '1';
+                }, 300);
+            } else {
+                loaderMessage.style.opacity = '0';
+                setTimeout(() => {
+                    loaderMessage.textContent = "Almost done... rendering final classification.";
+                    loaderMessage.style.opacity = '1';
+                }, 300);
+            }
+        }, 3000);
+
+        try {
+            const res = await fetch('/api/classify', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ description: desc })
+            });
+            const data = await res.json();
+
+            if (res.ok) {
+                renderResults(data);
+            } else {
+                alert("Error: " + data.detail);
+            }
+        } catch (err) {
+            console.error(err);
+            alert("An error occurred while calling the API.");
+        } finally {
+            clearInterval(loaderInterval);
+            loader.classList.add('hidden');
+            generateBtn.disabled = false;
+        }
+    });
+
+    function renderResults(data) {
+        resultsSection.classList.remove('hidden');
+
+        // HTS Code & Warning
+        document.getElementById('hts-code-display').textContent = data.final_hts_code || "XXXX.XX.XX.XX";
+
+        const warningBox = document.getElementById('escalation-warning');
+        if (data.escalation_needed) {
+            warningBox.classList.remove('hidden');
+        } else {
+            warningBox.classList.add('hidden');
+        }
+
+        // Confidence Grid
+        renderConfidenceGrid(data.element_confidences);
+
+        // Reasoning & Context
+        document.getElementById('reasoning-text').innerText = data.reasoning_steps || "No reasoning provided.";
+        document.getElementById('search-queries').innerHTML = (data.search_queries || []).map(q => `<li>${q}</li>`).join('');
+        document.getElementById('web-context').innerText = data.search_results || "None.";
+        document.getElementById('rag-context').innerText = data.rag_context || "None.";
+
+        // Chatbot Initialization
+        const chatContainer = document.getElementById('escalation-chat-container');
+        const chatMessages = document.getElementById('chat-messages');
+        const chatInput = document.getElementById('chat-input');
+        const sendChatBtn = document.getElementById('send-chat-btn');
+        chatMessages.innerHTML = "";
+
+        const finalCodeContainer = document.getElementById('final-code-container');
+        const reasoningPanelContainer = document.getElementById('reasoning-panel-container');
+
+        if (data.escalation_needed) {
+            chatContainer.classList.remove('hidden');
+            finalCodeContainer.classList.add('hidden');
+            reasoningPanelContainer.classList.add('hidden');
+
+            window.currentEscalationContext = {
+                description: document.getElementById('product-desc').value.trim(),
+                search_results: data.search_results,
+                rag_context: data.rag_context,
+                chat_history: []
+            };
+
+            appendChatMessage("assistant", data.escalation_question || "I need more details to finalize this code.");
+        } else {
+            chatContainer.classList.add('hidden');
+            finalCodeContainer.classList.remove('hidden');
+            reasoningPanelContainer.classList.remove('hidden');
+        }
+
+        // Chat Handlers
+        sendChatBtn.onclick = async () => {
+            const text = chatInput.value.trim();
+            if (!text) return;
+
+            appendChatMessage("user", text);
+            chatInput.value = "";
+            sendChatBtn.disabled = true;
+
+            try {
+                const res = await fetch('/api/escalation', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(window.currentEscalationContext)
+                });
+                const escData = await res.json();
+
+                if (res.ok && escData.success) {
+                    const r = escData.result;
+                    if (r.is_final) {
+                        appendChatMessage("assistant", "Excellent, I have enough confidence now! Updating the final code.");
+                        document.getElementById('hts-code-display').textContent = r.data.final_hts_code;
+                        document.getElementById('escalation-warning').classList.add('hidden');
+                        document.getElementById('chat-input-area').classList.add('hidden');
+
+                        // Show AI reasoning chain
+                        if (r.data.reasoning) {
+                            document.getElementById('reasoning-text').innerText = r.data.reasoning;
+                        }
+
+                        // Re-render confidence grid with human-verified values
+                        if (r.data.element_confidences) {
+                            renderConfidenceGrid(r.data.element_confidences);
+                        }
+
+                        // Output the final HTS code and reasoning, show the confidence grid
+                        document.getElementById('final-code-container').classList.remove('hidden');
+                        document.getElementById('reasoning-panel-container').classList.remove('hidden');
+                        document.getElementById('confidence-grid').classList.remove('hidden');
+
+                        // Collapse the Chat Accordion
+                        const chatAccordionItem = document.getElementById('chat-accordion-item');
+                        if (chatAccordionItem) {
+                            chatAccordionItem.classList.remove('active');
+                            const content = chatAccordionItem.querySelector('.accordion-content');
+                            if (content) content.style.maxHeight = "0";
+                        }
+                    } else {
+                        appendChatMessage("assistant", r.message);
+                    }
+                } else {
+                    alert("Chat error: " + (escData.detail || "Unknown error"));
+                }
+            } catch (err) {
+                console.error(err);
+                alert("Error sending chat message.");
+            } finally {
+                sendChatBtn.disabled = false;
+            }
+        };
+
+        chatInput.onkeypress = (e) => {
+            if (e.key === 'Enter') sendChatBtn.click();
+        }
+    }
+
+    function renderConfidenceGrid(element_confidences) {
+        if (!element_confidences) return;
+
+        const grid = document.getElementById('confidence-grid');
+        grid.innerHTML = '';
+        const order = [
+            { key: 'chapter', label: 'Chapter' },
+            { key: 'heading', label: 'Heading' },
+            { key: 'subheading', label: 'Subheading' },
+            { key: 'additional_subheading', label: 'Additional' },
+            { key: 'statistical_suffix', label: 'Statistical' }
+        ];
+
+        order.forEach(item => {
+            const conf = element_confidences[item.key];
+            if (!conf) return;
+
+            const isLow = conf.score < 0.6;
+            const card = document.createElement('div');
+            card.className = `conf-card ${isLow ? 'low-conf' : ''}`;
+
+            card.innerHTML = `
+                <div class="label">${item.label}</div>
+                <div class="value">${conf.value}</div>
+                <div class="score">${conf.confidence}</div>
+            `;
+            grid.appendChild(card);
+        });
+    }
+
+    function appendChatMessage(role, text) {
+        const chatMessages = document.getElementById('chat-messages');
+        const div = document.createElement('div');
+        div.className = `chat-msg msg-${role}`;
+
+        if (role === 'assistant' && typeof window.marked !== 'undefined') {
+            div.innerHTML = window.marked.parse(text);
+        } else {
+            div.textContent = text;
+        }
+
+        chatMessages.appendChild(div);
+        chatMessages.scrollTop = chatMessages.scrollHeight;
+
+        if (window.currentEscalationContext) {
+            window.currentEscalationContext.chat_history.push({ role, content: text });
+        }
+    }
+});

static/style.css

@@ -0,0 +1,492 @@
+:root {
+  --primary: #059669;
+  --primary-glow: rgba(5, 150, 105, 0.2);
+  --bg-light: #f1f5f9;
+  --glass-bg: rgba(255, 255, 255, 0.7);
+  --glass-border: rgba(255, 255, 255, 0.4);
+  --text-main: #0f172a;
+  --text-muted: #475569;
+  --danger: #e11d48;
+  --warning: #d97706;
+  --card-bg: rgba(255, 255, 255, 0.5);
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: 'Outfit', sans-serif;
+  background-color: var(--bg-light);
+  color: var(--text-main);
+  min-height: 100vh;
+  overflow-x: hidden;
+  position: relative;
+}
+
+/* Dynamic Background Blobs */
+.blob {
+  position: absolute;
+  filter: blur(80px);
+  z-index: -1;
+  opacity: 0.4;
+}
+
+.shape1 {
+  top: -100px;
+  left: -100px;
+  width: 500px;
+  height: 500px;
+  background: radial-gradient(circle, #bae6fd, transparent);
+  animation: float 10s ease-in-out infinite;
+}
+
+.shape2 {
+  bottom: -150px;
+  right: -50px;
+  width: 600px;
+  height: 600px;
+  background: radial-gradient(circle, #ddd6fe, transparent);
+  animation: float 12s ease-in-out infinite reverse;
+}
+
+@keyframes float {
+  0% {
+    transform: translate(0, 0);
+  }
+
+  50% {
+    transform: translate(40px, -60px);
+  }
+
+  100% {
+    transform: translate(0, 0);
+  }
+}
+
+.container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 3rem 1.5rem;
+}
+
+header {
+  text-align: center;
+  margin-bottom: 3.5rem;
+}
+
+header h1 {
+  font-size: 2.8rem;
+  font-weight: 700;
+  margin-bottom: 0.75rem;
+  background: linear-gradient(to right, #059669, #2563eb);
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+  letter-spacing: -0.5px;
+}
+
+header p {
+  color: var(--text-muted);
+  font-size: 1.15rem;
+  max-width: 600px;
+  margin: 0 auto;
+}
+
+.glass-panel {
+  background: var(--glass-bg);
+  backdrop-filter: blur(16px);
+  -webkit-backdrop-filter: blur(16px);
+  border: 1px solid var(--glass-border);
+  border-radius: 24px;
+  padding: 2.5rem;
+  box-shadow: 0 10px 40px rgba(0, 0, 0, 0.05), inset 0 0 0 1px rgba(255, 255, 255, 0.4);
+}
+
+.input-section {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+  margin-bottom: 2.5rem;
+}
+
+textarea {
+  width: 100%;
+  background: rgba(255, 255, 255, 0.8);
+  border: 1px solid rgba(15, 23, 42, 0.1);
+  border-radius: 12px;
+  color: var(--text-main);
+  padding: 1.25rem;
+  font-family: inherit;
+  font-size: 1.05rem;
+  resize: vertical;
+  outline: none;
+  transition: all 0.3s ease;
+  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.02);
+}
+
+textarea:focus {
+  border-color: var(--primary);
+  box-shadow: 0 0 0 4px var(--primary-glow);
+}
+
+.primary-btn {
+  background: linear-gradient(135deg, #059669 0%, #10b981 100%);
+  color: white;
+  border: none;
+  padding: 1.1rem 2.5rem;
+  font-size: 1.1rem;
+  font-weight: 600;
+  border-radius: 12px;
+  cursor: pointer;
+  transition: all 0.3s ease;
+  align-self: flex-end;
+  box-shadow: 0 4px 15px rgba(16, 185, 129, 0.3);
+}
+
+.primary-btn:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 6px 20px rgba(16, 185, 129, 0.4);
+}
+
+.primary-btn:active {
+  transform: translateY(0);
+}
+
+/* Results Section */
+.hidden {
+  display: none !important;
+}
+
+.results-section {
+  display: flex;
+  flex-direction: column;
+  gap: 2.5rem;
+  animation: fadeIn 0.5s ease-out;
+}
+
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(10px);
+  }
+
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.hts-code-display {
+  font-size: 3.5rem;
+  letter-spacing: 5px;
+  text-align: center;
+  font-weight: 800;
+  margin: 1.5rem 0;
+  color: var(--primary);
+  filter: drop-shadow(0 0 1px rgba(5, 150, 105, 0.3));
+}
+
+.warning-box {
+  background: rgba(225, 29, 72, 0.05);
+  border: 1px solid rgba(225, 29, 72, 0.1);
+  border-left: 5px solid var(--danger);
+  padding: 1.25rem;
+  border-radius: 12px;
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  color: #9f1239;
+  margin-bottom: 2rem;
+}
+
+.warning-box svg {
+  width: 28px;
+  height: 28px;
+  flex-shrink: 0;
+}
+
+.confidence-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(170px, 1fr));
+  gap: 1.25rem;
+  margin-top: 2rem;
+}
+
+.conf-card {
+  background: var(--card-bg);
+  padding: 1.5rem;
+  border-radius: 16px;
+  text-align: center;
+  border: 1px solid var(--glass-border);
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.03);
+  transition: transform 0.3s ease;
+}
+
+.conf-card:hover {
+  transform: translateY(-4px);
+}
+
+.conf-card.low-conf {
+  border-color: rgba(225, 29, 72, 0.3);
+  background: rgba(225, 29, 72, 0.03);
+}
+
+.conf-card .label {
+  font-size: 0.85rem;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 1.2px;
+  font-weight: 600;
+  margin-bottom: 0.5rem;
+}
+
+.conf-card .value {
+  font-size: 1.75rem;
+  font-weight: 700;
+  margin: 0.5rem 0;
+  color: var(--text-main);
+}
+
+.conf-card .score {
+  font-size: 0.95rem;
+  font-weight: 600;
+  color: var(--primary);
+}
+
+.conf-card.low-conf .score {
+  color: var(--danger);
+}
+
+/* Accordion */
+.accordion {
+  margin-top: 1rem;
+}
+
+.accordion-item {
+  border: 1px solid var(--glass-border);
+  border-radius: 12px;
+  margin-bottom: 1rem;
+  background: rgba(255, 255, 255, 0.3);
+  overflow: hidden;
+}
+
+.accordion-header {
+  width: 100%;
+  padding: 1.25rem;
+  background: transparent;
+  border: none;
+  font-size: 1.05rem;
+  font-weight: 600;
+  color: var(--text-main);
+  cursor: pointer;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  transition: background 0.3s ease;
+}
+
+.accordion-header:hover {
+  background: rgba(255, 255, 255, 0.4);
+}
+
+.accordion-content {
+  padding: 0 1.25rem;
+  max-height: 0;
+  overflow: hidden;
+  transition: all 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.accordion-item.active .accordion-content {
+  padding: 1.25rem;
+  max-height: 3000px;
+}
+
+.accordion-item.active .arrow {
+  transform: rotate(180deg);
+}
+
+.arrow {
+  transition: transform 0.3s ease;
+  font-size: 0.8rem;
+  opacity: 0.5;
+}
+
+#reasoning-text {
+  line-height: 1.7;
+  color: var(--text-main);
+  font-size: 1.05rem;
+  margin-bottom: 2rem;
+  white-space: pre-wrap;
+}
+
+pre {
+  background: #f8fafc;
+  border: 1px solid #e2e8f0;
+  padding: 1.25rem;
+  border-radius: 8px;
+  overflow-x: auto;
+  font-size: 0.9rem;
+  color: #475569;
+  white-space: pre-wrap;
+  margin-top: 1rem;
+  margin-bottom: 1.5rem;
+  font-family: 'Fira Code', monospace;
+}
+
+h3 {
+  font-size: 1.4rem;
+  color: var(--text-main);
+  margin-bottom: 1.25rem;
+}
+
+h4 {
+  color: var(--text-main);
+  margin-bottom: 0.75rem;
+  font-weight: 600;
+}
+
+/* Loader */
+.loader-container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 5rem 0;
+}
+
+.spinner {
+  width: 60px;
+  height: 60px;
+  border: 5px solid rgba(5, 150, 105, 0.1);
+  border-top-color: var(--primary);
+  border-radius: 50%;
+  animation: spin 1s cubic-bezier(0.5, 0.1, 0.4, 0.9) infinite;
+  margin-bottom: 1.5rem;
+  box-shadow: 0 0 20px rgba(5, 150, 105, 0.1);
+}
+
+@keyframes spin {
+  100% {
+    transform: rotate(360deg);
+  }
+}
+
+.loader-container p {
+  color: var(--text-muted);
+  font-weight: 500;
+  animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+
+  0%,
+  100% {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0.6;
+  }
+}
+
+#search-queries li {
+  margin-bottom: 0.5rem;
+  margin-left: 1.5rem;
+  color: var(--text-muted);
+}
+
+/* Escalation Chat */
+.escalation-chat {
+  margin-top: 2rem;
+  border-top: 1px solid var(--glass-border);
+  padding-top: 1.5rem;
+}
+
+.escalation-chat h3 {
+  font-size: 1.25rem;
+  margin-bottom: 1rem;
+  color: var(--warning);
+}
+
+.chat-messages {
+  max-height: 300px;
+  overflow-y: auto;
+  padding: 1rem;
+  background: rgba(255, 255, 255, 0.4);
+  border-radius: 12px;
+  margin-bottom: 1rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+  border: 1px solid var(--glass-border);
+}
+
+.chat-msg {
+  padding: 0.85rem 1.25rem;
+  border-radius: 16px;
+  max-width: 80%;
+  font-size: 0.95rem;
+  line-height: 1.5;
+  animation: fadeIn 0.3s ease;
+}
+
+.msg-assistant {
+  background: var(--card-bg);
+  border: 1px solid var(--glass-border);
+  color: var(--text-main);
+  align-self: flex-start;
+  border-bottom-left-radius: 4px;
+}
+
+.msg-user {
+  background: var(--primary);
+  color: white;
+  align-self: flex-end;
+  border-bottom-right-radius: 4px;
+  box-shadow: 0 4px 10px rgba(5, 150, 105, 0.2);
+}
+
+.chat-input-area {
+  display: flex;
+  gap: 0.5rem;
+}
+
+.chat-input-area input {
+  flex: 1;
+  background: rgba(255, 255, 255, 0.8);
+  border: 1px solid rgba(15, 23, 42, 0.1);
+  border-radius: 12px;
+  padding: 1rem;
+  font-family: inherit;
+  font-size: 1rem;
+  outline: none;
+  transition: all 0.3s ease;
+}
+
+.chat-input-area input:focus {
+  border-color: var(--primary);
+  box-shadow: 0 0 0 4px var(--primary-glow);
+}
+
+.chat-btn {
+  background: var(--text-main);
+  color: white;
+  border: none;
+  border-radius: 12px;
+  padding: 0 1.5rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.chat-btn:hover {
+  background: #1e293b;
+}
+
+.chat-btn:disabled {
+  background: #cbd5e1;
+  cursor: not-allowed;
+}

test_data.csv

@@ -0,0 +1,2 @@
+desc,label
+sports balls latex,9506620090