feat: city_context: Add real-world city context from Wikipedia to generation prompt

app/prompts/game_generation.txt

@@ -12,6 +12,11 @@ Generate a location-based game in strict JSON format.
 ## Retrieved Examples
 {retrieved_examples}
 
+## City Context (real-world reference data)
+{city_context}
+
+**Instructions:** Use the task patterns and game structures from the Retrieved Examples, but adapt them to fit the City Context above — replace Paris-specific locations with real landmarks, districts, and parks from the target city.
+
 ## Safety
 - NO entering buildings or private property
 - NO proximity to water, traffic, or rail lines

app/services/city_context.py

@@ -0,0 +1,216 @@
+"""City context enrichment via Wikipedia API.
+
+Fetches real landmarks, districts, parks, and geographic data for any city
+in the world — making the AI generation location-aware without needing to
+expand the local dataset.
+"""
+
+import json
+import re
+from typing import Optional
+from urllib.request import urlopen, Request
+from urllib.error import URLError
+from urllib.parse import urlencode
+
+
+# ── Simple in-memory cache ───────────────────────────────────────────────
+_cache: dict[str, dict] = {}
+
+USER_AGENT = "CityQuestAI/1.0 (hackathon; mailto:cityquest@example.com)"
+
+
+def _wikipedia_api(action: str, params: dict) -> Optional[dict]:
+    """Call the Wikipedia API and return parsed JSON."""
+    params["action"] = action
+    params["format"] = "json"
+    query = urlencode(params)
+    url = f"https://en.wikipedia.org/w/api.php?{query}"
+
+    try:
+        req = Request(url, headers={"User-Agent": USER_AGENT})
+        with urlopen(req, timeout=10) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except (URLError, OSError, json.JSONDecodeError) as e:
+        print(f"[city] Wikipedia API error: {e}")
+        return None
+
+
+def _fetch_city_context(city: str) -> Optional[dict]:
+    """Fetch city information from Wikipedia.
+
+    Returns a dict with:
+        - ``landmarks``: list of notable landmarks
+        - ``districts``: list of neighbourhoods/districts
+        - ``parks``: list of parks/green spaces
+        - ``description``: short city description (2-3 sentences)
+    """
+    result = {
+        "landmarks": [],
+        "districts": [],
+        "parks": [],
+        "description": "",
+    }
+
+    # Handle common disambiguation cases
+    city_variants = [city]
+    if city.lower() == "new york":
+        city_variants.append("New York City")
+    elif city.lower() == "nyc":
+        city_variants = ["New York City"]
+    elif city.lower() in ("la", "los angeles"):
+        city_variants = ["Los Angeles"]
+
+    for variant in city_variants:
+        # Single API call — get the full page text
+        data = _wikipedia_api("query", {
+            "titles": variant,
+            "prop": "extracts",
+            "explaintext": "1",
+            "redirects": "1",
+        })
+        if not data:
+            continue
+
+        pages = data.get("query", {}).get("pages", {})
+        if not pages:
+            continue
+
+        page_id = next(iter(pages.keys()))
+        if page_id == "-1":
+            print(f"[city] No Wikipedia page found for '{variant}'")
+            continue
+
+        extract = pages[page_id].get("extract", "")
+        if not extract:
+            continue
+
+        # Description = first paragraph
+        paragraphs = [p.strip() for p in extract.split("\n\n") if p.strip()]
+        if paragraphs:
+            result["description"] = paragraphs[0][:600].strip()
+
+        # ── Landmark extraction ────────────────────────────────────────
+        # Wikipedia uses bullet lists (*) for landmarks/sights/tourist attractions
+        # Also look for sentences with landmark keywords in the first 50 paragraphs
+        landmark_candidates = set()
+        for para in paragraphs[:50]:
+            # Bullet-point lists are the best signal
+            if para.startswith("*"):
+                for line in para.split("\n"):
+                    line = line.strip()
+                    if line.startswith("*"):
+                        clean = re.sub(r"^[*]\s*", "", line)
+                        clean = re.sub(r"\[.*?\]", "", clean)
+                        clean = re.sub(r"\s*\(.*?\)\s*", " ", clean).strip()
+                        if 10 < len(clean) < 300:
+                            landmark_candidates.add(clean)
+
+            # Plain sentences mentioning known attraction types
+            elif any(word in para.lower() for word in [
+                "landmark", "attraction", "museum", "cathedral", "square",
+                "monument", "palace", "garden", "market", "tower",
+                "bridge", "theatre", "gallery", "castle", "temple",
+                "shrine", "stadium", "park", "beach", "harbour",
+            ]):
+                for sent in re.split(r"(?<=[.!?])\s+", para):
+                    if any(word in sent.lower() for word in [
+                        "square", "museum", "cathedral", "church", "bridge",
+                        "tower", "palace", "garden", "market", "theatre",
+                        "gallery", "monument", "castle", "station", "stadium",
+                        "temple", "shrine", "mosque", "plaza", "fountain",
+                        "statue", "memorial", "opera", "aquarium", "zoo",
+                        "beach", "waterfront", "basilica", "fort", "hall",
+                    ]) and len(sent) > 20 and len(sent) < 300:
+                        clean = re.sub(r"\[.*?\]", "", sent).strip()
+                        landmark_candidates.add(clean)
+
+        # ── District/neighbourhood extraction ──────────────────────────
+        districts = set()
+        for para in paragraphs[:40]:
+            lower = para.lower()
+            if any(word in lower for word in ["district", "neighbourhood", "neighborhood", "quarter"]):
+                # Extract capitalized proper nouns near these keywords
+                for match in re.finditer(
+                    r"\b([A-Z][a-zéèêëàâîïôûùçüöäñ]+(?:\s[A-Z][a-zéèêëàâîïôûùçüöäñ]+)*)\s+(district|neighbourhood|neighborhood|quarter)",
+                    para,
+                ):
+                    name = match.group(1).strip()
+                    if name.lower() != city.lower() and 3 < len(name) < 40:
+                        districts.add(name)
+
+        # ── Park extraction ────────────────────────────────────────────
+        parks = set()
+        for match in re.finditer(
+            r"\b([A-Z][a-zéèêëàâîïôûùçüöäñ]+(?:\s[A-Z][a-zéèêëàâîïôûùçüöäñ]+)*)\s+(Park|Gardens|Garden|Forest|Reserve)\b",
+            extract,
+        ):
+            name = match.group(0).strip()
+            if 5 < len(name) < 50:
+                parks.add(name)
+
+        # Assign results to the output dict
+        result["landmarks"] = sorted(landmark_candidates, key=len)[:10]
+        result["districts"] = sorted(districts, key=len)[:8]
+        result["parks"] = sorted(parks, key=len)[:5]
+
+        break  # first successful variant wins
+
+    return result
+
+
+def get_city_context(city: str) -> dict:
+    """Get city context, using a simple in-memory cache.
+
+    Args:
+        city: City name (e.g. "Tokyo", "New York", "Berlin").
+
+    Returns:
+        Dict with keys ``landmarks``, ``districts``, ``parks``, ``description``.
+        If the fetch fails, returns empty lists and a generic description.
+    """
+    key = city.strip().lower()
+    if key not in _cache:
+        print(f"[city] Fetching context for '{city}' …")
+        ctx = _fetch_city_context(city)
+        if ctx is None:
+            ctx = {
+                "landmarks": [],
+                "districts": [],
+                "parks": [],
+                "description": f"{city} is a major city.",
+            }
+        _cache[key] = ctx
+        print(f"[city] Got {len(ctx['landmarks'])} landmarks, "
+              f"{len(ctx['districts'])} districts, {len(ctx['parks'])} parks")
+    return _cache[key]
+
+
+def build_city_section(city: str) -> str:
+    """Build a human-readable 'City Context' section for a prompt.
+
+    Args:
+        city: City name.
+
+    Returns:
+        A multi-line string to inject into the game generation prompt.
+    """
+    ctx = get_city_context(city)
+
+    lines = [f"### {city}"]
+    if ctx.get("description"):
+        lines.append(ctx["description"])
+
+    if ctx.get("districts"):
+        lines.append("\n**Notable districts/neighbourhoods:**")
+        lines.append(", ".join(ctx["districts"][:6]))
+
+    if ctx.get("parks"):
+        lines.append("\n**Parks & green spaces (great for outdoor games):**")
+        lines.append(", ".join(ctx["parks"][:4]))
+
+    if ctx.get("landmarks"):
+        lines.append("\n**Notable landmarks/monuments:**")
+        for lm in ctx["landmarks"][:6]:
+            lines.append(f"- {lm[:120]}")
+
+    return "\n".join(lines)

