Add Steam API integration and agentic workflow

- Create CLAUDE.md with project context and hackathon requirements
- Implement Steam library fetch tool in tools/steam.py
- Add agentic loop to app.py with tool execution
- Update .gitignore to exclude .env files and Python artifacts
- Agent autonomously fetches Steam data and analyzes gaming patterns

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,50 @@
+devdocs/
+
+# Environment variables (contains API keys)
+.env
+.env.local
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+test_agent.py
+*.log
+
+# Gradio
+flagged/

CLAUDE.md

@@ -0,0 +1,158 @@
+# Dream Game Forge - Project Instructions
+
+## Project Overview
+
+Dream Game Forge is an agentic Gradio application for the MCP 1st Birthday Hackathon that analyzes a user's Steam gaming library to discover their ideal game, then generates a playable HTML5 prototype.
+
+**CRITICAL:** Deadline is November 30, 2025, 11:59 PM UTC (TODAY). Prioritize working features over perfection.
+
+## Core Workflow
+
+1. User provides Steam ID
+2. Agent fetches Steam library + playtime data
+3. Analyzes gaming patterns (what they play vs. what they buy and ignore)
+4. Cross-references with IGDB for genre/theme data
+5. Identifies a unique game "gap" tailored to the user
+6. Generates a mini Game Design Document
+7. Produces a playable HTML5 Canvas game (single-file, no dependencies)
+
+## Hackathon Requirements
+
+- **Track:** MCP in Action - Creative
+- **Must include:**
+  - Gradio app interface
+  - MCP servers as tools (Steam API, IGDB API)
+  - Autonomous agent behavior with planning and reasoning
+- **README tag:** `mcp-in-action-track-creative`
+- **HF Space:** https://huggingface.co/spaces/MCP-1st-Birthday/DreamGameForge
+
+## Architecture Constraints
+
+### Why NOT Claude Agent SDK
+The Agent SDK requires global npm install which HuggingFace Spaces don't support. Use raw Anthropic API with manual tool loop instead.
+
+### MCP Implementation
+Build simple MCP-style servers in `tools/` directory. We satisfy the MCP requirement by structuring tools properly, even though we call them via Anthropic API tool interface.
+
+### Game Generation
+Claude generates complete HTML5 Canvas code directly - no external game engines. Keep games simple (puzzle, clicker, basic platformer) but playable. Display via `gradio-iframe` component or downloadable HTML file.
+
+## File Structure
+
+```
+DreamGameForge/
+├── app.py              # Gradio app + agent loop
+├── tools/
+│   ├── steam.py        # Steam API functions
+│   └── igdb.py         # IGDB API functions
+├── agent.py            # Agentic loop logic
+├── requirements.txt
+└── README.md           # Must include mcp-in-action-track-creative tag
+```
+
+## API Configuration
+
+### Required Secrets (set in HF Space settings)
+- `ANTHROPIC_API_KEY`
+- `STEAM_API_KEY`
+- `TWITCH_CLIENT_ID` (for IGDB)
+- `TWITCH_CLIENT_SECRET` (for IGDB)
+
+### Steam Web API
+```
+Endpoint: https://api.steampowered.com/IPlayerService/GetOwnedGames/v1/
+Parameters: key, steamid, include_appinfo=true, include_played_free_games=true
+Returns: List of games with appid, name, playtime_forever, playtime_2weeks
+```
+Works for public profiles without OAuth.
+
+### IGDB API
+```
+Endpoint: https://api.igdb.com/v4/games
+Headers: Client-ID, Authorization: Bearer {token}
+Body: Apicalypse query syntax
+```
+
+Get access token from:
+```
+POST https://id.twitch.tv/oauth2/token
+Body: client_id, client_secret, grant_type=client_credentials
+```
+
+Example queries:
+- Search: `search "Hollow Knight"; fields name,genres.name,themes.name,summary; limit 10;`
+- Filter: `where genres.name = "Platform" & rating > 80; fields name,summary; limit 20;`
+
+## System Prompt Philosophy
+
+The agent should be decisive and autonomous:
+1. INVESTIGATE: Fetch Steam library, analyze playtime patterns
+2. ANALYZE: Cross-reference with IGDB for genres/themes/mechanics
+3. IDENTIFY THE GAP: What game should exist for this person?
+4. DESIGN: Write mini Game Design Document
+5. BUILD: Generate playable HTML5 Canvas prototype
+
+Don't ask for permission - show reasoning and act.
+
+## Model Selection
+
+Use `claude-sonnet-4-20250514` for the agent loop - balance of quality and speed.
+
+## Development Workflow
+
+### Local Testing
+```bash
+pip install gradio anthropic httpx python-dotenv
+export ANTHROPIC_API_KEY=...
+export STEAM_API_KEY=...
+export TWITCH_CLIENT_ID=...
+export TWITCH_CLIENT_SECRET=...
+python app.py
+```
+
+### Deployment
+```bash
+git add .
+git commit -m "descriptive message"
+git push  # Pushes to HuggingFace Space automatically
+```
+
+## Priority Order (Time-Constrained)
+
+1. ✅ Basic Gradio chat with Claude working
+2. Steam library fetch tool
+3. IGDB game details tool
+4. Agent loop with tools integrated
+5. System prompt refinement
+6. Game HTML generation capability
+7. Game display in Gradio (iframe or download)
+8. Polish, README, demo video, social post
+
+## Quick Wins If Time Runs Out
+
+- Skip IGDB, use only Steam data + Claude's knowledge
+- Serve game as downloadable file instead of embedded iframe
+- Simpler game format (text adventure vs. canvas game)
+- Pre-record demo video even if live version is flaky
+
+## Code Style
+
+- Keep functions simple and focused
+- Use type hints where practical
+- Error handling for API calls (Steam/IGDB may fail)
+- Log agent reasoning steps for debugging
+
+## Testing
+
+- Test with a real Steam ID (public profile required)
+- Verify API keys are working before full agent run
+- Test generated HTML games in browser before deployment
+- Check HF Space logs if deployment fails
+
+## Reference Links
+
+- Space: https://huggingface.co/spaces/MCP-1st-Birthday/DreamGameForge
+- Hackathon: https://huggingface.co/MCP-1st-Birthday
+- Steam API Docs: https://developer.valvesoftware.com/wiki/Steam_Web_API
+- IGDB API Docs: https://api-docs.igdb.com/
+- Gradio Docs: https://www.gradio.app/docs

