Update app.py

app.py

@@ -1,146 +1,194 @@
-# ==============================
-# 🚖 Uber Driver Recommendation System
-# Hugging Face Ready | Single File | Clean Version
-# ==============================
-
+import os
+import faiss
 import numpy as np
-import pandas as pd
 import gradio as gr
-from sklearn.model_selection import train_test_split
-from sklearn.ensemble import RandomForestRegressor
-
-# ------------------------------
-# 1. Generate Synthetic Data
-# ------------------------------
-def generate_data(n=1000):
-    np.random.seed(42)
-    data = pd.DataFrame({
-        "pickup_distance": np.random.uniform(0.5, 10, n),
-        "trip_distance": np.random.uniform(1, 20, n),
-        "fare": np.random.uniform(50, 500, n),
-        "surge": np.random.choice([1, 1.5, 2], n),
-        "rating": np.random.uniform(3, 5, n)
-    })
-    return data
-
-# ------------------------------
-# 2. Feature Engineering
-# ------------------------------
-def feature_engineering(df):
-    df = df.copy()
-    df["earning_per_km"] = df["fare"] / (df["trip_distance"] + 1)
-    df["efficiency"] = (df["fare"] * df["surge"]) / (df["pickup_distance"] + df["trip_distance"])
-    return df
-
-# ------------------------------
-# 3. Train Model (Lightweight)
-# ------------------------------
-def train_model():
-    data = generate_data()
-    data = feature_engineering(data)
-
-    data["reward"] = data["efficiency"]
-
-    X = data.drop("reward", axis=1)
-    y = data["reward"]
-
-    X_train, _, y_train, _ = train_test_split(X, y, test_size=0.2)
-
-    model = RandomForestRegressor(n_estimators=50, random_state=42)
-    model.fit(X_train, y_train)
-
-    return model
-
-model = train_model()
-
-# ------------------------------
-# 4. Generate Ride Options
-# ------------------------------
-def generate_rides(base_pickup, base_trip, base_fare, base_surge):
-    rides = []
-    for _ in range(5):
-        rides.append({
-            "pickup_distance": max(0.5, base_pickup + np.random.uniform(-1, 1)),
-            "trip_distance": max(1, base_trip + np.random.uniform(-2, 2)),
-            "fare": max(50, base_fare + np.random.uniform(-50, 50)),
-            "surge": min(2, max(1, base_surge + np.random.choice([0, 0.5])))
-        })
-    return pd.DataFrame(rides)
-
-# ------------------------------
-# 5. Explainability
-# ------------------------------
-def explain(row):
-    reasons = []
-
-    if row["fare"] > 300:
-        reasons.append("High Fare")
-    if row["pickup_distance"] < 3:
-        reasons.append("Close Pickup")
-    if row["surge"] > 1:
-        reasons.append("Surge Benefit")
-    if row["trip_distance"] > 10:
-        reasons.append("Long Trip")
-
-    return ", ".join(reasons) if reasons else "Balanced Ride"
-
-# ------------------------------
-# 6. Recommendation Engine
-# ------------------------------
-def recommend(pickup, trip, fare, surge):
-    rides = generate_rides(pickup, trip, fare, surge)
-    rides = feature_engineering(rides)
-
-    scores = model.predict(rides)
-    rides["score"] = scores
-
-    rides = rides.sort_values(by="score", ascending=False).head(3)
-
-    # Format Output
-    output = ""
-    for i, row in rides.iterrows():
-        explanation = explain(row)
-
-        output += (
-            f"🚖 Ride Option\n"
-            f"Score: {round(row['score'],2)}\n"
-            f"Fare: ₹{round(row['fare'],2)}\n"
-            f"Pickup Distance: {round(row['pickup_distance'],2)} km\n"
-            f"Trip Distance: {round(row['trip_distance'],2)} km\n"
-            f"Surge: {row['surge']}\n"
-            f"Why: {explanation}\n"
-            f"-----------------------------\n"
-        )
-
-    return output
-
-# ------------------------------
-# 7. Gradio UI (Clean & Minimal)
-# ------------------------------
-with gr.Blocks() as demo:
-    gr.Markdown("## 🚖 Uber Driver Recommendation System")
-    gr.Markdown("Smart ride selection based on AI scoring")
 
