initial files uploaded

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GithubDefaultAccount">
+    <option name="defaultAccountId" value="34b99f66-1f2e-4ee6-b01c-03df7216dada" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="imagebind" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/travelling-agent.iml" filepath="$PROJECT_DIR$/.idea/travelling-agent.iml" />
+    </modules>
+  </component>
+</project>

.idea/travelling-agent.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="imagebind" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

Dockerfile

@@ -0,0 +1,32 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+# --no-cache-dir: Don't store the downloaded packages, keeping the image size smaller.
+# --upgrade pip: Ensure you have the latest pip.
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code into the container at /app
+COPY . .
+
+# Make port 8000 available to the world outside this container
+# Hugging Face Spaces typically expect the app on port 7860, but FastAPI defaults to 8000.
+# We'll run on 8000 and let HF handle mapping if needed, or adjust the CMD.
+# Let's use 7860 directly as it's common for HF.
+EXPOSE 7860
+
+# Define environment variables (optional, can be set in Hugging Face secrets)
+# ENV GOOGLE_API_KEY="your_key_here" # It's better to use HF Secrets
+# ENV PEXELS_API_KEY="your_key_here" # It's better to use HF Secrets
+
+# Run main.py when the container launches
+# Use 0.0.0.0 to make it accessible from outside the container.
+# Use port 7860 as often expected by Hugging Face Spaces.
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,12 @@
----
-title: Travelling Agent
-emoji: ⚡
-colorFrom: red
-colorTo: gray
-sdk: docker
-pinned: false
-license: mit
-short_description: agent that recommend the places to travel
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Travelling Agent
+emoji: ⚡
+colorFrom: red
+colorTo: gray
+sdk: docker
+pinned: false
+license: mit
+short_description: agent that recommend the places to travel
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

gemini_utils.py

