initial commit

backend/check.py

@@ -0,0 +1,3 @@
+import torch
+print(torch.cuda.is_available())
+print(torch.cuda.get_device_name(0))

backend/main.py

@@ -0,0 +1,543 @@
+# from fastapi import FastAPI, HTTPException, Request
+# from fastapi.responses import HTMLResponse, JSONResponse
+# from fastapi.templating import Jinja2Templates
+# from fastapi.middleware.cors import CORSMiddleware
+# from pydantic import BaseModel, Field
+# import os
+# from dotenv import load_dotenv
+# import openai
+# from typing import Optional, List
+# import logging
+
+# # Configure logging
+# logging.basicConfig(level=logging.INFO)
+# logger = logging.getLogger(__name__)
+
+# # Load environment variables
+# load_dotenv()
+
+# # Initialize FastAPI app
+# app = FastAPI(title="AI Recipe Assistant")
+
+# # Add CORS middleware
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# # Setup templates
+# templates = Jinja2Templates(directory="templates")
+
+# # Configure OpenAI
+# # openai.api_key = os.getenv("OPENAI_API_KEY")
+# # if not openai.api_key:
+# #     raise ValueError("OPENAI_API_KEY environment variable is not set")
+
+# class RecipeRequest(BaseModel):
+#     query: str = Field(..., min_length=1, description="The recipe to generate")
+#     diet_preference: Optional[str] = Field(None, description="Dietary preference (e.g., vegetarian, vegan)")
+#     cuisine_type: Optional[str] = Field(None, description="Type of cuisine (e.g., Italian, Mexican)")
+
+#     class Config:
+#         schema_extra = {
+#             "example": {
+#                 "query": "chocolate chip cookies",
+#                 "diet_preference": "vegetarian",
+#                 "cuisine_type": "italian"
+#             }
+#         }
+
+# class LearningResource(BaseModel):
+#     title: str
+#     url: str
+#     type: str
+
+# class RecipeResponse(BaseModel):
+#     recipe: str
+#     image_url: str
+#     learning_resources: List[LearningResource]
+
+# # def generate_recipe(query: str, diet_preference: Optional[str] = None, cuisine_type: Optional[str] = None) -> dict:
+# #     logger.info(f"Generating recipe for query: {query}, diet: {diet_preference}, cuisine: {cuisine_type}")
+    
+# #     if not query:
+# #         raise HTTPException(status_code=400, detail="Recipe query is required")
+
+# #     # Create a detailed prompt for the recipe
+# #     prompt = f"""Create a detailed recipe for {query}"""
+# #     if diet_preference:
+# #         prompt += f" that is {diet_preference}"
+# #     if cuisine_type:
+# #         prompt += f" in {cuisine_type} style"
+    
+# #     prompt += """\n\nFormat the recipe in markdown with the following sections:
+# #     1. Brief Description
+# #     2. Ingredients (as a bulleted list)
+# #     3. Instructions (as numbered steps)
+# #     4. Tips (as a bulleted list)
+# #     5. Nutritional Information (as a bulleted list)
+    
+# #     Use markdown formatting like:
+# #     - Headers (###)
+# #     - Bold text (**)
+# #     - Lists (- and 1.)
+# #     - Sections (>)
+# #     """
+
+# #     try:
+# #         logger.info(f"Sending prompt to OpenAI: {prompt}")
+        
+# #         # Generate recipe text
+# #         completion = openai.chat.completions.create(
+# #             model="gpt-3.5-turbo",
+# #             messages=[
+# #                 {"role": "system", "content": "You are a professional chef who provides detailed recipes with ingredients, instructions, nutritional information, and cooking tips. Format your responses in markdown."},
+# #                 {"role": "user", "content": prompt}
+# #             ],
+# #             temperature=0.7
+# #         )
+# #         recipe_text = completion.choices[0].message.content
+# #         logger.info("Successfully generated recipe text")
+
+# #         # Generate recipe image
+# #         logger.info("Generating recipe image")
+# #         image_response = openai.images.generate(
+# #             model="dall-e-3",
+# #             prompt=f"Professional food photography of {query}, appetizing, high-quality, restaurant style",
+# #             n=1,
+# #             size="1024x1024"
+# #         )
+# #         image_url = image_response.data[0].url
+# #         logger.info("Successfully generated recipe image")
+
+# #         # Get learning resources
+# #         learning_resources = get_learning_resources(query)
+# #         logger.info("Successfully generated learning resources")
+
+# #         response_data = {
+# #             "recipe": recipe_text,
+# #             "image_url": image_url,
+# #             "learning_resources": learning_resources
+# #         }
+        
+# #         return response_data
+# #     except Exception as e:
+# #         logger.error(f"Error generating recipe: {str(e)}")
+# #         raise HTTPException(status_code=500, detail=str(e))
+# def generate_recipe(query: str, diet_preference: Optional[str] = None, cuisine_type: Optional[str] = None) -> dict:
+#     logger.info(f"Generating mock recipe for query: {query}, diet: {diet_preference}, cuisine: {cuisine_type}")
+
+#     mock_recipe = f"""
+#     ### {query.title()} Recipe
+
+#     > **A quick and easy mock recipe!**
+
+#     #### Ingredients
+#     - 1 cup flour
+#     - 2 eggs
+#     - 1/2 cup milk
+#     - Salt to taste
+
+#     #### Instructions
+#     1. Mix all ingredients.
+#     2. Cook on medium heat.
+#     3. Serve hot.
+
+#     #### Tips
+#     - Use fresh ingredients.
+#     - Adjust salt as per taste.
+
+#     #### Nutritional Info
+#     - Calories: ~200
+#     - Protein: 5g
+#     - Carbs: 30g
+#     """
+
+#     mock_image_url = "https://via.placeholder.com/600x400.png?text=Recipe+Image"
+
+#     mock_learning_resources = [
+#         {
+#             "title": "Mock Cooking Basics",
+#             "url": "https://example.com/mock-cooking",
+#             "type": "video"
+#         },
+#         {
+#             "title": "Mock Recipe Tips",
+#             "url": "https://example.com/mock-tips",
+#             "type": "article"
+#         }
+#     ]
+
+#     return {
+#         "recipe": mock_recipe,
+#         "image_url": mock_image_url,
+#         "learning_resources": mock_learning_resources
+#     }
+
+# def get_learning_resources(recipe_name: str) -> list:
+#     return [
+#         {
+#             "title": f"Master the Art of {recipe_name}",
+#             "url": f"https://cooking-school.example.com/learn/{recipe_name.lower().replace(' ', '-')}",
+#             "type": "video"
+#         },
+#         {
+#             "title": f"Tips and Tricks for Perfect {recipe_name}",
+#             "url": f"https://recipes.example.com/tips/{recipe_name.lower().replace(' ', '-')}",
+#             "type": "article"
+#         }
+#     ]
+
+# @app.post("/recipe", response_model=RecipeResponse)
+# async def get_recipe(request: RecipeRequest):
+#     logger.info(f"Received recipe request: {request}")
+#     try:
+#         result = generate_recipe(request.query, request.diet_preference, request.cuisine_type)
+#         logger.info("Successfully generated recipe response")
+#         return result
+#     except Exception as e:
+#         logger.error(f"Error processing recipe request: {str(e)}")
+#         return JSONResponse(
+#             status_code=500,
+#             content={"detail": str(e)}
+#         )
+
+# @app.get("/", response_class=HTMLResponse)
+# async def root(request: Request):
+#     return templates.TemplateResponse("index.html", {"request": request})
+
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=8080)
+# import os
+# import requests
+# from fastapi import FastAPI, Request, HTTPException
+# from fastapi.responses import JSONResponse, HTMLResponse
+# from fastapi.staticfiles import StaticFiles
+# from fastapi.templating import Jinja2Templates
+# from pydantic import BaseModel
+# from typing import Optional
+# from dotenv import load_dotenv
+
+# # Load environment variables
+# load_dotenv()
+
+# app = FastAPI()
+
+# # Setup static + templates
+# os.makedirs("static", exist_ok=True)
+# os.makedirs("templates", exist_ok=True)
+
+# app.mount("/static", StaticFiles(directory="static"), name="static")
+# templates = Jinja2Templates(directory="templates")
+
+# # Hugging Face config
+# TEXT_MODEL = "facebook/bart-large-cnn"
+# HF_API_KEY = os.getenv("HUGGINGFACE_API_KEY")
+
+# class RecipeRequest(BaseModel):
+#     ingredients: str
+#     diet: Optional[str] = None
+#     cuisine: Optional[str] = None
+
+# @app.get("/", response_class=HTMLResponse)
+# async def home(request: Request):
+#     return templates.TemplateResponse("index.html", {"request": request})
+
+# @app.post("/api/generate-recipe")
+# async def generate_recipe(request: RecipeRequest):
+#     try:
+#         # 👨‍🍳 Smart Prompt
+#         prompt = f"""
+#         You are a professional chef and recipe writer.
+#         Create a full, detailed cooking recipe using the following ingredients: {request.ingredients}.
+#         {f"Make sure it is suitable for a {request.diet} diet." if request.diet else ""}
+#         {f"The recipe should follow {request.cuisine} cuisine style." if request.cuisine else ""}
+
+#         Format the response in markdown with the following sections:
+#         ### Title
+#         ### Description
+#         ### Ingredients (as a bulleted list)
+#         ### Instructions (as numbered steps)
+#         ### Tips
+#         ### Nutritional Information (if possible)
+
+#         Be friendly and helpful in tone.
+#         """
+
+#         # Debug logs
+#         print("📤 Prompt Sent:", prompt)
+#         print("🧠 Model:", TEXT_MODEL)
+
+#         headers = {"Authorization": f"Bearer {HF_API_KEY}"}
+#         payload = {
+#             "inputs": prompt,
+#             "parameters": {
+#                 "max_new_tokens": 250,
+#                 "temperature": 0.8,
+#                 "do_sample": True
+#             }
+#         }
+
+#         # Send to Hugging Face
+#         response = requests.post(
+#             f"https://api-inference.huggingface.co/models/{TEXT_MODEL}",
+#             headers=headers,
+#             json=payload,
+#             timeout=30
+#         )
+
+#         # Try JSON parse or show raw text
+#         try:
+#             result = response.json()
+#         except Exception as e:
+#             print("❌ Could not parse JSON. Raw response:")
+#             print(response.text)
+#             raise HTTPException(status_code=500, detail="Invalid response from Hugging Face API")
+
+#         print("✅ HF JSON Response:", result)
+
+#         # Handle errors or loading message
+#         if "error" in result:
+#             raise HTTPException(status_code=503, detail=result["error"])
+#         if isinstance(result, dict) and "generated_text" in result:
+#             generated = result["generated_text"]
+#         elif isinstance(result, list) and "generated_text" in result[0]:
+#             generated = result[0]["generated_text"]
+#         else:
+#             raise HTTPException(status_code=500, detail="No recipe generated by the model.")
+
+#         return {
+#             "recipe": generated.strip(),
+#             "image_url": "/static/placeholder.jpg"
+#         }
+
+#     except Exception as e:
+#         print(f"🔥 Error: {str(e)}")
+#         raise HTTPException(status_code=500, detail=str(e))
+
+
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)
+
+#uvicorn main:app --reload
+import os
+import shutil
+from fastapi import FastAPI, Request, UploadFile, File, Form
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.middleware.cors import CORSMiddleware
+from langchain.chains import RetrievalQA
+from langchain_community.document_loaders import TextLoader
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain.prompts import PromptTemplate
+from langchain_community.llms import HuggingFacePipeline
+from transformers import pipeline
+from dotenv import load_dotenv
+from PyPDF2 import PdfReader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from typing import Optional
+import torch
+
+load_dotenv()
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+templates = Jinja2Templates(directory="frontend/templates")
+app.mount("/static", StaticFiles(directory="frontend/static"), name="static")
+
+# ========== Model & LLM Setup ==========
+device = 0 if torch.cuda.is_available() else -1
+print(f"🔥 Using device: {'GPU' if device==0 else 'CPU'}")
+
+llm_pipeline = pipeline(
+    "text-generation",
+    model="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+    max_new_tokens=512,
+    temperature=0.7,
+    device=device
+)
+
+llm = HuggingFacePipeline(pipeline=llm_pipeline)
+
+DB_PATH = "vector_store"
+EMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+embedding = HuggingFaceEmbeddings(model_name=EMBED_MODEL)
+
+# ========== Prompt Templates ==========
+non_rag_prompt = """
+You are an expert Indian home chef and AI assistant.  
+Generate a single, detailed, easy-to-follow recipe based only on the query.  
+Output must be in **Markdown** format with clear sections:
+- Ingredients
+- Method
+- Nutritional Info
+- Cooking Tips
+
+Be friendly and professional. Stop after the recipe.
+
+Query: {query}
+"""
+
+rag_prompt_template = PromptTemplate(
+    input_variables=["context", "question"],
+    template="""
+You are an expert Indian home chef and AI assistant.
+
+You are given some cooking knowledge from the user's personal recipe notes in <context>.
+Use only the recipes from <context> that match the user's question.
+
+STRICTLY FOLLOW MARKDOWN FORMAT.
+
+✅ If the recipe exists in <context>, use it.
+✅ If it needs improvement, create an improved version.
+✅ If it does not exist, create a new one.
+❌ DO NOT include unrelated recipes.
+
+Always include: Ingredients, Method, Nutritional Info, Cooking Tips.
+
+<context>
+{context}
+</context>
+
+<user_question>
+{question}
+</user_question>
+
+<response>
+"""
+)
+
+# ========== Helper Functions ==========
+def extract_non_rag_output(full_text: str) -> str:
+    marker = "Ingredients:"
+    idx = full_text.find(marker)
+    return full_text[idx:].strip() if idx != -1 else full_text.strip()
+
+def extract_rag_output(full_text: str) -> str:
+    marker = "Generate a recipe for:"
+    idx = full_text.find(marker)
+    if idx != -1:
+        return full_text[idx:].strip()
+    marker2 = "Ingredients:"
+    idx2 = full_text.find(marker2)
+    return full_text[idx2:].strip() if idx2 != -1 else full_text.strip()
+
+# ========== Routes ==========
+@app.get("/", response_class=HTMLResponse)
+async def serve_home(request: Request):
+    print("✅ Serving index.html")
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.post("/upload")
+async def upload_recipe_file(file: UploadFile = File(...)):
+    if file.filename.endswith(".txt") or file.filename.endswith(".pdf"):
+        save_path = f"uploaded_files/{file.filename}"
+        os.makedirs("uploaded_files", exist_ok=True)
+        with open(save_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        loader = TextLoader(save_path)
+        documents = loader.load()
+
+        db = FAISS.from_documents(documents, embedding)
+        db.save_local(DB_PATH)
+
+        return {"message": "File uploaded and processed successfully."}
+    else:
+        return JSONResponse(status_code=400, content={"error": "Only .txt or .pdf files allowed."})
+
+@app.post("/api/generate-recipe")  # NON-RAG
+async def generate_recipe(
+    ingredients: str = Form(...),
+    diet: Optional[str] = Form("Any"),
+    cuisine: Optional[str] = Form("Any")
+):
+    try:
+        query = f"Give me a recipe using these ingredients: {ingredients}. Diet: {diet}, Cuisine: {cuisine}."
+        response = llm.invoke(non_rag_prompt.format(query=query))
+        cleaned_response = extract_non_rag_output(response)
+
+        return {
+            "recipe": cleaned_response,
+            "image_url": "/static/placeholder.jpg"
+        }
+
+    except Exception as e:
+        print("❌ Non-RAG failed:", e)
+        return JSONResponse(status_code=500, content={"detail": "Internal Server Error"})
+
+@app.post("/api/rag-recipe")  # RAG
+async def rag_recipe(
+    ingredients: str = Form(...),
+    diet: Optional[str] = Form("Any"),
+    cuisine: Optional[str] = Form("Any"),
+    file: Optional[UploadFile] = File(None)
+):
+    try:
+        query = f"Generate a recipe for: {ingredients}. Diet: {diet}. Cuisine style: {cuisine}."
+
+        # Check if we have a file upload or need to use existing DB
+        if file:
+            extracted_text = ""
+            if file.content_type == "application/pdf":
+                pdf = PdfReader(file.file)
+                extracted_text = "\n".join(page.extract_text() or "" for page in pdf.pages)
+            elif file.content_type == "text/plain":
+                extracted_text = (await file.read()).decode("utf-8")
+            else:
+                return JSONResponse(status_code=400, content={"detail": "Only .txt and .pdf supported"})
+
+            text_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
+            docs = text_splitter.create_documents([extracted_text])
+            vector_store = FAISS.from_documents(docs, embedding)
+        else:
+            if not os.path.exists(DB_PATH):
+                return JSONResponse(
+                    status_code=400,
+                    content={"detail": "No recipe database found. Please upload a file first."}
+                )
+            vector_store = FAISS.load_local(DB_PATH, embedding, allow_dangerous_deserialization=True)
+
+        retriever = vector_store.as_retriever(search_type="mmr", k=1)
+
+        qa_chain = RetrievalQA.from_chain_type(
+            llm=llm,
+            retriever=retriever,
+            chain_type="stuff",
+            chain_type_kwargs={"prompt": rag_prompt_template}
+        )
+
+        # Changed from "question" to "query" to match the prompt template
+        result = qa_chain.invoke({"query": query})["result"]
+        cleaned_result = extract_rag_output(result)
+
+        return {
+            "recipe": cleaned_result,
+            "image_url": "/static/placeholder.jpg"
+        }
+
+    except Exception as e:
+        print("❌ RAG failed:", e)
+        return JSONResponse(status_code=500, content={"detail": str(e)})
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("backend.main:app", host="0.0.0.0", port=8080, reload=True)
+
+
+# uvicorn backend.main:app --reload --port 8008

backend/requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.68.0
+uvicorn>=0.15.0
+python-dotenv>=0.19.0
+openai>=1.0.0
+jinja2>=3.0.1
+python-multipart>=0.0.5
+requests>=2.26.0
+pydantic>=2.0.0

backend/temp.py

@@ -0,0 +1,99 @@
+# import os
+# from fastapi import FastAPI, Request, HTTPException
+# from fastapi.responses import HTMLResponse, JSONResponse
+# from fastapi.staticfiles import StaticFiles
+# from fastapi.templating import Jinja2Templates
+
+# app = FastAPI()
+
+# # Configure paths
+# BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+# STATIC_DIR = os.path.join(BASE_DIR, "frontend", "static")
+# TEMPLATE_DIR = os.path.join(BASE_DIR, "frontend", "templates")
+
+# # Debug paths
+# print(f"Static files directory: {STATIC_DIR} (exists: {os.path.exists(STATIC_DIR)})")
+# print(f"Templates directory: {TEMPLATE_DIR} (exists: {os.path.exists(TEMPLATE_DIR)})")
+
+# app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+# templates = Jinja2Templates(directory=TEMPLATE_DIR)
+
+# @app.get("/", response_class=HTMLResponse)
+# async def home(request: Request):
+#     return templates.TemplateResponse("index.html", {"request": request})
+
+# # Add API endpoint for recipe generation
+# @app.post("/api/generate-recipe")
+# async def generate_recipe(request: Request):
+#     try:
+#         data = await request.json()
+#         ingredients = data.get("ingredients", "")
+#         diet = data.get("diet")
+#         cuisine = data.get("cuisine")
+        
+#         # Here you would add your actual recipe generation logic
+#         # For now, returning a mock response
+#         return JSONResponse({
+#             "recipe": f"Mock recipe using: {ingredients}\n\n1. Do something\n2. Then another step\n3. Serve hot!",
+#             "image_url": "https://via.placeholder.com/600x400?text=Recipe+Image"
+#         })
+#     except Exception as e:
+#         raise HTTPException(status_code=400, detail=str(e))
+
+
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from langchain_huggingface import ChatHuggingFace, HuggingFacePipeline
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+model_id = "mistralai/Mistral-7B-Instruct-v0.3"
+
+# Load tokenizer + model
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(
+    model_id,
+    device_map="auto",
+    torch_dtype="auto"
+)
+
+# Create text-generation pipeline
+pipe = pipeline(
+    "text-generation",
+    model=model,
+    tokenizer=tokenizer,
+    max_new_tokens=200,
+    do_sample=True,
+    temperature=0.7
+)
+
+llm = HuggingFacePipeline(pipeline=pipe)
+modell = ChatHuggingFace(llm = llm)
+
+# Wrap in LangChain Chat Model
+
+# Prompt Template
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are a wise assistant reply quickly to users prompt."),
+    MessagesPlaceholder("history"),
+    ("user", "{input}")
+])
+
+history = []
+
+while True:
+    user_input = input("You: ")
+    if user_input in ["stop", "exit"]:
+        break
+
+    chain_input = {
+        "input": user_input,
+        "history": history
+    }
+
+    # Generate answer
+    response = modell.invoke(prompt.invoke(chain_input))
+
+    print("AI:", response.content)
+
+    # Maintain chat memory
+    history.append(("user", user_input))
+    history.append(("assistant", response.content))

