Implement comprehensive IGDB integration for real-time game information

## Major Features Added

- **Enhanced igdblib.py**:
  * Added search_games() method with fuzzy game search
  * Added get_game_details() for comprehensive game information
  * Added AI-friendly data formatting with _format_game_for_ai()
  * Added OpenAI function definitions via get_openai_functions()

- **OpenAI Function Calling Integration**:
  * Modified OpenAIResponder to support function calling
  * Added IGDB function execution with _execute_igdb_function()
  * Backward compatible - gracefully falls back if IGDB unavailable
  * Auto-detects gaming queries and fetches real-time data

- **Configuration & Setup**:
  * Added IGDB configuration options to config.toml
  * Updated system prompt to inform AI of gaming capabilities
  * Added comprehensive IGDB_SETUP.md documentation
  * Graceful initialization with proper error handling

## Technical Implementation

- **Function Calling**: Uses OpenAI's tools/function calling API
- **Smart Game Search**: Includes ratings, platforms, developers, genres
- **Error Handling**: Robust fallbacks and logging
- **Data Formatting**: Optimized for AI comprehension and user presentation
- **Rate Limiting**: Respects IGDB API limits

## Usage

Users can now ask natural gaming questions:
- "Tell me about Elden Ring"
- "What are good RPG games from 2023?"
- "Is Cyberpunk 2077 on PlayStation?"

The AI automatically detects gaming queries, calls IGDB API, and presents
accurate, real-time game information seamlessly.

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

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
OK
2025-08-08 19:57:26 +02:00
parent aab8d06595
commit 38f0479d1e
5 changed files with 561 additions and 7 deletions
+172
View File
@@ -1,4 +1,6 @@
import logging
from functools import cache
from typing import Any, Dict, List, Optional, Union
import requests
@@ -89,3 +91,173 @@ class IGDBQuery(object):
limit=100,
)
return game_info
def search_games(self, query: str, limit: int = 5) -> Optional[List[Dict[str, Any]]]:
"""
Search for games with a flexible query string.
Returns formatted game information suitable for AI responses.
"""
if not query or not query.strip():
return None
try:
# Search for games with fuzzy matching
games = self.generalized_igdb_query(
{"name": query.strip()},
"games",
[
"id", "name", "summary", "storyline", "rating", "aggregated_rating",
"first_release_date", "genres.name", "platforms.name", "developers.name",
"publishers.name", "game_modes.name", "themes.name", "cover.url"
],
additional_filters={"category": "= 0"}, # Main games only
limit=limit
)
if not games:
return None
# Format games for AI consumption
formatted_games = []
for game in games:
formatted_game = self._format_game_for_ai(game)
if formatted_game:
formatted_games.append(formatted_game)
return formatted_games if formatted_games else None
except Exception as e:
logging.error(f"Error searching games for query '{query}': {e}")
return None
def get_game_details(self, game_id: int) -> Optional[Dict[str, Any]]:
"""
Get detailed information about a specific game by ID.
"""
try:
games = self.generalized_igdb_query(
{},
"games",
[
"id", "name", "summary", "storyline", "rating", "aggregated_rating",
"first_release_date", "genres.name", "platforms.name", "developers.name",
"publishers.name", "game_modes.name", "themes.name", "keywords.name",
"similar_games.name", "cover.url", "screenshots.url", "videos.video_id",
"release_dates.date", "release_dates.platform.name", "age_ratings.rating"
],
additional_filters={"id": f"= {game_id}"},
limit=1
)
if games and len(games) > 0:
return self._format_game_for_ai(games[0], detailed=True)
except Exception as e:
logging.error(f"Error getting game details for ID {game_id}: {e}")
return None
def _format_game_for_ai(self, game_data: Dict[str, Any], detailed: bool = False) -> Dict[str, Any]:
"""
Format game data in a way that's easy for AI to understand and present to users.
"""
try:
formatted = {
"name": game_data.get("name", "Unknown"),
"summary": game_data.get("summary", "No summary available")
}
# Add basic info
if "rating" in game_data:
formatted["rating"] = f"{game_data['rating']:.1f}/100"
if "aggregated_rating" in game_data:
formatted["user_rating"] = f"{game_data['aggregated_rating']:.1f}/100"
# Release information
if "first_release_date" in game_data:
import datetime
release_date = datetime.datetime.fromtimestamp(game_data["first_release_date"])
formatted["release_year"] = release_date.year
if detailed:
formatted["release_date"] = release_date.strftime("%Y-%m-%d")
# Platforms
if "platforms" in game_data and game_data["platforms"]:
platforms = [p.get("name", "") for p in game_data["platforms"] if p.get("name")]
formatted["platforms"] = platforms[:5] # Limit to prevent overflow
# Genres
if "genres" in game_data and game_data["genres"]:
genres = [g.get("name", "") for g in game_data["genres"] if g.get("name")]
formatted["genres"] = genres
# Developers
if "developers" in game_data and game_data["developers"]:
developers = [d.get("name", "") for d in game_data["developers"] if d.get("name")]
formatted["developers"] = developers[:3] # Limit for readability
# Publishers
if "publishers" in game_data and game_data["publishers"]:
publishers = [p.get("name", "") for p in game_data["publishers"] if p.get("name")]
formatted["publishers"] = publishers[:2]
if detailed:
# Add more detailed info for specific requests
if "storyline" in game_data and game_data["storyline"]:
formatted["storyline"] = game_data["storyline"]
if "game_modes" in game_data and game_data["game_modes"]:
modes = [m.get("name", "") for m in game_data["game_modes"] if m.get("name")]
formatted["game_modes"] = modes
if "themes" in game_data and game_data["themes"]:
themes = [t.get("name", "") for t in game_data["themes"] if t.get("name")]
formatted["themes"] = themes
return formatted
except Exception as e:
logging.error(f"Error formatting game data: {e}")
return {"name": game_data.get("name", "Unknown"), "summary": "Error retrieving game information"}
def get_openai_functions(self) -> List[Dict[str, Any]]:
"""
Generate OpenAI function definitions for game-related queries.
Returns function definitions that OpenAI can use to call IGDB API.
"""
return [
{
"name": "search_games",
"description": "Search for video games by name or title. Use when users ask about specific games, game recommendations, or want to know about games.",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "The game name or search query (e.g., 'Elden Ring', 'Mario', 'Zelda Breath of the Wild')"
},
"limit": {
"type": "integer",
"description": "Maximum number of games to return (default: 5, max: 10)",
"minimum": 1,
"maximum": 10
}
},
"required": ["query"]
}
},
{
"name": "get_game_details",
"description": "Get detailed information about a specific game when you have its ID from a previous search.",
"parameters": {
"type": "object",
"properties": {
"game_id": {
"type": "integer",
"description": "The IGDB game ID from a previous search result"
}
},
"required": ["game_id"]
}
}
]