Upload folder using huggingface_hub

Dockerfile

@@ -1,20 +1,16 @@
-FROM python:3.13.5-slim
+# Use a minimal base image with Python 3.9 installed
+FROM python:3.9-slim
 
+# Set the working directory inside the container to /app
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
+# Copy all files from the current directory on the host to the container's /app directory
+COPY . .
 
+# Install Python dependencies listed in requirements.txt
 RUN pip3 install -r requirements.txt
 
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Define the command to run the Streamlit app on port 8501 and make it accessible externally
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0", "--server.enableXsrfProtection=false"]
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# NOTE: Disable XSRF protection for easier external access in order to make batch predictions

app.py

@@ -0,0 +1,7 @@
+import streamlit as st
+
+st.title("Chat Input Demo")
+
+if user_input := st.chat_input("Ask something..."):
+    st.write("HERE")
+    st.write(f"You typed: {user_input}")

chat_agent.py

@@ -0,0 +1,134 @@
+
+# import the packages required for API execution
+import json
+import os
+import pandas as pd
+import sqlite3
+
+from langchain.agents import create_sql_agent, initialize_agent # Added initialize_agent
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain.agents.agent_types import AgentType
+from langchain.sql_database import SQLDatabase
+from langchain.agents.agent_toolkits import SQLDatabaseToolkit
+from langchain import hub
+from langchain.agents import load_tools
+from langchain.agents import Tool
+from pydantic import BaseModel, Field, ValidationError
+from typing import List, Optional, Dict
+
+import warnings
+# warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore")
+
+# Groq API key added to the groq portal and google collab
+# accessing the groq API generated
+from google.colab import userdata
+#os.environ['GROQ_API_KEY'] = userdata.get('GROQ_API_KEY')#Complete the code by calling the Groq API key
+
+#from google.colab import userdata
+from langchain_groq import ChatGroq  # Import Groq LLM
+
+# Get the API key from Colab secrets
+#groq_api_key = userdata.get('GROQ_API_KEY') #Complete the code by calling the API key
+groq_api_key = os.environ['GROQ_API_KEY']
+#userdata.get('GROQ_API_KEY') #Complete the code by calling the API key
+
+# let us create an LLM instances using low temp.
+# model temp should very between (0-1.0) lets take low temp as 0.2 (deterministic)
+
+# using llama-3.1-8b-instant for long conversations and clear, accurate summaries for dialogues.
+
+# Low creativity (deterministic) LLM
+
+llm = ChatGroq(
+    model="meta-llama/llama-4-scout-17b-16e-instruct", #Call the Groq model
+    temperature=0, #Complete the code by providing low temperature
+    max_tokens=None,
+    timeout=None,
+    max_retries=3,
+    groq_api_key=groq_api_key
+)
+
+# defining the schema which shall be used as part of system prompt
+# Human-readable schema description (for LLM prompt only)
+ORDERS_SCHEMA = """
+Table: orders_new
+
+Columns:
+- order_id (TEXT)
+- cust_id (TEXT)
+- order_time (TEXT)
+- order_status_std (TEXT)
+- payment_status_std (TEXT)
+- item_in_order (TEXT)
+- preparing_eta (TEXT)
+- prepared_time (TEXT)
+- delivery_eta (TEXT)
+- delivery_time (TEXT)
+"""
+system_message = f"""
+You are an expert & secure SQLite assistant specialized in answering questions using the customer_orders.db SQLite database.
+
+{ORDERS_SCHEMA}
+
+Security Rules:
+1. You are a read-only, helpful database assistant.
+   If the user mentions 'hacking' or 'unauthorized access', immediately refuse the request.
+2. NEVER generate DROP, DELETE, UPDATE, INSERT, ALTER, or CREATE statements.
+   Your sole purpose is read-only querying.
+3. Do not provide the full table schema, definition, or a list of all tables.
+   Only query tables relevant to the user's specific request.
+4. Only generate safe, read-only SQL queries (SELECT).
+5. Only run query when order id is given otherwise refuse gracefully.
+"""
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+db_path = os.path.join(current_dir, "customer_orders.db")
+db = SQLDatabase.from_uri(f"sqlite:///{db_path}")
+
+# upload the customer database and configure for sql access.
+#db = SQLDatabase.from_uri("sqlite:///customer_orders.db")
+
+#Initialize the toolkit with customer database and the LLM
+toolkit = SQLDatabaseToolkit(db=db, llm=llm)
+
+#Create the SQL agent with the system message
+db_agent = create_sql_agent(
+    llm=llm,
+    toolkit=toolkit,
+    verbose=False,
+    system_message=SystemMessage(system_message)
+)
+
+# Define Order Query Tool
+# Create a function that the tool will call
+def fetch_order_info(query: str) -> str:
+    """Fetches raw order details from the database using the SQL Agent."""
+    try:
+        # We pass the user's query directly to your pre-configured db_agent
+        response = db_agent.invoke(query)
+        return response["output"]
+    except Exception as e:
+        return f"Error retrieving data: {str(e)}"
+
+# Define the Tool
+order_query_tool = Tool(
+    name="Order_Query_Tool",
+    func=fetch_order_info,
+    description="Useful for when you need to answer questions about order status, delivery times, or specific order details."
+)
+
+def polish_response(raw_data: str) -> str:
+    """Refines raw data into a polite, formal, and customer-friendly response."""
+    refinement_prompt = [
+        SystemMessage(content="You are a polite customer service representative. Take the provided raw data and turn it into a helpful, professional, and warm response. Do not change the facts."),
+        HumanMessage(content=f"Raw Data: {raw_data}")
+    ]
+    response = llm.invoke(refinement_prompt)
+    return response.content
+
+answer_tool = Tool(
+    name="Answer_Polishing_Tool",
+    func=polish_response,
+    description="Useful for refining a technical or raw database response into a polite and formal customer message."
+)