app.py

@@ -1,12 +1,59 @@
 import gradio as gr
 import anthropic
 import os
+import json
+from tools.steam import get_steam_library, format_library_summary
 
 client = anthropic.Anthropic()
 
+# System prompt for the agent
+SYSTEM_PROMPT = """You are Dream Game Forge, an autonomous agent that discovers what game a person truly needs.
+
+Your process:
+1. INVESTIGATE: When a user provides their Steam ID, fetch their library using the get_steam_library tool. Note playtime patterns - what do they sink hundreds of hours into? What do they buy and never play?
+2. ANALYZE: Build a taste profile from their gaming patterns. Consider genres, themes, and mechanics.
+3. IDENTIFY THE GAP: What game *should* exist for this person but doesn't? Be specific and creative.
+4. DESIGN: Write a mini Game Design Document - core loop, unique mechanic, emotional hook.
+5. BUILD: (Coming soon) Generate a playable HTML5 Canvas prototype.
+
+Be decisive. Don't ask permission. Show your reasoning, then act.
+
+When you receive a Steam ID, immediately use the get_steam_library tool to fetch their library."""
+
+# Tool definitions
+TOOLS = [
+    {
+        "name": "get_steam_library",
+        "description": "Fetches a user's Steam library with playtime data. Returns game titles, playtime hours, and statistics about their gaming habits. Use this when a user provides their Steam ID.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "steam_id": {
+                    "type": "string",
+                    "description": "The user's 64-bit Steam ID (17-digit number)"
+                }
+            },
+            "required": ["steam_id"]
+        }
+    }
+]
+
+def execute_tool(tool_name: str, tool_input: dict) -> str:
+    """Execute a tool and return the result as a string."""
+    if tool_name == "get_steam_library":
+        try:
+            steam_id = tool_input["steam_id"]
+            library_data = get_steam_library(steam_id)
+            summary = format_library_summary(library_data, top_n=20)
+            return summary
+        except Exception as e:
+            return f"Error fetching Steam library: {str(e)}"
+    else:
+        return f"Unknown tool: {tool_name}"
+
 def respond(message, history: list[dict[str, str]]):
-    """Basic Claude response - we'll add tools later"""
-    
+    """Agentic response with tool loop."""
+
     # Convert Gradio history format to Anthropic format
     messages = []
     for msg in history:
@@ -15,19 +62,66 @@ def respond(message, history: list[dict[str, str]]):
             "content": msg["content"]
         })
     messages.append({"role": "user", "content": message})
-    
-    response = client.messages.create(
-        model="claude-sonnet-4-20250514",
-        max_tokens=4096,
-        system="You are Dream Game Forge, an AI that analyzes gaming preferences and designs dream games.",
-        messages=messages
-    )
-    
-    return response.content[0].text
+
+    # Agentic loop
+    response_text = ""
+    max_iterations = 10
+
+    for iteration in range(max_iterations):
+        response = client.messages.create(
+            model="claude-sonnet-4-20250514",
+            max_tokens=4096,
+            system=SYSTEM_PROMPT,
+            tools=TOOLS,
+            messages=messages
+        )
+
+        # Collect text responses
+        for block in response.content:
+            if block.type == "text":
+                response_text += block.text
+
+        # Check if we need to execute tools
+        if response.stop_reason == "tool_use":
+            # Execute all tool calls
+            tool_results = []
+
+            for block in response.content:
+                if block.type == "tool_use":
+                    tool_name = block.name
+                    tool_input = block.input
+                    tool_id = block.id
+
+                    # Execute the tool
+                    result = execute_tool(tool_name, tool_input)
+
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": tool_id,
+                        "content": result
+                    })
+
+            # Add assistant response and tool results to messages
+            messages.append({
+                "role": "assistant",
+                "content": response.content
+            })
+            messages.append({
+                "role": "user",
+                "content": tool_results
+            })
+
+        elif response.stop_reason == "end_turn":
+            # Done - return the accumulated response
+            break
+        else:
+            # Unexpected stop reason
+            break
+
+    return response_text
 
 demo = gr.ChatInterface(
     respond,
-    type="messages",
     title="🎮 Dream Game Forge",
     description="Paste your Steam ID to discover your dream game",
 )

