Deploy: Godot Web build + HF Inference NPC dialogue (drop AWS)

README.md

@@ -49,7 +49,7 @@ As newcomers to Godot, we faced a steep learning curve, especially with our seme
 - Elevenlabs for audio generation
 - Notebook LM to quickly grasp concepts, even using an 8-hour YouTube video as input
 - Suno AI for creating background music
-- **Hugging Face Inference (Qwen2.5-7B-Instruct)** for NPC dialogue
+- **Hugging Face Inference (Qwen2.5-1.5B-Instruct)** for fast NPC dialogue
 - **Ziva.sh** (in-editor AI agent) and **AWS Q Developer** to help write GDScript code
 - **Hugging Face Spaces** to host both the game and the AI dialogue endpoint
 

app.py

@@ -1,162 +1,74 @@
 import os
 import time
+import mimetypes
 
-import gradio as gr
+from dotenv import load_dotenv
 from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
-from dotenv import load_dotenv
 from huggingface_hub import InferenceClient
 
+
 load_dotenv()
 
-# --- Configuration -----------------------------------------------------------
-# Set HF_TOKEN as a Space secret (Settings -> Repository secrets). The token only
-# needs "Make calls to Inference Providers" permission. Without it the app falls
-# back to a mock response so the deployment still builds and runs.
 HF_TOKEN = os.getenv("HF_TOKEN")
-
-# Cheapest reliably-served conversational model with good quality-per-cost.
-# Swap this for Qwen/Qwen2.5-1.5B-Instruct (cheaper) or any chat model served by
-# Hugging Face Inference Providers: https://huggingface.co/models?inference_provider=all
-MODEL_ID = "Qwen/Qwen2.5-7B-Instruct"
-
+MODEL_ID = os.getenv("MODEL_ID", "Qwen/Qwen2.5-1.5B-Instruct")
 GAME_DIR = "game"
 
+MAX_TOKENS = 80
+TEMPERATURE = 0.5
+TOP_P = 0.85
+
 client = InferenceClient(token=HF_TOKEN) if HF_TOKEN else None
 
+mimetypes.add_type("application/wasm", ".wasm")
+mimetypes.add_type("application/octet-stream", ".pck")
 
-def generate_reply(prompt: str) -> str:
-    """Call Hugging Face Inference (OpenAI-compatible router) for NPC dialogue."""
-    full_prompt = prompt + ". Strictly respond in plain text, limited to 4 sentences."
 
+def generate_reply(prompt: str) -> str:
+    """Generate short NPC dialogue for the Godot game."""
     if client is None:
-        time.sleep(0.5)
-        return (
-            "Mocked response. The wasteland is quiet today, traveler. "
-            "(Set the HF_TOKEN secret to enable real AI dialogue. "
-            "Get a token at https://huggingface.co/settings/tokens)"
-        )
-
-    print(f"Calling Hugging Face Inference: model={MODEL_ID}")
-    start_time = time.time()
+        time.sleep(0.2)
+        return "The air is calm today. Bring what you find, and we will make it useful."
 
+    start_time = time.time()
     completion = client.chat.completions.create(
         model=MODEL_ID,
-        messages=[{"role": "user", "content": full_prompt}],
-        max_tokens=200,
-        temperature=0.6,
-        top_p=0.9,
+        messages=[
+            {
+                "role": "system",
+                "content": (
+                    "You are an NPC in the post-nuclear RPG Shadows of Tomorrow. "
+                    "Answer in plain text only, with 1 or 2 short natural sentences."
+                ),
+            },
+            {"role": "user", "content": prompt},
+        ],
+        max_tokens=MAX_TOKENS,
+        temperature=TEMPERATURE,
+        top_p=TOP_P,
     )
-
-    print(f"Took={time.time() - start_time:.2f}s")
+    print(f"HF inference model={MODEL_ID} took={time.time() - start_time:.2f}s")
     return completion.choices[0].message.content.strip()
 
 
-def get_ai_response(prompt):
-    """Gradio tester-tab handler. Returns the same shape the game expects."""
-    try:
-        if not prompt:
-            return {"error": "Missing prompt"}
-        return {"output": generate_reply(prompt)}
-    except Exception as e:
-        return {"error": f"Inference error: {str(e)}"}
-
+app = FastAPI()
 