app/services/generator.py

@@ -105,6 +105,17 @@ def build_generation_prompt(config: dict, retrieved_examples: list[dict]) -> str
             for task in ex.get('task_patterns', [])[:2]:
                 examples_str += f"  • {task.get('task_id')}: {task.get('points')} pts ({task.get('proof_type')})\n"
 
+    # ── Live city context via Wikipedia ─────────────────────────────────
+    # Inject real landmarks, districts, and parks so the model generates
+    # location-accurate content even for cities not in the dataset.
+    city = config.get('city', 'Paris')
+    city_context_str = ""
+    try:
+        from app.services.city_context import build_city_section
+        city_context_str = build_city_section(city)
+    except Exception as e:
+        print(f"[prompt] Wikipedia city context unavailable: {e}")
+
     # Load prompt template
     template_path = Path("app/prompts/game_generation.txt")
     if template_path.exists():
@@ -123,7 +134,7 @@ def build_generation_prompt(config: dict, retrieved_examples: list[dict]) -> str
 
     # Build prompt with all context
     prompt = template.format(
-        city=config.get('city', 'Paris'),
+        city=city,
         area=config.get('area', 'downtown'),
         game_type=config.get('game_type', 'scavenger_hunt'),
         duration_minutes=config.get('duration_minutes', 45),
@@ -132,6 +143,7 @@ def build_generation_prompt(config: dict, retrieved_examples: list[dict]) -> str
         age_group=config.get('age_group', 'adults'),
         location_type=config.get('location_type', 'mixed'),
         retrieved_examples=examples_str,
+        city_context=city_context_str,
         output_schema=schema_str,
     )