backend/test_hugf.py

@@ -0,0 +1,209 @@
+# import os
+# import requests
+# from pathlib import Path
+# from dotenv import load_dotenv
+
+# # 1. Find and load the .env file - searches for ANY of these names
+# ENV_FILES = ['.env', '.env.example', 'env.example', 'env.txt']
+# loaded = False
+# for env_file in ENV_FILES:
+#     if Path(env_file).exists():
+#         load_dotenv(env_file)
+#         loaded = True
+#         print(f"✅ Loaded environment from: {env_file}")
+#         break
+
+# if not loaded:
+#     print("❌ No .env file found! Please create one with your API key")
+#     print("   File should contain either:")
+#     print("   HUGGINGFACE_API_KEY=your_api_key_here")
+#     print("   OR")
+#     print("   HF_API_KEY=your_api_key_here")
+#     exit(1)
+
+# # 2. Find the API key - checks ALL possible variable names
+# API_KEYS = ['HUGGINGFACE_API_KEY', 'HF_API_KEY', 'API_KEY']
+# api_key = None
+# for key in API_KEYS:
+#     api_key = os.getenv(key)
+#     if api_key:
+#         print(f"🔑 Found API key in variable: {key}")
+#         print(f"   Key starts with: {api_key[:8]}...")
+#         break
+
+# if not api_key:
+#     print("❌ No API key found in environment variables!")
+#     print("   Your .env file should contain:")
+#     print("   HUGGINGFACE_API_KEY=your_actual_key_here")
+#     print("   OR")
+#     print("   HF_API_KEY=your_actual_key_here")
+#     exit(1)
+
+# # 3. Test with a GUARANTEED small model
+# print("\n🚀 Testing API connection with small model (gpt2)...")
+# try:
+#     response = requests.post(
+#         "https://api-inference.huggingface.co/models/gpt2",
+#         headers={"Authorization": f"Bearer {api_key}"},
+#         json={"inputs": "Just say 'API is working'"},
+#         timeout=10
+#     )
+    
+#     if response.status_code == 200:
+#         print("🎉 SUCCESS! API Response:")
+#         print(response.json()[0]['generated_text'])
+#     else:
+#         print(f"❌ API Error (Status {response.status_code}):")
+#         print(response.text)
+#         print("\n🔧 Solutions:")
+#         print("- Wait 1 minute and try again (model may be loading)")
+#         print("- Check token at: https://huggingface.co/settings/tokens")
+#         print("- Try a different small model")
+
+# except Exception as e:
+#     print(f"🚨 Connection failed: {str(e)}")
+#     print("\n🔧 Check your internet connection and try again")
+# import os
+# import requests
+# from dotenv import load_dotenv
+# import time
+
+# # Load environment
+# load_dotenv()
+# API_KEY = os.getenv("HUGGINGFACE_API_KEY")
+
+# # Verified working models (2025)
+# MODELS = [
+#     "gpt2",  # Always available
+#     "distilgpt2",  # More responsive
+#     "facebook/opt-350m",  # Structured responses
+#     "google/flan-t5-small",  # Best for instructions
+#     "bert-base-uncased",  # Embeddings
+#     "deepset/roberta-base-squad2",  # QA
+#     "distilbert-base-uncased-finetuned-sst-2-english",  # Sentiment
+#     "nlpconnect/vit-gpt2-image-captioning",  # Multimodal
+#     "microsoft/DialoGPT-medium",  # Chat
+#     "Jean-Baptiste/camembert-ner"  # NER
+# ]
+
+# def test_model(model: str):
+#     headers = {"Authorization": f"Bearer {API_KEY}"}
+#     test_prompts = {
+#         "text-gen": "Respond only with: API_TEST_OK",
+#         "embedding": "Test sentence for embeddings",
+#         "qa": {"inputs": {"question": "Test?", "context": "Testing"}},
+#         "multimodal": {"image": "https://example.com/test.jpg"}
+#     }
+    
+#     try:
+#         # Get model type from Hugging Face API
+#         model_info = requests.get(
+#             f"https://huggingface.co/api/models/{model}",
+#             timeout=10
+#         ).json()
+        
+#         # Select appropriate test
+#         pipeline_tags = model_info.get("pipeline_tags", ["unknown"])
+#         print(f"\n🚀 Testing {model} ({pipeline_tags})...")
+        
+#         if "text-generation" in pipeline_tags:
+#             prompt = test_prompts["text-gen"]
+#         elif "feature-extraction" in pipeline_tags:
+#             prompt = test_prompts["embedding"]
+#         else:
+#             prompt = test_prompts["text-gen"]  # Default
+            
+#         response = requests.post(
+#             f"https://api-inference.huggingface.co/models/{model}",
+#             headers=headers,
+#             json={"inputs": prompt},
+#             timeout=30
+#         )
+        
+#         if response.status_code == 200:
+#             print(f"✅ Working! Response: {response.json()}")
+#             return True
+#         else:
+#             print(f"❌ Failed (Status {response.status_code}): {response.text[:200]}...")
+#             return False
+            
+#     except Exception as e:
+#         print(f"🚨 Error testing {model}: {str(e)}")
+#         return False
+
+# def main():
+#     print("🔍 Hugging Face Full Model Test (2025)")
+#     print("="*60)
+    
+#     if not API_KEY:
+#         print("❌ Error: Set HUGGINGFACE_API_KEY in .env file")
+#         return
+    
+#     for model in MODELS:
+#         for attempt in range(3):  # 3 retries
+#             if test_model(model):
+#                 break
+#             time.sleep(10)  # Wait between attempts
+
+# if __name__ == "__main__":
+#     main()
+
+import requests
+from dotenv import load_dotenv
+import os
+import time
+
+# Load environment variables
+load_dotenv()
+API_KEY = os.getenv("HUGGINGFACE_API_KEY")
+
+MODEL = "google/flan-t5-large"  # Google FLAN-T5 Small model
+
+def search_and_answer(prompt: str) -> str:
+    """
+    Sends a query to the Hugging Face FLAN-T5 Small model and retrieves an answer.
+    
+    :param prompt: The user query to process and generate an answer.
+    :return: The generated answer.
+    """
+    headers = {"Authorization": f"Bearer {API_KEY}"}
+    
+    try:
+        # Make a request to Hugging Face FLAN-T5 Small model
+        response = requests.post(
+            f"https://api-inference.huggingface.co/models/{MODEL}",
+            headers=headers,
+            json={"inputs": prompt},
+            timeout=30
+        )
+        
+        # Check response status
+        if response.status_code == 200:
+            result = response.json()
+            generated_text = result[0].get("generated_text", "No answer generated.")
+            return f"Answer: {generated_text}"
+        else:
+            return f"Error: Unable to fetch answer (Status: {response.status_code})"
+    
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def main():
+    print("🔍 Query Answering Tool Using Google FLAN-T5 Small")
+    print("=" * 50)
+    
+    if not API_KEY:
+        print("❌ Error: Set HUGGINGFACE_API_KEY in .env file")
+        return
+    
+    # Get user input for the query
+    user_query = input("Enter your query: ")
+    
+    # Get the answer using the model
+    answer = search_and_answer(user_query)
+    
+    print("\n🚀 Result:")
+    print(answer)
+
+if __name__ == "__main__":
+    main()