@@ -0,0 +1,120 @@
+# gemini_utils.py
+
+import os
+import time
+import backoff
+import google.generativeai as genai
+from typing import Dict, List
+
+# Load the Gemini API key from environment variables
+GOOGLE_API_KEY="AIzaSyDuDPP0eWWA0UsGBBIeOI7Fl0WcPli4Sdo"
+
+genai.configure(api_key=GOOGLE_API_KEY)
+
+# Initialize the model once
+model = genai.GenerativeModel(model_name="gemini-1.5-flash")
+
+@backoff.on_exception(
+    backoff.expo,
+    Exception,
+    max_tries=3,
+    giveup=lambda e: "rate limit" not in str(e).lower() and "timeout" not in str(e).lower(),
+    max_value=20
+)
+def generate_with_gemini(prompt: str, max_tokens: int = 2048, temperature: float = 0.7) -> str:
+    """
+    Generates a response from the Gemini model using the given prompt.
+    Retries on transient errors using exponential backoff.
+    """
+    try:
+        response = model.generate_content(
+            prompt,
+            generation_config={
+                "max_output_tokens": max_tokens,
+                "temperature": temperature
+            }
+        )
+        return response.text
+    except Exception as e:
+        print(f"Gemini API Error: {str(e)}")
+        raise e
+
+def create_travel_plan_prompt(travel_data: Dict) -> str:
+    """
+    Constructs a prompt to generate a travel itinerary based on user-provided data.
+    """
+    destination = travel_data.get("destination") or "a suitable destination based on additional preferences"
+    location_type = travel_data.get("location_type")
+    province = travel_data.get("province")
+    starting_location = travel_data.get("starting_location") or "Pakistan"
+    gender = travel_data.get("gender")
+    num_people = travel_data.get("num_people")
+    has_children = travel_data.get("has_children")
+    activity_type = travel_data.get("activity_type")
+    travel_group = travel_data.get("travel_group")
+    preferences = ", ".join(travel_data.get("preferences", [])) or "None"
+    budget = travel_data.get("budget", 0)
+    num_days = travel_data.get("num_days")
+    additional_preferences = travel_data.get("additional_preferences", "") or "None"
+    budget_str = f"They have a budget of {budget} PKR" if budget > 0 else "No specific budget is provided"
+
+    prompt = f"""You are a travel expert specializing in Pakistan. Create a detailed {num_days}-day travel itinerary for {num_people} people, including {gender.lower()} travelers, who are {travel_group.lower()}, {'with children' if has_children else 'without children'}, starting from {starting_location}. {'They want to visit ' + destination + '.' if destination != 'a suitable destination based on additional preferences' else 'Suggest a suitable destination based on their preferences.'} The destination is a {location_type} in {province}. They prefer {activity_type.lower()} activities and are interested in {preferences}. {budget_str}. Additional requests: {additional_preferences}
+
+INCLUDE ALL THE FOLLOWING SECTIONS in your itinerary, using simple and clear language:
+
+1. **Itinerary Overview:**
+   - Destination: [Destination Name]
+   - Brief summary of the trip
+   - Key highlights and attractions
+   - Best time to visit the destination
+   - If no destination is specified, explain why the suggested destination was chosen
+
+2. **Daily Itinerary:**
+   - For each day (Day 1 to Day {num_days}), provide:
+     - Morning, afternoon, and evening activities
+     - Meal suggestions (local cuisine where possible)
+     - Accommodation recommendations (hotels, guesthouses, etc.)
+
+3. **Transportation:**
+   - How to travel from {starting_location} to the destination (e.g., flights, buses)
+   - Local transportation options within the destination
+
+4. **Safety and Health:**
+   - Safety precautions, especially for children if applicable
+   - Health considerations or recommended vaccinations
+
+5. **Cultural Etiquette:**
+   - Important cultural norms to respect
+
+6. **Estimated Costs:**
+   - Detailed cost breakdown for activities, meals, accommodations, and transportation
+   - Ensure the itinerary fits within the budget if provided, or provide approximate costs
+
+7. **Travel Tips:**
+   - Practical tips for a smooth trip (e.g., packing, local customs, safety)
+
+8. **Contingency Plans:**
+   - Alternatives for bad weather, cancellations, or other issues
+
+Format the itinerary using Markdown with clear headers (# for main sections, ## for days) and consistent structure for each day.
+"""
+    return prompt
+
+def create_chat_prompt(plan: str, destination: str, num_days: int, history: List[Dict], user_input: str) -> str:
+    """
+    Constructs a prompt for a chat interaction based on an existing travel plan and chat history.
+    """
+    conversation = ""
+    for msg in history:
+        conversation += f"{msg['role'].capitalize()}: {msg['content']}\n"
+
+    prompt = f"""You are a helpful travel assistant. The user has a {num_days}-day travel plan for {destination}.
+The plan is:
+{plan}
+
+Conversation history:
+{conversation}
+User: {user_input}
+
+Assistant:"""
+    return prompt

image_searcher.py

