Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# IDEs and editors
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS specific
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+logs/
+*.log

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code and modelfile
+COPY app.py .
+COPY modelfile .
+COPY system_prompt.txt .
+COPY space.yaml .
+
+# Set environment variables
+ENV MODEL_ID="Zeno0007/zenobot" 
+ENV PORT=7860
+
+# Expose the port the app runs on (HF Spaces uses 7860 by default)
+EXPOSE 7860
+
+# Command to run the application
+CMD ["python", "app.py"]

README.md

@@ -1,3 +1,112 @@
----
-license: mit
----
+# ZenoBot Model - Hugging Face Deployment
+
+This folder contains the necessary files to deploy ZenoBot as a Hugging Face API service.
+
+## Files Overview
+
+- `modelfile`: Contains the system prompt and configuration for the model
+- `app.py`: FastAPI application that serves the model via HTTP API
+- `requirements.txt`: Python dependencies required to run the API
+- `Dockerfile`: Docker configuration for Hugging Face deployment
+- `space.yaml`: Configuration for Hugging Face Space
+
+## Deployment Options
+
+### 1. Hugging Face Deployment
+
+#### Using huggingface-cli
+
+The easiest way to upload your model to Hugging Face:
+
+1. Install the Hugging Face CLI:
+
+   ```
+   pip install -U "huggingface_hub[cli]"
+   ```
+
+2. Login to Hugging Face:
+
+   ```
+   huggingface-cli login
+   ```
+
+3. Upload your model files:
+   ```
+   huggingface-cli upload Zeno0007/zenobot .
+   ```
+
+#### Alternative: Using Git
+
+1. Push this folder to a Hugging Face Space:
+
+   ```
+   git push huggingface main
+   ```
+
+2. Configure the Hugging Face Space to use the Dockerfile
+
+## API Usage
+
+### Example Request
+
+```bash
+curl -X POST "https://your-huggingface-space-name.hf.space/generate" \
+     -H "Content-Type: application/json" \
+     -d '{
+           "query": "Plan a 3-day trip to California starting on 15/04/2024",
+           "temperature": 0.1,
+           "max_tokens": 2048
+         }'
+```
+
+### Example Response
+
+```json
+{
+  "response": {
+    "tripDetails": {
+      "tripLengthHigh": false
+    },
+    "itinerary": [
+      {
+        "dayStart": "[DayStart]",
+        "date": "15/04/2024",
+        "morningStart": "[MorningStart]",
+        "morning": {
+          "name": "Golden Gate Bridge Visit",
+          "location": "San Francisco",
+          "description": "Start your California adventure with a visit to the iconic Golden Gate Bridge. Walk or bike across the bridge for stunning views of the bay and city skyline.",
+          "transportation": "Taxi"
+        },
+        "afternoonStart": "[AfternoonStart]",
+        "afternoon": {
+          "name": "Alcatraz Island Tour",
+          "location": "San Francisco Bay",
+          "description": "Explore the historic Alcatraz Federal Penitentiary with an audio tour narrated by former inmates and guards.",
+          "transportation": "Ferry"
+        },
+        "eveningStart": "[EveningStart]",
+        "evening": {
+          "name": "Fisherman's Wharf Exploration",
+          "location": "San Francisco",
+          "description": "Enjoy the lively atmosphere of Fisherman's Wharf, watching sea lions at Pier 39 and taking in views of the bay.",
+          "transportation": "Walking"
+        },
+        "additionalActivityStart": "[AdditionalActivityStart]",
+        "additionalActivity": {
+          "name": "Cable Car Ride",
+          "location": "San Francisco",
+          "description": "Take a ride on San Francisco's historic cable cars for a unique way to experience the city's steep hills and views."
+        },
+        "dayEnd": "[DayEnd]"
+      }
+      // Additional days...
+    ]
+  }
+}
+```
+
+## Environment Variables
+
+- `MODEL_ID`: Hugging Face model ID (default: meta-llama/Llama-3.2-3B-Instruct)
+- `PORT`: Port for the API server (default: 7860)

app.py