frontend/templates/index.html

@@ -0,0 +1,248 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>NPChef</title>
+    <link rel="icon" href="https://img.icons8.com/ios-filled/100/meal.png" type="image/png">
+    
+    <!-- Optional: For better display on mobile homescreens -->
+    <link rel="apple-touch-icon" href="https://img.icons8.com/ios-filled/100/meal.png">
+    <meta name="theme-color" content="#FF8C42">
+    <script src="https://cdn.tailwindcss.com"></script>
+  </head>
+  <body class="bg-orange-50 text-gray-800">
+    <!-- Hero Section -->
+    <!-- <section class="bg-gradient-to-r from-orange-400 to-orange-500 text-white py-20 pt-20 text-center">
+      <h1 class="text-5xl font-bold mb-4">AI Recipe Generator</h1>
+      <p class="text-lg">Enter your ingredients below and get amazing recipes!</p>
+    </section> -->
+    <section class="text-center mb-10 bg-gradient-to-r from-orange-400 to-orange-500 text-white py-10 text-center">
+      <img src="https://img.icons8.com/ios-filled/100/meal.png" alt="logo" class="mx-auto  w-16 h-16 mb-2">
+      <h1 class="text-4xl font-extrabold tracking-tight text-white">NPChef Recipe Assistant</h1>
+      <p class="text-sm text-white font-bold mt-2">NPChef Recipe Assistant for NPCs = Non-Player Cooks 😉 </p>
+      <!-- <p class="text-sm text-white font-bold mt-2"> Enter your ingredients below and get amazing recipes!</p> -->
+    </section>
+
+    <!-- Input Section -->
+    <section class="max-w-3xl mx-auto py-10 px-4">
+      <h2 class="text-2xl text-orange-400 font-bold mb-4">Enter your ingredients below and get amazing recipes!</h2>
+      <p class="text-gray-600 mb-6">NOTE! This service is hosted on an open source server and uses CPU and allow limited resources,so the responses may be wrong and it may take upto 2 minutes to generate the recipe.</p>
+      <form id="recipeForm" class="space-y-4">
+        <div class="relative">
+        <textarea
+          id="ingredientsInput"
+          class="w-full p-4 rounded-lg shadow border border-orange-300 focus:ring-2 focus:ring-orange-400"
+          rows="4"
+          placeholder="e.g. rice, tomato, onion, chicken or just the name of the dish you want to make"
+        ></textarea>
+        <label for="recipeFile" class="absolute bottom-3 right-3 cursor-pointer">
+            <img src="/static/attach-file.png" class="w-6 h-6" alt="Upload" title="Upload your recipe file">
+          </label>
+          <input type="file" id="recipeFile" name="recipeFile" accept=".txt,.pdf" class="hidden" />
+        </div>
+
+
+
+          <!-- Info-only Box -->
+          <strong class="text-orange-500">New</strong><br>
+          <div class="relative max-w-3xl border border-dashed border-orange-400 rounded p-3 bg-orange-50 text-sm text-gray-700" style="margin-top: 0.5rem;" id="uploadInfoBox">
+          <!-- Tail triangle -->
+          <div class="absolute -top-2 right-5 w-0 h-0 border-l-[6px] border-l-transparent border-r-[6px] border-r-transparent border-b-[8px] border-b-orange-400"></div>
+
+          
+          Got your or your mom’s secret recipes? Upload and get detailed versions!
+        </div>
+          <!-- Hidden File Input -->
+          <input type="file" id="recipeFile" name="recipeFile" accept=".txt,.pdf" class="hidden" />
+          <p id="uploadMessage" class="text-sm mt-2 text-green-600 hidden"></p>
+        </div>
+
+        <div class="flex gap-4">
+          <button
+            type="submit"
+            class="bg-orange-500 hover:bg-orange-600 text-white px-6 py-2 rounded-lg shadow"
+          >
+            Generate Recipe
+          </button>
+          <button
+            type="button"
+            onclick="clearInput()"
+            class="bg-white text-orange-500 border border-orange-500 hover:bg-orange-100 px-6 py-2 rounded-lg shadow"
+          >
+            Clear
+          </button>
+        </div>
+
+        <!-- Dietary Preferences & Cuisine Type -->
+        <div class="mt-6 grid gap-4 md:grid-cols-2">
+          <div>
+            <label for="diet" class="block font-medium mb-1">Dietary Preference</label>
+            <select id="diet" class="w-full p-3 rounded-lg border border-orange-300">
+              <option value="">Any</option>
+              <option value="vegetarian">Vegetarian</option>
+              <option value="vegan">Vegan</option>
+              <option value="gluten-free">Gluten-Free</option>
+            </select>
+          </div>
+          <div>
+            <label for="cuisine" class="block font-medium mb-1">Cuisine Type</label>
+            <select id="cuisine" class="w-full p-3 rounded-lg border border-orange-300">
+              <option value="">Any</option>
+              <option value="indian">Indian</option>
+              <option value="italian">Italian</option>
+              <option value="mexican">Mexican</option>
+            </select>
+          </div>
+        </div>
+      </form>
+
+      <!-- Most Used Ingredients -->
+      <div class="mt-6">
+        <h2 class="text-xl font-semibold mb-2">Most Used Ingredients</h2>
+        <div class="flex flex-wrap gap-2">
+          <button onclick="fillIngredient('rice')" class="bg-orange-200 hover:bg-orange-300 px-3 py-1 rounded-full">rice</button>
+          <button onclick="fillIngredient('onion')" class="bg-orange-200 hover:bg-orange-300 px-3 py-1 rounded-full">onion</button>
+          <button onclick="fillIngredient('chicken')" class="bg-orange-200 hover:bg-orange-300 px-3 py-1 rounded-full">chicken</button>
+          <button onclick="fillIngredient('garlic')" class="bg-orange-200 hover:bg-orange-300 px-3 py-1 rounded-full">garlic</button>
+          <button onclick="fillIngredient('milk')" class="bg-orange-200 hover:bg-orange-300 px-3 py-1 rounded-full">milk</button>
+          <button onclick="fillIngredient('bread')" class="bg-orange-200 hover:bg-orange-300 px-3 py-1 rounded-full">bread</button>
+        </div>
+      </div>
+    </section>
+
+    <!-- Recipe Output Section -->
+    <section id="recipeOutput" class="max-w-4xl mx-auto px-4 pb-20">
+      <!-- Recipes will appear here -->
+    </section>
+
+    <!-- Footer -->
+    <footer class="bg-orange-100 text-center py-9 pt-9 text-sm text-orange-700 mt-20" >
+      <!-- Made with ❤️ using AI. Never waste food. -->
+      <p class="flex items-center justify-center space-x-1">
+        <span>Made with ❤️</span>
+        <!-- <svg class="w-5 h-5 text-red-500" fill="currentColor" viewBox="0 0 20 20">
+            <path fill-rule="evenodd" d="M3.172 5.172a4 4 0 015.656 0L10 6.343l1.172-1.171a4 4 0 115.656 5.656L10 17.657l-6.828-6.829a4 4 0 010-5.656z" clip-rule="evenodd" />
+        </svg> -->
+        <span>by <a href="https://mehul-raul.github.io/mehul.dev.portfolio/" class="text-orange-600 hover:text-orange-800 font-medium" target="_blank" rel="noopener noreferrer">Mehul Raul</a></span>
+        <span>|</span>
+        <span>Never waste food:)</span>
+    </p>
+    </footer>
+
+   <script>
+const form = document.getElementById("recipeForm");
+const ingredientsInput = document.getElementById("ingredientsInput");
+const output = document.getElementById("recipeOutput");
+const dietSelect = document.getElementById("diet");
+const cuisineSelect = document.getElementById("cuisine");
+const fileInput = document.getElementById("recipeFile");
+
+function fillIngredient(text) {
+  ingredientsInput.value = ingredientsInput.value
+    ? ingredientsInput.value + ", " + text
+    : text;
+  ingredientsInput.focus();
+}
+
+function clearInput() {
+  ingredientsInput.value = "";
+  ingredientsInput.focus();
+  fileInput.value = "";
+
+  const uploadMessage = document.getElementById("uploadMessage");
+  if (uploadMessage) {
+    uploadMessage.textContent = "";
+    uploadMessage.classList.add("hidden");
+  }
+}
+
+document.getElementById("recipeFile").addEventListener("change", function () {
+  const file = this.files[0];
+  const message = document.getElementById("uploadMessage");
+
+  if (!file) {
+    message.textContent = "No file selected.";
+    message.classList.remove("hidden", "text-green-600");
+    message.classList.add("text-red-600");
+    return;
+  }
+
+  const allowedTypes = ["text/plain", "application/pdf"];
+  if (!allowedTypes.includes(file.type)) {
+    message.textContent = "❌ Please upload a .txt or .pdf file only!";
+    message.classList.remove("hidden", "text-green-600");
+    message.classList.add("text-red-600");
+    return;
+  }
+
+  message.textContent = `✅ File "${file.name}" uploaded successfully!`;
+  message.classList.remove("hidden", "text-red-600");
+  message.classList.add("text-green-600");
+});
+
+form.addEventListener("submit", async (e) => {
+  e.preventDefault();
+  output.innerHTML = `
+    <div class='text-center py-6'>
+      <div class='inline-block animate-spin rounded-full h-8 w-8 border-t-2 border-b-2 border-orange-500'></div>
+      <p class='mt-2 text-orange-500'>Generating your recipe (please wait, this may take up to 2 minutes)...</p>
+    </div>`;
+
+  const formData = new FormData();
+  formData.append("ingredients", ingredientsInput.value.trim());
+  formData.append("diet", dietSelect.value || "");
+  formData.append("cuisine", cuisineSelect.value || "");
+
+  let endpoint = "/api/generate-recipe"; // default: non-RAG
+  if (fileInput.files.length > 0) {
+    formData.append("file", fileInput.files[0]);
+    endpoint = "/api/rag-recipe"; // use RAG if file uploaded
+  }
+
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      body: formData,
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.detail || "Recipe generation failed");
+    }
+
+    const data = await response.json();
+    const formattedRecipe = data.recipe.replace(/\n/g, "<br>");
+
+    output.innerHTML = `
+      <div class="bg-white shadow rounded-lg overflow-hidden">
+        <img src="${data.image_url}" alt="Recipe Image" class="w-full h-48 object-cover" onerror="this.src='/docs/static/placeholder.jpg'">
+        <div class="p-6">
+          <h3 class="text-2xl font-bold mb-4">Your Generated Recipe</h3>
+          <div class="prose max-w-none">${formattedRecipe}</div>
+        </div>
+      </div>
+    `;
+  } catch (error) {
+    output.innerHTML = `
+      <div class="bg-red-50 border-l-4 border-red-500 p-4">
+        <div class="flex">
+          <div class="flex-shrink-0">
+            <svg class="h-5 w-5 text-red-500" viewBox="0 0 20 20" fill="currentColor">
+              <path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clip-rule="evenodd" />
+            </svg>
+          </div>
+          <div class="ml-3">
+            <p class="text-sm text-red-700">${error.message}</p>
+          </div>
+        </div>
+      </div>`;
+    console.error("Error:", error);
+  }
+});
+</script>
+
+
+
+  </body>
+</html>