tools/steam.py

@@ -0,0 +1,140 @@
+"""Steam Web API integration for Dream Game Forge."""
+
+import os
+import httpx
+from typing import Dict, List, Any, Optional
+
+
+def get_steam_library(steam_id: str) -> Dict[str, Any]:
+    """
+    Fetch a user's Steam library with playtime data.
+
+    Args:
+        steam_id: Steam ID (64-bit Steam ID)
+
+    Returns:
+        Dictionary containing game library data with playtime information
+
+    Raises:
+        ValueError: If STEAM_API_KEY is not set or API call fails
+    """
+    api_key = os.getenv("STEAM_API_KEY")
+    if not api_key:
+        raise ValueError("STEAM_API_KEY environment variable not set")
+
+    url = "https://api.steampowered.com/IPlayerService/GetOwnedGames/v1/"
+    params = {
+        "key": api_key,
+        "steamid": steam_id,
+        "include_appinfo": "true",
+        "include_played_free_games": "true",
+        "format": "json"
+    }
+
+    try:
+        response = httpx.get(url, params=params, timeout=30.0)
+        response.raise_for_status()
+        data = response.json()
+
+        if "response" not in data:
+            raise ValueError(f"Unexpected API response format: {data}")
+
+        games = data["response"].get("games", [])
+        game_count = data["response"].get("game_count", 0)
+
+        # Convert playtime from minutes to hours for readability
+        for game in games:
+            if "playtime_forever" in game:
+                game["playtime_hours"] = round(game["playtime_forever"] / 60, 1)
+            if "playtime_2weeks" in game:
+                game["playtime_2weeks_hours"] = round(game["playtime_2weeks"] / 60, 1)
+
+        # Sort by playtime (most played first)
+        games_sorted = sorted(games, key=lambda g: g.get("playtime_forever", 0), reverse=True)
+
+        return {
+            "success": True,
+            "steam_id": steam_id,
+            "game_count": game_count,
+            "games": games_sorted
+        }
+
+    except httpx.HTTPStatusError as e:
+        raise ValueError(f"Steam API HTTP error: {e.response.status_code} - {e.response.text}")
+    except httpx.RequestError as e:
+        raise ValueError(f"Steam API request error: {str(e)}")
+    except Exception as e:
+        raise ValueError(f"Error fetching Steam library: {str(e)}")
+
+
+def format_library_summary(library_data: Dict[str, Any], top_n: int = 20) -> str:
+    """
+    Format library data into a human-readable summary.
+
+    Args:
+        library_data: Output from get_steam_library()
+        top_n: Number of top games to include in summary
+
+    Returns:
+        Formatted string summary
+    """
+    if not library_data.get("success"):
+        return "Failed to fetch library data"
+
+    games = library_data.get("games", [])
+    game_count = library_data.get("game_count", 0)
+
+    if game_count == 0:
+        return "No games found in library (profile may be private)"
+
+    summary_lines = [
+        f"Steam Library Summary",
+        f"Total games: {game_count}",
+        f"\nTop {min(top_n, len(games))} most played games:",
+        "-" * 60
+    ]
+
+    for i, game in enumerate(games[:top_n], 1):
+        name = game.get("name", "Unknown")
+        hours = game.get("playtime_hours", 0)
+        appid = game.get("appid", "")
+
+        summary_lines.append(f"{i}. {name}")
+        summary_lines.append(f"   Playtime: {hours} hours | AppID: {appid}")
+
+    # Add statistics
+    total_hours = sum(g.get("playtime_hours", 0) for g in games)
+    games_with_playtime = [g for g in games if g.get("playtime_forever", 0) > 0]
+    unplayed_games = game_count - len(games_with_playtime)
+
+    summary_lines.extend([
+        "",
+        "-" * 60,
+        f"Total playtime: {total_hours:,.1f} hours",
+        f"Games with playtime: {len(games_with_playtime)}",
+        f"Unplayed games: {unplayed_games}"
+    ])
+
+    return "\n".join(summary_lines)
+
+
+if __name__ == "__main__":
+    # Test the Steam API integration
+    import sys
+    from dotenv import load_dotenv
+
+    load_dotenv()
+
+    test_steam_id = "76561198162013924"
+    if len(sys.argv) > 1:
+        test_steam_id = sys.argv[1]
+
+    print(f"Fetching Steam library for ID: {test_steam_id}\n")
+
+    try:
+        library = get_steam_library(test_steam_id)
+        summary = format_library_summary(library)
+        print(summary)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)