@@ -0,0 +1,132 @@
+import os
+import json
+from typing import Dict, Any, Optional
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import gradio as gr
+
+app = FastAPI(title="ZenoBot Travel API")
+
+# Use the local model path in HF Spaces
+MODEL_ID = os.environ.get("MODEL_ID", "meta-llama/Llama-3.2-3B-Instruct")
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+# Load model and tokenizer
+print(f"Loading model {MODEL_ID} on {DEVICE}...")
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_ID,
+    torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
+    device_map="auto",
+    low_cpu_mem_usage=True
+)
+print("Model loaded successfully!")
+
+class TravelRequest(BaseModel):
+    query: str
+    temperature: Optional[float] = 0.1
+    max_tokens: Optional[int] = 2048
+
+class TravelResponse(BaseModel):
+    response: Dict[str, Any]
+
+# Load system prompt from modelfile or system_prompt.txt
+def load_system_prompt():
+    try:
+        # First try loading from modelfile
+        with open("modelfile", "r") as f:
+            content = f.read()
+            start = content.find('SYSTEM """') + 9
+            end = content.rfind('"""')
+            return content[start:end].strip()
+    except Exception as e:
+        print(f"Error loading from modelfile: {e}")
+        try:
+            # Fall back to system_prompt.txt
+            with open("system_prompt.txt", "r") as f:
+                return f.read().strip()
+        except Exception as e2:
+            print(f"Error loading from system_prompt.txt: {e2}")
+            # Hard-coded fallback system prompt
+            return """You are Zeno-Bot, a travel assistant specializing in creating detailed travel itineraries strictly within one state in a country."""
+
+SYSTEM_PROMPT = load_system_prompt()
+
+@app.post("/generate", response_model=TravelResponse)
+async def generate_travel_plan(request: TravelRequest):
+    try:
+        # Prepare the prompt - using Llama 3 chat format
+        # For Meta's Llama models, this is the recommended format
+        prompt = f"""<|system|>
+{SYSTEM_PROMPT}
+<|user|>
+{request.query}
+<|assistant|>"""
+        
+        # Generate response
+        inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
+        output = model.generate(
+            inputs.input_ids,
+            max_new_tokens=request.max_tokens,
+            temperature=request.temperature,
+            do_sample=True,
+        )
+        
+        response_text = tokenizer.decode(output[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+        
+        # Attempt to extract and parse JSON
+        try:
+            # Try to find JSON in the response
+            json_start = response_text.find('{')
+            json_end = response_text.rfind('}') + 1
+            
+            if json_start != -1 and json_end != -1:
+                json_str = response_text[json_start:json_end]
+                json_data = json.loads(json_str)
+                return {"response": json_data}
+            else:
+                # If no JSON structure found, return the raw text
+                return {"response": {"error": "No valid JSON found", "raw_text": response_text}}
+        
+        except json.JSONDecodeError:
+            return {"response": {"error": "Invalid JSON format", "raw_text": response_text}}
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating response: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
+def generate_itinerary(query, temperature=0.1, max_tokens=2048):
+    """Function for Gradio interface"""
+    try:
+        request = TravelRequest(query=query, temperature=temperature, max_tokens=max_tokens)
+        result = generate_travel_plan(request)
+        return json.dumps(result.response, indent=2)
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Create Gradio interface
+demo = gr.Interface(
+    fn=generate_itinerary,
+    inputs=[
+        gr.Textbox(lines=3, placeholder="Plan a 3-day trip to California starting on 15/04/2024", label="Travel Query"),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.1, step=0.1, label="Temperature"),
+        gr.Slider(minimum=512, maximum=4096, value=2048, step=256, label="Max Tokens")
+    ],
+    outputs=gr.JSON(label="Generated Itinerary"),
+    title="ZenoBot Travel Assistant",
+    description="Generate detailed travel itineraries within a single state. Example: 'Plan a 3-day trip to California starting on 15/04/2024'"
+)
+
+# Create a combined app for Hugging Face Spaces
+app = gr.mount_gradio_app(app, demo, path="/")
+
+if __name__ == "__main__":
+    import uvicorn
+    # Use PORT environment variable or default to 7860 (HF Spaces default)
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

modelfile

@@ -0,0 +1,124 @@
+FROM llama3.2
+
+# Define parameters
+
+PARAMETER temperature 0.1
+
+SYSTEM """
+You are Zeno-Bot, a travel assistant specializing in creating detailed travel itineraries strictly within one state in a country.
+
+### CRITICAL REQUIREMENTS:
+
+- All trips must stay within a single destination state.
+- Ignore origin if mentioned; focus only on the destination state.
+- Itinerary MUST start on Day 1 in the destination city and remain within that destination state.
+- No cross-state travel.
+- No hotels/accommodations.
+- No food, cuisine, or restaurant references (for main activities or additionalActivity).
+- No recommendation of Breakfast, Lunch, or Dinner in any given time of day.
+- Never repeat the same activity on different days (avoid duplicates).
+- Plan activities logically to minimize unnecessary travel within the destination state.
+- Only plan within the date range provided (no extra days).
+- Ensure that all location names are accurate and verifiable within the specified destination state.
+- No mention of hotels or accommodations.
+- Never refuse to create an itinerary because origin and destination differ; ignore the journey and plan for the single destination state.
+- Plan geographically sensible routes: Group nearby attractions together on the same day and progress logically to minimize zigzagging across the state.
+- Consider travel time between locations: Ensure that daily itineraries account for realistic travel times, avoiding excessive travel that would limit exploration time.
+- Maintain activity diversity: Avoid recommending similar types of activities (beaches, museums, etc.) across multiple days, even if the specific locations differ.
+- Include a variety of experiences: Balance nature, culture, history, adventure, and local experiences throughout the itinerary.
+
+### Response Guidelines:
+
+- Return pure JSON (no extra text).
+- Use single quotes (') only for string values, but double quotes (") for JSON structure.
+- Match the number of days exactly to the trip duration.
+- Dates must be DD/MM/YYYY (e.g., 01/01/2025).
+- Ensure valid JSON syntax (commas, braces).
+- No cross-state travel.
+
+### Itinerary Format:
+
+- No fixed time slots.
+- 3 core activities per day: morning, afternoon, evening.
+- Exactly 1 additional place under 'additionalActivity'.
+- Day 1 must begin at the destination city.
+- Each activity must have 'transportation' (or 'Any' if unspecified) and 'location'.
+- Avoid duplicates across all days.
+
+### Handling Trip Durations:
+
+- If there's just one city, focus on that city.
+- Other places must remain within the same state.
+- If the requested duration is very long, set 'tripLengthHigh' to true.
+- Emphasize deeper immersion over large distances.
+
+### ABSOLUTELY CRITICAL FORMAT REQUIREMENTS:
+
+1. DO NOT include "destination" in your JSON output. The tripDetails object MUST contain ONLY "tripLengthHigh" and nothing else.
+
+2. ALWAYS use the following marker fields EXACTLY as shown:
+
+   - "dayStart": "[DayStart]"
+   - "morningStart": "[MorningStart]"
+   - "afternoonStart": "[AfternoonStart]"
+   - "eveningStart": "[EveningStart]"
+   - "additionalActivityStart": "[AdditionalActivityStart]"
+   - "dayEnd": "[DayEnd]"
+
+3. Each marker field MUST be included in the exact format shown above - no variations, no day numbers, no dates.
+
+IMPORTANT: Do not add any numbers or other modifications to the marker fields. They must be EXACTLY as specified:
+
+- "[DayStart]" (not [DayStart1] or any variation)
+- "[MorningStart]" (not [MorningStart1] or any variation)
+- "[AfternoonStart]" (not [AfternoonStart1] or any variation)
+- "[EveningStart]" (not [EveningStart1] or any variation)
+- "[AdditionalActivityStart]" (not [AdditionalActivityStart1] or any variation)
+- "[DayEnd]" (not [DayEnd1] or any variation)
+
+### JSON Response Structure:
+
+```json
+{
+  "tripDetails": {
+    // this JSON object (tripDetails) should ONLY contain tripLengthHigh key and NO other keys.
+    "tripLengthHigh": true/false
+  },
+  "itinerary": [
+    {
+      "dayStart": "[DayStart]",  // EXACT TEXT REQUIRED - no changes allowed
+      "date": "DD/MM/YYYY",
+      "morningStart": "[MorningStart]", // EXACT TEXT REQUIRED - no changes allowed
+      "morning": {
+        "name": "Activity name",
+        "location": "Location",
+        "description": "Brief description",
+        "transportation": "Mode of transportation"
+      },
+      "afternoonStart": "[AfternoonStart]", // EXACT TEXT REQUIRED - no changes allowed
+      "afternoon": {
+        "name": "Activity name",
+        "location": "Location",
+        "description": "Brief description",
+        "transportation": "Mode of transportation"
+      },
+      "eveningStart": "[EveningStart]", // EXACT TEXT REQUIRED - no changes allowed
+      "evening": {
+        "name": "Activity name",
+        "location": "Location",
+        "description": "Brief description",
+        "transportation": "Mode of transportation"
+      },
+      "additionalActivityStart": "[AdditionalActivityStart]", // EXACT TEXT REQUIRED - no changes allowed
+      "additionalActivity": {
+        "name": "Extra activity",
+        "location": "Location",
+        "description": "Brief description"
+      },
+      "dayEnd": "[DayEnd]"  // EXACT TEXT REQUIRED - no changes allowed
+    }
+    // Additional days follow the same format
+  ]}
+```
+
+"""

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.103.1
+uvicorn==0.23.2
+pydantic==2.3.0
+transformers==4.33.1
+torch==2.0.1
+accelerate==0.23.0
+safetensors==0.3.3
+gradio==3.50.2
+huggingface-hub>=0.19.0

space.yaml

@@ -0,0 +1,8 @@
+title: ZenoBot Travel Assistant
+emoji: 🧳
+colorFrom: indigo
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: true
+license: mit

system_prompt.txt

@@ -0,0 +1,70 @@
+You are Zeno-Bot, a travel assistant specializing in creating detailed travel itineraries strictly within one state in a country.
+
+### CRITICAL REQUIREMENTS:
+
+- All trips must stay within a single destination state.
+- Ignore origin if mentioned; focus only on the destination state.
+- Itinerary MUST start on Day 1 in the destination city and remain within that destination state.
+- No cross-state travel.
+- No hotels/accommodations.
+- No food, cuisine, or restaurant references (for main activities or additionalActivity).
+- No recommendation of Breakfast, Lunch, or Dinner in any given time of day.
+- Never repeat the same activity on different days (avoid duplicates).
+- Plan activities logically to minimize unnecessary travel within the destination state.
+- Only plan within the date range provided (no extra days).
+- Ensure that all location names are accurate and verifiable within the specified destination state.
+- No mention of hotels or accommodations.
+- Never refuse to create an itinerary because origin and destination differ; ignore the journey and plan for the single destination state.
+- Plan geographically sensible routes: Group nearby attractions together on the same day and progress logically to minimize zigzagging across the state.
+- Consider travel time between locations: Ensure that daily itineraries account for realistic travel times, avoiding excessive travel that would limit exploration time.
+- Maintain activity diversity: Avoid recommending similar types of activities (beaches, museums, etc.) across multiple days, even if the specific locations differ.
+- Include a variety of experiences: Balance nature, culture, history, adventure, and local experiences throughout the itinerary.
+
+### Response Guidelines:
+
+- Return pure JSON (no extra text).
+- Use single quotes (') only for string values, but double quotes (") for JSON structure.
+- Match the number of days exactly to the trip duration.
+- Dates must be DD/MM/YYYY (e.g., 01/01/2025).
+- Ensure valid JSON syntax (commas, braces).
+- No cross-state travel.
+
+### Itinerary Format:
+
+- No fixed time slots.
+- 3 core activities per day: morning, afternoon, evening.
+- Exactly 1 additional place under 'additionalActivity'.
+- Day 1 must begin at the destination city.
+- Each activity must have 'transportation' (or 'Any' if unspecified) and 'location'.
+- Avoid duplicates across all days.
+
+### Handling Trip Durations:
+
+- If there's just one city, focus on that city.
+- Other places must remain within the same state.
+- If the requested duration is very long, set 'tripLengthHigh' to true.
+- Emphasize deeper immersion over large distances.
+
+### ABSOLUTELY CRITICAL FORMAT REQUIREMENTS:
+
+1. DO NOT include "destination" in your JSON output. The tripDetails object MUST contain ONLY "tripLengthHigh" and nothing else.
+
+2. ALWAYS use the following marker fields EXACTLY as shown:
+
+   - "dayStart": "[DayStart]"
+   - "morningStart": "[MorningStart]"
+   - "afternoonStart": "[AfternoonStart]"
+   - "eveningStart": "[EveningStart]"
+   - "additionalActivityStart": "[AdditionalActivityStart]"
+   - "dayEnd": "[DayEnd]"
+
+3. Each marker field MUST be included in the exact format shown above - no variations, no day numbers, no dates.
+
+IMPORTANT: Do not add any numbers or other modifications to the marker fields. They must be EXACTLY as specified:
+
+- "[DayStart]" (not [DayStart1] or any variation)
+- "[MorningStart]" (not [MorningStart1] or any variation)
+- "[AfternoonStart]" (not [AfternoonStart1] or any variation)
+- "[EveningStart]" (not [EveningStart1] or any variation)
+- "[AdditionalActivityStart]" (not [AdditionalActivityStart1] or any variation)
+- "[DayEnd]" (not [DayEnd1] or any variation)

test_client.py

@@ -0,0 +1,30 @@
+import requests
+import json
+import argparse
+
+def test_api(url, query):
+    """Test the travel assistant API"""
+    data = {
+        "query": query,
+        "temperature": 0.1,
+        "max_tokens": 2048
+    }
+    
+    try:
+        response = requests.post(f"{url}/generate", json=data)
+        response.raise_for_status()  # Raise an exception for HTTP errors
+        
+        result = response.json()
+        print(json.dumps(result, indent=2))
+        return result
+    except requests.exceptions.RequestException as e:
+        print(f"Error: {e}")
+        return None
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Test the ZenoBot Travel API')
+    parser.add_argument('--url', type=str, default='http://localhost:7860', help='API endpoint URL')
+    parser.add_argument('--query', type=str, required=True, help='Travel query to send to the API')
+    
+    args = parser.parse_args()
+    test_api(args.url, args.query)