-# --- Gradio UI ---------------------------------------------------------------
-with gr.Blocks(title="Shadows of Tomorrow - AWS Game Hackathon") as demo:
-    gr.Markdown(
-        """
-    # 🎮 Shadows of Tomorrow
-    ### An RPG Adventure Set in Post-Nuclear 2200
 
-    Welcome to Magnus Province! Built with Godot 4.3, with AI-powered NPC
-    dialogue served by **Hugging Face Inference** (Qwen2.5-7B-Instruct).
+@app.get("/", include_in_schema=False)
+async def root():
+    """Make the Space open straight into the fullscreen Godot web export."""
+    return RedirectResponse(url="/game/index.html", status_code=307)
 
-    **Game Controls:**
-    - WASD / Arrow Keys: Move
-    - E: Interact
-    - Left Mouse Click: Shoot
-    - Tab: Toggle Inventory
-    """
-    )
 
-    with gr.Tab("🎮 Play Game"):
-        gr.HTML(
-            """
-        <div style="display: flex; justify-content: center; align-items: center; padding: 20px;">
-            <iframe
-                src="/game/index.html"
-                width="1920"
-                height="1080"
-                style="border: 2px solid #333; border-radius: 8px; background: #000; max-width: 100%; max-height: 80vh;"
-                allow="autoplay; fullscreen"
-                allowfullscreen>
-            </iframe>
-        </div>
-        """
-        )
-        gr.Markdown(
-            "### 📝 Note\nIf the game doesn't load, the Godot Web export hasn't been "
-            "placed in the `game/` folder yet. Click inside the game area to capture keyboard input."
-        )
-
-    with gr.Tab("🤖 AI Dialogue Tester"):
-        gr.Markdown(
-            """
-        ### Test the NPC Dialogue System
-        This is the same AI system used for NPC conversations in the game,
-        powered by Hugging Face Inference (Qwen2.5-7B-Instruct).
-        """
-        )
-        with gr.Row():
-            with gr.Column():
-                prompt_input = gr.Textbox(
-                    label="Enter NPC Prompt",
-                    placeholder="Example: You are a farmer in Magnus Province. Discuss renewable energy...",
-                    lines=5,
-                )
-                submit_btn = gr.Button("Generate Response", variant="primary")
-            with gr.Column():
-                response_output = gr.JSON(label="AI Response")
-
-        submit_btn.click(fn=get_ai_response, inputs=[prompt_input], outputs=[response_output])
-
-        gr.Examples(
-            examples=[
-                ["You are Delano, a farmer. Discuss innovative farming methods in a post-nuclear world."],
-                ["You are a Nova Force officer. Explain how food security is maintained in Magnus Province."],
-                ["You are a scientist. Discuss methods to combat contaminated soil after the nuclear disaster."],
-            ],
-            inputs=[prompt_input],
-        )
-
-    with gr.Tab("📖 About"):
-        gr.Markdown(
-            """
-        ## Technologies
-        - **Godot 4.3** — Game engine
-        - **Hugging Face Inference (Qwen2.5-7B-Instruct)** — NPC dialogue
-        - **Hugging Face Spaces** — Free hosting for the game + AI endpoint
-        - **FLUX-dev / ElevenLabs / Suno AI** — Image, audio, and music generation
-
-        ## How the AI works
-        NPC prompts are POSTed to this Space's `/ai-response` endpoint, which proxies
-        the request to Hugging Face Inference using the server-side `HF_TOKEN` secret —
-        so no API keys are ever exposed in the browser game.
-
-        [GitHub Repository](https://github.com/Reubencfernandes/aws-game-hackathon)
-        """
-        )
-
-
-# --- FastAPI app: AI endpoint + static game + mounted Gradio ------------------
-app = FastAPI()
+@app.get("/healthz")
+async def healthz():
+    return {"ok": True, "model": MODEL_ID}
 
 
 @app.post("/ai-response")
 async def ai_response(request: Request):
-    """Endpoint the Godot game POSTs to. Contract: {"prompt": str} -> {"output": str}."""
+    """Contract used by Godot: {"prompt": str} -> {"output": str}."""
     try:
         data = await request.json()
     except Exception:
@@ -169,19 +81,14 @@ async def ai_response(request: Request):
     try:
         return {"output": generate_reply(prompt)}
     except Exception as e:
-        print(f"Error: {str(e)}")
+        print(f"Inference error: {e}")
         return JSONResponse({"error": str(e)}, status_code=500)
 
 
-# Serve the exported Godot Web build (game/index.html, *.wasm, *.pck, ...).
-# html=True makes /game/ resolve to index.html.
 if os.path.isdir(GAME_DIR):
     app.mount("/game", StaticFiles(directory=GAME_DIR, html=True), name="game")
 else:
-    print(f"WARNING: '{GAME_DIR}/' not found — export the Godot Web build there before deploying.")
-
-# Mount the Gradio UI at the root. Registered last so /ai-response and /game win.
-app = gr.mount_gradio_app(app, demo, path="/")
+    print(f"WARNING: '{GAME_DIR}/' not found. Export the Godot Web build before deploying.")
 
 
 if __name__ == "__main__":