@@ -0,0 +1,117 @@
+# image_searcher.py
+import requests
+import random
+from typing import List, Dict, Optional
+
+class ImageSearcher:
+    def __init__(self, pexels_api_key: str):
+        self.pexels_api_key = pexels_api_key
+        self.headers = {
+            'Authorization': self.pexels_api_key,
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+
+    def search_pexels(self, query: str, num_images: int = 10) -> List[Dict]:
+        try:
+            url = "https://api.pexels.com/v1/search"
+            params = {
+                'query': query,
+                'per_page': min(num_images, 80),
+                'page': 1
+            }
+            response = requests.get(url, params=params, headers=self.headers, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            images = []
+            for item in data.get('photos', []):
+                images.append({
+                    'url': item['src']['medium'],
+                    'thumbnail': item['src']['small'],
+                    'title': item.get('alt', query),
+                    'author': item['photographer'],
+                    'source': 'pexels'
+                })
+            print(f"Found {len(images)} images from Pexels for query: {query}")
+            return images
+        except Exception as e:
+            print(f"Pexels search failed for query {query}: {e}")
+            return []
+
+    def search_lorem_picsum(self, query: str, width: int = 400, height: int = 300, num_images: int = 10) -> List[Dict]:
+        images = []
+        title_base = f"Pakistan {query}" if query else "Pakistan Travel"
+        for i in range(num_images):
+            seed = random.randint(1, 1000)
+            images.append({
+                'url': f"https://picsum.photos/{width}/{height}?random={seed}",
+                'thumbnail': f"https://picsum.photos/200/150?random={seed}",
+                'title': f"{title_base} View {i+1}",
+                'author': 'Lorem Picsum',
+                'source': 'lorem_picsum'
+            })
+        print(f"Generated {len(images)} placeholder images for query: {query}")
+        return images
+
+    def search_all_sources(self, queries: List[str], num_images: int = 6) -> List[Dict]:
+        all_images = []
+        for query in queries:
+            if query:
+                full_query = f"{query} Pakistan"
+                pexels_images = self.search_pexels(full_query, num_images)
+                all_images.extend(pexels_images)
+                if len(all_images) >= num_images: break
+
+        if len(all_images) < num_images:
+            for query in queries:
+                if query and not any(f"{query} Pakistan" in q for q in [img['title'] for img in all_images]):
+                    pexels_images = self.search_pexels(query, num_images - len(all_images))
+                    all_images.extend(pexels_images)
+                    if len(all_images) >= num_images: break
+
+        if len(all_images) < num_images:
+            print(f"Insufficient results, generating placeholders.")
+            placeholder_images = self.search_lorem_picsum(queries[0] if queries else '', num_images=num_images - len(all_images))
+            all_images.extend(placeholder_images)
+
+        return all_images[:num_images]
+
+def create_image_queries(travel_data: Dict, destination: Optional[str]) -> List[str]:
+    queries = []
+    location_type = travel_data.get("location_type", "").lower() if travel_data.get("location_type") != "Other" else ""
+    province = travel_data.get("province", "").lower().replace("-", " ") if travel_data.get("province") else ""
+    preferences = travel_data.get("preferences", [])
+    preference_map = {
+        "Cultural Experience": "culture", "Food and Dining": "food",
+        "Shopping": "market", "Nature": "nature", "History": "historical"
+    }
+    pref_terms = [preference_map.get(pref, pref.lower()) for pref in preferences if pref in preference_map]
+
+    if destination and destination != "Suggested Destination": queries.append(destination)
+    if destination and destination != "Suggested Destination" and location_type: queries.append(f"{destination} {location_type}")
+    if destination and destination != "Suggested Destination" and pref_terms: queries.append(f"{destination} {' '.join(pref_terms)}")
+    if destination and destination != "Suggested Destination" and location_type and pref_terms: queries.append(f"{destination} {location_type} {' '.join(pref_terms)}")
+    if province and location_type: queries.append(f"{province} {location_type}")
+    if province and pref_terms: queries.append(f"{province} {' '.join(pref_terms)}")
+    if province: queries.append(province)
+    if location_type and pref_terms: queries.append(f"{location_type} {' '.join(pref_terms)}")
+    if location_type: queries.append(location_type)
+
+    queries = list(dict.fromkeys([q for q in queries if q]))
+    if not queries: queries.append("Pakistan travel")
+    print(f"Created image search queries: {queries}")
+    return queries
+
+def extract_destination(plan_text: str, travel_data: Dict) -> Optional[str]:
+    lines = plan_text.split('\n')
+    for line in lines:
+        if line.strip().startswith('- Destination:'):
+            parts = line.split(':', 1)
+            if len(parts) > 1:
+                destination = parts[1].strip()
+                print(f"Extracted destination from plan: {destination}")
+                return destination
+
+    if travel_data.get("destination"): return travel_data["destination"]
+    if travel_data.get("additional_preferences"): return " ".join(travel_data["additional_preferences"].split()[:3])
+    if travel_data.get("province"): return travel_data["province"]
+    return None

main.py

@@ -0,0 +1,233 @@
+# # main.py
+# import os
+# from fastapi import FastAPI, HTTPException
+# from fastapi.middleware.cors import CORSMiddleware
+# from dotenv import load_dotenv
+#
+# from models import TravelDataInput, PlanResponse, ChatInput, ChatResponse
+# from image_searcher import ImageSearcher, create_image_queries, extract_destination
+# from gemini_utils import create_travel_plan_prompt, generate_with_gemini, create_chat_prompt
+# from rag_utils import get_relevant_plan
+#
+# # Load environment variables (especially API keys)
+# load_dotenv()
+# PEXELS_API_KEY = os.getenv("PEXELS_API_KEY", "LB4mRviLcvE72R2645m3f4NpYGBMpPucVctpvzJAsCJYC2dhbGVpLraK") # Replace or set in env
+# GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", "AIzaSyDuDPP0eWWA0UsGBBIeOI7Fl0WcPli4Sdo") # Replace or set in env
+#
+# if not PEXELS_API_KEY or not GOOGLE_API_KEY:
+#     print("Warning: API keys not found. Please set PEXELS_API_KEY and GOOGLE_API_KEY environment variables.")
+#
+# # Initialize app and image searcher
+# app = FastAPI(title="Travel Recommendation API")
+# image_searcher = ImageSearcher(PEXELS_API_KEY)
+#
+# # CORS (Cross-Origin Resource Sharing) - Allow frontend access
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"], # Adjust in production
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+#
+# @app.get("/", summary="Root endpoint for health check")
+# def read_root():
+#     return {"message": "Travel Recommendation API is running!"}
+#
+# @app.post("/generate_plan", response_model=PlanResponse, summary="Generate a travel plan")
+# async def generate_plan_endpoint(travel_input: TravelDataInput):
+#     travel_data = travel_input.model_dump() # Use model_dump() for Pydantic v2
+#     source = "generated"
+#     plan_text = None
+#
+#     # 1. Try RAG first
+#     try:
+#         relevant_plan = get_relevant_plan(travel_data)
+#         if relevant_plan:
+#             plan_text = relevant_plan
+#             source = "index"
+#     except Exception as e:
+#         print(f"RAG check failed (continuing with generation): {e}")
+#
+#     # 2. If no RAG plan, generate with Gemini
+#     if not plan_text:
+#         try:
+#             prompt = create_travel_plan_prompt(travel_data)
+#             plan_text = generate_with_gemini(prompt)
+#             source = "generated"
+#         except Exception as e:
+#             print(f"Gemini generation failed: {e}")
+#             raise HTTPException(status_code=500, detail=f"Failed to generate plan: {e}")
+#
+#     if not plan_text:
+#         raise HTTPException(status_code=500, detail="Could not retrieve or generate a travel plan.")
+#
+#     # 3. Extract destination & get images
+#     try:
+#         destination = extract_destination(plan_text, travel_data) or "Suggested Destination"
+#         image_queries = create_image_queries(travel_data, destination)
+#         images = image_searcher.search_all_sources(image_queries, num_images=6)
+#     except Exception as e:
+#         print(f"Image search failed: {e}")
+#         images = [] # Return empty list if image search fails
+#         image_queries = []
+#
+#     return PlanResponse(
+#         plan_text=plan_text,
+#         destination_used=destination,
+#         images=images,
+#         image_queries_used=image_queries,
+#         source=source
+#     )
+#
+# @app.post("/chat", response_model=ChatResponse, summary="Chat about the travel plan")
+# async def chat_endpoint(chat_input: ChatInput):
+#     try:
+#         prompt = create_chat_prompt(
+#             chat_input.plan_text,
+#             chat_input.destination,
+#             chat_input.num_days,
+#             [msg.model_dump() for msg in chat_input.chat_history], # Convert Pydantic to dict
+#             chat_input.user_input
+#         )
+#         response = generate_with_gemini(prompt, max_tokens=1024, temperature=0.5)
+#         return ChatResponse(assistant_response=response)
+#     except Exception as e:
+#         print(f"Chat generation failed: {e}")
+#         raise HTTPException(status_code=500, detail=f"Failed to get chat response: {e}")
+#
+# # To run locally: uvicorn main:app --reload
+
+# PEXELS_API_KEY = "LB4mRviLcvE72R2645m3f4NpYGBMpPucVctpvzJAsCJYC2dhbGVpLraK"
+# GOOGLE_API_KEY = "AIzaSyDuDPP0eWWA0UsGBBIeOI7Fl0WcPli4Sdo"
+
+import re
+import os
+import json
+from typing import List
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+from models import TravelDataInput, PlanResponse
+from image_searcher import ImageSearcher, create_image_queries, extract_destination
+from gemini_utils import create_travel_plan_prompt, generate_with_gemini
+from rag_utils import get_relevant_plan
+
+# API keys
+PEXELS_API_KEY = "LB4mRviLcvE72R2645m3f4NpYGBMpPucVctpvzJAsCJYC2dhbGVpLraK"
+GOOGLE_API_KEY = "AIzaSyDuDPP0eWWA0UsGBBIeOI7Fl0WcPli4Sdo"
+
+# App setup
+app = FastAPI(title="Travel Recommendation API")
+image_searcher = ImageSearcher(PEXELS_API_KEY)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/", summary="Root endpoint for health check")
+def read_root():
+    return {"message": "Travel Recommendation API is running!"}
+
+@app.post("/generate_plan", response_model=PlanResponse, summary="Generate a travel plan")
+async def generate_plan_endpoint(travel_input: TravelDataInput):
+    travel_data = travel_input.model_dump()
+    source = "generated"
+    plan_text = None
+
+    # Step 1: RAG
+    try:
+        relevant_plan = get_relevant_plan(travel_data)
+        if relevant_plan:
+            plan_text = relevant_plan
+            source = "index"
+    except Exception as e:
+        print(f"RAG check failed: {e}")
+
+    # Step 2: Generate if RAG fails
+    if not plan_text:
+        try:
+            prompt = create_travel_plan_prompt(travel_data)
+            plan_text = generate_with_gemini(prompt)
+        except Exception as e:
+            print(f"Gemini generation failed: {e}")
+            raise HTTPException(status_code=500, detail=f"Failed to generate plan: {e}")
+
+    if not plan_text:
+        raise HTTPException(status_code=500, detail="Could not retrieve or generate a travel plan.")
+
+    # Step 3: Get destination & images
+    try:
+        destination = extract_destination(plan_text, travel_data) or "Suggested Destination"
+        image_queries = create_image_queries(travel_data, destination)
+        images = image_searcher.search_all_sources(image_queries, num_images=6)
+    except Exception as e:
+        print(f"Image search failed: {e}")
+        images = []
+        image_queries = []
+
+    return PlanResponse(
+        plan_text=plan_text,
+        destination_used=destination,
+        images=images,
+        image_queries_used=image_queries,
+        source=source,
+    )
+
+# ========== EXTRACTION ENDPOINT ==========
+
+class ExtractionInput(BaseModel):
+    plan_text: str
+
+@app.post("/extract_package", summary="Extract structured package data from plan text")
+async def extract_package_endpoint(data: ExtractionInput):
+    extraction_prompt = f"""
+Extract ONLY the following fields from the travel plan below and return STRICTLY in raw JSON format. No extra explanation, no markdown, no text.
+
+Required JSON format:
+{{
+  "packageName": string,
+  "packageDescription": string,
+  "packageDestination": string,
+  "packageDays": integer,
+  "packageNights": integer,
+  "packageAccommodation": string,
+  "packageTransportation": string,
+  "packageMeals": string,
+  "packageActivities": string,
+  "packagePrice": float,
+  "packageDiscountPrice": float,
+  "packageOffer": boolean,
+  "packageRating": 0,
+  "packageTotalRatings": 0
+}}
+
+TRAVEL PLAN:
+\"\"\" 
+{data.plan_text}
+\"\"\"
+"""
+
+    try:
+        raw_response = generate_with_gemini(extraction_prompt)
+        print("Gemini raw response:", raw_response)
+
+        # Extract the JSON body from the response
+        json_match = re.search(r'\{.*\}', raw_response, re.DOTALL)
+        if not json_match:
+            raise ValueError("No JSON object found in Gemini response")
+
+        json_str = json_match.group(0)
+        structured_package = json.loads(json_str)
+
+    except Exception as e:
+        print("Gemini extraction failed:", e)
+        print("Prompt was:\n", extraction_prompt)
+        raise HTTPException(status_code=500, detail="Failed to extract structured package data.")
+
+    return structured_package

models.py

@@ -0,0 +1,39 @@
+# models.py
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional
+
+class TravelDataInput(BaseModel):
+    destination: Optional[str] = Field(None, description="e.g., Neelum Valley")
+    location_type: str = Field(..., description="City, Beach, Mountain, etc.")
+    province: str = Field(..., description="Punjab, Sindh, etc.")
+    starting_location: str = Field(..., description="e.g., Islamabad")
+    gender: str = Field(..., description="Male, Female, Mixed")
+    num_people: int = Field(..., gt=0, description="Number of people")
+    has_children: bool = Field(False, description="Whether children are present")
+    activity_type: str = Field(..., description="Adventure, Sightseeing, Both")
+    travel_group: str = Field(..., description="Solo, With partner, etc.")
+    preferences: List[str] = Field([], description="Cultural Experience, Food, etc.")
+    budget: int = Field(0, ge=0, description="Budget in PKR")
+    num_days: int = Field(..., gt=0, description="Number of days")
+    additional_preferences: Optional[str] = Field(None, description="Any other requests")
+
+class PlanResponse(BaseModel):
+    plan_text: str
+    destination_used: str
+    images: List[Dict]
+    image_queries_used: List[str]
+    source: str
+
+class ChatMessage(BaseModel):
+    role: str # user or assistant
+    content: str
+
+class ChatInput(BaseModel):
+    plan_text: str
+    destination: str
+    num_days: int
+    chat_history: List[ChatMessage]
+    user_input: str
+
+class ChatResponse(BaseModel):
+    assistant_response: str

rag_utils.py

@@ -0,0 +1,61 @@
+# rag_utils.py
+import faiss
+import pickle
+import numpy as np
+from typing import Dict, Optional
+
+FAISS_INDEX_PATH = "faiss_travel_index"
+PKL_PATH = "faiss_travel_index.pkl"
+
+def get_relevant_plan(travel_data: Dict) -> Optional[str]:
+    try:
+        index = faiss.read_index(FAISS_INDEX_PATH)
+        with open(PKL_PATH, "rb") as f:
+            plan_data = pickle.load(f)
+
+        if not isinstance(plan_data, dict):
+            print("Warning: plan_data is not a dict, assuming list with index as key")
+            plan_data = {i: plan for i, plan in enumerate(plan_data)}
+
+        # --- IMPORTANT ---
+        # This part needs a real embedding model.
+        # You need to install 'sentence-transformers' and use it here.
+        # For now, it uses a random vector, which WON'T give relevant results.
+        # Example (uncomment and install 'sentence-transformers'):
+        # from sentence_transformers import SentenceTransformer
+        # model = SentenceTransformer('all-MiniLM-L6-v2')
+        query_text = f"{travel_data.get('destination', '')} {travel_data.get('location_type', '')} {travel_data.get('province', '')} {' '.join(travel_data.get('preferences', []))}"
+        # query_vector = model.encode([query_text]).astype('float32') # Use this line with SentenceTransformers
+        query_vector = np.random.rand(1, index.d).astype('float32')  # Dummy vector - REPLACE THIS
+        # --- END IMPORTANT ---
+
+        k = 1
+        distances, indices = index.search(query_vector, k)
+
+        if indices.size > 0:
+            relevant_index = indices[0][0]
+            # Check if the index is valid for plan_data
+            if relevant_index in plan_data:
+                relevant_plan = plan_data[relevant_index]
+                print(f"Found relevant plan at index {relevant_index} with distance {distances[0][0]}")
+                return relevant_plan
+            else:
+                 # Try to map the index if plan_data is a list
+                if isinstance(plan_data, dict) and relevant_index < len(plan_data):
+                     plan_keys = list(plan_data.keys())
+                     mapped_key = plan_keys[relevant_index]
+                     relevant_plan = plan_data[mapped_key]
+                     print(f"Found relevant plan at mapped index {mapped_key} with distance {distances[0][0]}")
+                     return relevant_plan
+                else:
+                    print(f"No plan found at index {relevant_index}")
+
+    except FileNotFoundError:
+        print(f"Error: FAISS index or pickle file not found at {FAISS_INDEX_PATH} or {PKL_PATH}")
+        return None
+    except Exception as e:
+        print(f"Error in RAG functionality: {e}")
+        return None
+
+    print("No relevant plan found.")
+    return None

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn[standard]
+pydantic
+requests
+google-generativeai
+backoff
+python-dotenv
+faiss-cpu # Or faiss-gpu if you have a GPU and CUDA set up
+numpy
+google-generativeai
+# Add sentence-transformers if you implement real RAG embeddings
+# sentence-transformers