chatbot_logic.py

@@ -0,0 +1,144 @@
+import os
+import re
+import json
+from typing import Optional
+import pandas as pd
+from sqlalchemy import engine
+from langchain_groq import ChatGroq
+from langchain_core.messages import Message, SysMessage
+from langchain.utilities import SQLDatabase
+from langchain.agents import sqlagent
+from langchain.memory import Buffer
+
+GROQ_API = os.environ.get("GROQ_API")
+if not GROQ_API:
+    raise ValueError("Add GROQ_API as an environment variable.")
+
+model_name = "llama-3.3-70b-versatile"
+llm = ChatGroq(
+    model=model_name,
+    temperature=0.0,
+    max_tokens=512,
+    api_key=GROQ_API
+)
+
+
+db_path = "customer_orders.db"  
+
+
+db = SQLDatabase.from_uri(f"sqlite:///{db_path}")
+
+
+sql_agent = sqlagent(
+    llm=llm,
+    db=db,
+    verbose=False  
+)
+
+
+
+memory = Buffer(
+    memory_key="chat_history",
+    return_messages=True
+)
+
+
+
+def findorder(text: str) -> Optional[str]:
+    """Extract order id pattern (e.g. O12345) from user text."""
+    m = re.search(r"\b([Oo]\d{3,})\b", text)
+    return m.group(1) if m else None
+
+
+def llmgenerate(messages):
+    """Call LLM safely, fallback if needed."""
+    try:
+        res = llm.generate([messages])
+        text = res.generations[0][0].text
+    except Exception:
+        resp = llm.invoke(messages)
+        try:
+            text = resp.content
+        except Exception:
+            text = str(resp)
+    return text.strip()
+
+
+def orderqtool(orderid: str) -> str:
+    """Fetch order data using SQL agent (or fallback to raw DB)."""
+    if not orderid:
+        return "ERROR: No orderid provided."
+    try:
+        query = f"SELECT * FROM orders WHERE orderid = '{orderid}';"
+        raw_response = sql_agent.run(query)
+        raw_text = str(raw_response)
+    except Exception as e:
+        try:
+            rows = db.run(f"SELECT * FROM orders WHERE orderid = '{orderid}'")
+            raw_text = json.dumps(rows, default=str, indent=2)
+        except Exception as e2:
+            raw_text = f"ERROR fetching order {orderid}: {e} / fallback: {e2}"
+    return raw_text
+
+
+def answer_tool(raw_order_context: str, user_question: str) -> str:
+    """convert the raw order information into a polite."""
+    system_prompt = SysMessage(
+        content=(
+            "You are a polite"
+            "don't reveal sensitive details"
+        )
+    )
+
+    hprompt = Message(
+        content=(
+            f"Order context (raw):\n{raw_order_context}\n\n"
+            f"Customer question:\n{user_question}\n\n"
+            "Instructions:\n"
+            "1) Answer in 2-4 sentences.\n"
+            "2) If not found, ask politely for order id.\n"
+        
+        )
+    )
+
+    return llmgenerate([system_prompt, hprompt])
+
+
+
+def chatagent(uinput: str) -> dict:
+    """
+    Main agent entrypoint called by app.py
+    Returns a dict with keys: uinput, orderid, mycontext, answer
+    """
+    result = {
+        "uinput": uinput,
+        "orderid": None,
+        "mycontext": None,
+        "answer": None,
+    }
+
+    chat_history = memory.load_memory_variables({}).get("chat_history", [])
+
+  
+    orderid = findorder(uinput)
+    result["orderid"] = orderid
+
+    if orderid:
+        mycontext = orderqtool(orderid)
+        result["mycontext"] = mycontext
+        answer = answer_tool(mycontext, uinput)
+        result["answer"] = answer
+    else:
+    
+        guardrail = SysMessage(
+            content=(
+                "You are a food delivery assistant that helps users while strictly avoiding requests for sensitive information. "
+            )
+        )
+        answer = llmgenerate([guardrail, *chat_history, Message(content=uinput)])
+        result["answer"] = answer
+
+ 
+    memory.save_context({"input": uinput}, {"output": result["answer"]})
+
+    return result

requirements.txt

@@ -1,3 +1,8 @@
-altair
-pandas
-streamlit
+langchain==0.2.14
+langchain-groq==0.1.9
+langchain-community==0.2.12
+langchain-experimental==0.0.62
+langchainhub==0.1.20
+numpy==1.26
+pandas==2.2.2
+streamlit==1.43.2