-    with gr.Row():
-        pickup = gr.Slider(0.5, 10, value=2, label="Pickup Distance (km)")
-        trip = gr.Slider(1, 20, value=5, label="Trip Distance (km)")
+from sentence_transformers import SentenceTransformer
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from PyPDF2 import PdfReader
+
+# -----------------------------
+# CONFIG
+# -----------------------------
+DATA_PATH = "docs"
+TOP_K = 3
+LLM_MODEL = "google/flan-t5-base"
+
+# -----------------------------
+# LOAD MODELS
+# -----------------------------
+embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
+
+tokenizer = AutoTokenizer.from_pretrained(LLM_MODEL)
+llm_model = AutoModelForSeq2SeqLM.from_pretrained(LLM_MODEL)
+
+# -----------------------------
+# FILE LOADER
+# -----------------------------
+def read_file(path):
+    if path.endswith(".txt") or path.endswith(".md"):
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    elif path.endswith(".pdf"):
+        reader = PdfReader(path)
+        text = ""
+        for page in reader.pages:
+            text += page.extract_text() or ""
+        return text
+    return ""
+
+def load_docs(folder):
+    texts = []
+    if not os.path.exists(folder):
+        return texts
+
+    for file in os.listdir(folder):
+        path = os.path.join(folder, file)
+        try:
+            txt = read_file(path)
+            if txt.strip():
+                texts.append(txt)
+        except:
+            continue
+    return texts
+
+# -----------------------------
+# CHUNKING
+# -----------------------------
+def chunk_text(text, size=300, overlap=50):
+    words = text.split()
+    return [" ".join(words[i:i + size]) for i in range(0, len(words), size - overlap)]
+
+# -----------------------------
+# BUILD VECTOR DB
+# -----------------------------
+def build_index(docs):
+    chunks = []
+    for doc in docs:
+        chunks.extend(chunk_text(doc))
+
+    if not chunks:
+        return None, []
+
+    embeddings = embedding_model.encode(chunks)
+    dim = embeddings.shape[1]
+
+    index = faiss.IndexFlatL2(dim)
+    index.add(np.array(embeddings))
+
+    return index, chunks
+
+# -----------------------------
+# RETRIEVE
+# -----------------------------
+def retrieve(query, index, chunks, k=TOP_K):
+    q_embed = embedding_model.encode([query])
+    D, I = index.search(np.array(q_embed), k)
+    return [chunks[i] for i in I[0]]
+
+# -----------------------------
+# GENERATE ANSWER (WITH MEMORY)
+# -----------------------------
+def generate_answer(query, contexts, history):
+    context = "\n\n".join(contexts)
+
+    history_text = ""
+    for h in history[-6:]:
+        history_text += f"{h['role']}: {h['content']}\n"
+
+    prompt = f"""
+You are an expert AI/ML assistant.
+
+Conversation:
+{history_text}
+
+Context:
+{context}
+
+Question:
+{query}
+
+Answer clearly:
+"""
+
+    inputs = tokenizer(prompt, return_tensors="pt", truncation=True)
+    outputs = llm_model.generate(**inputs, max_new_tokens=200)
+
+    return tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+# -----------------------------
+# TOOL RECOMMENDER (AGENT MODE)
+# -----------------------------
+def tool_recommender(query):
+    prompt = f"""
+You are an AI architect.
+
+Suggest best AI/ML tools for:
+
+{query}
+
+Give:
+- Tools
+- Why
+- Use cases
+"""
+
+    inputs = tokenizer(prompt, return_tensors="pt", truncation=True)
+    outputs = llm_model.generate(**inputs, max_new_tokens=150)
+
+    return tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+# -----------------------------
+# INIT
+# -----------------------------
+docs = load_docs(DATA_PATH)
+index, chunks = build_index(docs)
+
+# -----------------------------
+# MAIN CHAT PIPELINE
+# -----------------------------
+def rag_chat(query, history):
+    history = history or []
+
+    if index is None:
+        history.append({"role": "user", "content": query})
+        history.append({"role": "assistant", "content": "No documents found"})
+        return history
+
+    retrieved = retrieve(query, index, chunks)
+
+    # Agent decision
+    if "recommend" in query.lower() or "best tool" in query.lower():
+        answer = tool_recommender(query)
+    else:
+        answer = generate_answer(query, retrieved, history)
 
-    with gr.Row():
-        fare = gr.Slider(50, 500, value=200, label="Fare (₹)")
-        surge = gr.Slider(1, 2, value=1, step=0.5, label="Surge")
+    history.append({"role": "user", "content": query})
+    history.append({"role": "assistant", "content": answer})
 
-    btn = gr.Button("Get Recommendation")
+    return history
+
+# -----------------------------
+# UI HANDLER
+# -----------------------------
+def respond(message, chat_history):
+    chat_history = chat_history or []
+    updated_history = rag_chat(message, chat_history)
+    return "", updated_history
+
+# -----------------------------
+# UI (CHATGPT STYLE)
+# -----------------------------
+with gr.Blocks() as demo:
+    gr.Markdown("## AI/ML Conversational RAG + Tool Recommender")
 
-    output = gr.Textbox(label="Top Ride Recommendations", lines=15)
+    chatbot = gr.Chatbot(type="messages")
+    msg = gr.Textbox(placeholder="Ask about AI tools, ML, companies...")
 
-    btn.click(
-        fn=recommend,
-        inputs=[pickup, trip, fare, surge],
-        outputs=output
-    )
+    msg.submit(respond, [msg, chatbot], [msg, chatbot])
 
-# ------------------------------
-# 8. Launch
-# ------------------------------
+# -----------------------------
+# RUN
+# -----------------------------
 if __name__ == "__main__":
     demo.launch()