Update app.py

app.py

@@ -1,97 +1,132 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
-from fastapi import FastAPI, HTTPException
-import os
+from datasets import load_dataset
+import pandas as pd
 
-# Initialize clients
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-app = FastAPI()
+# --- Load the Indian Recipes Dataset ---
+dataset = load_dataset("nf-analyst/indian_recipe")
+recipes = dataset["train"].to_pandas()
 
-# Configuration - Change this default key for production!
-DEFAULT_SYSTEM_MESSAGE = "You are a chatbot that helps in mood detection and recommends recipes"
-API_TOKEN = "default-secret-key"  # 👈 Change this for production deployments
+# Preprocess: Combine relevant fields for search
+recipes["search_text"] = (
+    recipes["name"] + " " + 
+    recipes["ingredients"].apply(lambda x: ' '.join(x)) + " " + 
+    recipes["instructions"].apply(lambda x: ' '.join(x))
+)
 
-def generate_response(
-    message: str,
-    history: list[tuple[str, str]] = None,
-    system_message: str = DEFAULT_SYSTEM_MESSAGE,
-    max_tokens: int = 512,
-    temperature: float = 0.7,
-    top_p: float = 0.95
-):
-    """Core response generation logic"""
-    messages = [{"role": "system", "content": system_message}]
+# --- Enhanced Search Function (Semantic + Keyword) ---
+from sentence_transformers import SentenceTransformer
+import faiss
+import numpy as np
 
-    if history:
-        for user_msg, assistant_msg in history:
-            if user_msg:
-                messages.append({"role": "user", "content": user_msg})
-            if assistant_msg:
-                messages.append({"role": "assistant", "content": assistant_msg})
+# Initialize semantic search
+model = SentenceTransformer("all-MiniLM-L6-v2")
+embeddings = model.encode(recipes["search_text"].tolist())
+index = faiss.IndexFlatL2(embeddings.shape[1])
+index.add(embeddings)
 
-    messages.append({"role": "user", "content": message})
+def search_recipes(query, top_k=3):
+    # Semantic search first
+    query_embedding = model.encode([query])
+    distances, indices = index.search(query_embedding, top_k)
+    
+    # Keyword verification
+    results = []
+    for i in indices[0]:
+        recipe = recipes.iloc[i]
+        if query.lower() in recipe["search_text"].lower():
+            results.append({
+                "name": recipe["name"],
+                "ingredients": recipe["ingredients"],
+                "instructions": recipe["instructions"],
+                "cook_time": recipe["cook_time"],
+                "diet": recipe["diet"]
+            })
+    return results if results else None
 
-    try:
-        response = ""
-        for chunk in client.chat_completion(
-            messages,
-            max_tokens=max_tokens,
-            stream=True,
-            temperature=temperature,
-            top_p=top_p,
-        ):
-            response += chunk.choices[0].delta.content or ""
-        return response
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+# --- Modified Respond Function ---
+client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
-# FastAPI Endpoints
-@app.post("/api/chat")
-async def api_chat_endpoint(
-    message: str,
-    api_token: str,
-    system_message: str = DEFAULT_SYSTEM_MESSAGE,
-    max_tokens: int = 512,
-    temperature: float = 0.7,
-    top_p: float = 0.95
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
 ):
-    """External API endpoint"""
-    if api_token != API_TOKEN:
-        raise HTTPException(status_code=403, detail="Invalid API token")
+    # Search our dataset first
+    found_recipes = search_recipes(message)
+    
+    if not found_recipes:
+        yield "No matching Indian recipes found. Try terms like 'butter chicken', 'biryani', or 'dal tadka'."
+        return
+    
+    # Format recipes as strict context
+    recipe_context = "\n\n".join([
+        f"Recipe {i+1}: {r['name']} ({r['diet']}, {r['cook_time']})\n"
+        f"Ingredients: {', '.join(r['ingredients'])}\n"
+        f"Method: {' '.join(r['instructions'][:3])}..."
+        for i, r in enumerate(found_recipes)
+    ])
     
-    return {
-        "response": generate_response(
-            message=message,
-            system_message=system_message,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            top_p=top_p
-        )
-    }
+    # Force the LLM to only use these recipes
+    strict_system_prompt = f"""You are an Indian food expert. ONLY recommend from these verified recipes.
+    NEVER invent recipes. If asked for variations, suggest only minor modifications to these:
+    
+    {recipe_context}
+    
+    Respond in this format:
+    1. First recommend recipe names matching the query
+    2. If asked for details, provide ONLY from the recipes above
+    3. For substitutions, suggest similar ingredients from these recipes
+    """
+    
+    messages = [{"role": "system", "content": strict_system_prompt}]
+    
+    # Add conversation history
+    for user_msg, bot_msg in history:
+        if user_msg:
+            messages.append({"role": "user", "content": user_msg})
+        if bot_msg:
+            messages.append({"role": "assistant", "content": bot_msg})
+    
+    messages.append({"role": "user", "content": message})
 
-# Gradio Interface - Now includes API key validation
-def chat_ui(message: str, history: list[tuple[str, str]], api_key: str):
-    if api_key != API_TOKEN:
-        return "🔒 Error: Invalid API Key"
-    return generate_response(message, history)
+    # Generate response
+    response = ""
+    for chunk in client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        token = chunk.choices[0].delta.content
+        response += token
+        yield response
 
-chat_interface = gr.ChatInterface(
-    fn=chat_ui,
+# --- Gradio Interface with Indian Food Examples ---
+demo = gr.ChatInterface(
+    respond,
     additional_inputs=[
-        gr.Textbox(API_TOKEN, label="API Key", type="password"),
-        gr.Textbox(DEFAULT_SYSTEM_MESSAGE, label="System message"),
-        gr.Slider(1, 2048, 512, step=1, label="Max new tokens"),
-        gr.Slider(0.1, 4.0, 0.7, step=0.1, label="Temperature"),
-        gr.Slider(0.1, 1.0, 0.95, step=0.05, label="Top-p sampling"),
+        gr.Textbox(
+            value="You are an expert on Indian cuisine.",
+            label="System message"
+        ),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p"),
     ],
-    title="🍳 Mood-Based Recipe Assistant",
-    description=f"API Key: {API_TOKEN}"  # Shows default key for testing
+    examples=[
+        "Vegetarian North Indian dinner",
+        "Quick chicken curry",
+        "Traditional South Indian breakfast",
+        "Gluten-free Indian dessert"
+    ],
+    title="🍛 Authentic Indian Recipe Assistant",
+    description="Get recommendations ONLY from verified Indian recipes"
 )
 
-# Mount Gradio to FastAPI
-chat_interface.mount_to(app, path="/")
-
 if __name__ == "__main__":
-    import uvicorn
-    print(f"🔑 Default API Token: {API_TOKEN}")  # Visible in console
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    demo.launch()