Amazon Bedrock: Browsergame generiert bei jeder Partie ein neues Krimi-Rätsel
Mit AI Mystery Game lässt sich jedes Mal ein komplett neuer Krimifall erzeugen, dessen Spuren Spieler untersuchen und Hinweise anfordern können. Die KI bewertet am Ende die Lösung des Spielers.
Was wäre, wenn Sie jedes Mal beim Spielen ein völlig neues Mysterium generieren könnten, den Hinweisen nachgehen, Tipps anfordern und Ihre Antwort von einer KI bewerten lassen könnten?
Ich habe AI Mystery Game entwickelt, ein browserbasiertes Spiel, das generative KI mit interaktivem Gameplay kombiniert und dabei Amazon Bedrock, AWS Lambda und Amazon API Gateway nutzt.
Spieler können einen Schwierigkeitsgrad und eine Mysteriums-Kategorie wählen, einen originellen Fall generieren, der Geschichte nachgehen, um Hinweise bitten und ihre Antworten zur KI-gestützten Bewertung einreichen.
Live-Demo des Spiels im Browser verfügbar.
Der Quellcode ist in einem öffentlichen GitHub-Repository einsehbar.
Ich wollte etwas bauen, das generative KI für mehr einsetzt als nur für das Beantworten von Fragen oder das Erzeugen gewöhnlicher Texte.
Die Idee war, ein interaktives Erlebnis zu schaffen, bei dem die KI die Inhalte generiert und der Spieler Teil der Geschichte wird.
Generieren Sie einzigartige, von der KI erstellte Mysterien.
Wählen Sie Kategorien wie Logik, Verbrechen, Fantasy, Wissenschaft und Abenteuer.
Erkunden Sie bei jedem Spiel neue Geschichten.
Die Mysterien werden dynamisch mithilfe von Amazon Nova Lite über Amazon Bedrock generiert, wodurch jedes Spiel zu einem neuen Erlebnis wird.
Ich habe eine schlanke serverlose Architektur verwendet, um das browserbasierte Spiel mit einem generativen KI-Backend zu verbinden.
Das Frontend wird auf Netlify gehostet, während die Backend-Verarbeitung und die KI-Generierung von AWS übernommen werden.
Generierung von Mysterien, Hinweisen und Antwortbewertung
HTTP-API, die Frontend und Backend verbindet
Ich habe die Anwendung in zwei Hauptkomponenten unterteilt: die Frontend-Spieloberfläche und das serverlose Backend.
Die Oberfläche umfasst Steuerelemente zur Auswahl der Mysteriums-Kategorie und des Schwierigkeitsgrads sowie Schaltflächen zum Generieren eines Mysteriums, zum Anfordern eines Hinweises und zum Einreichen einer Antwort.
Das Backend habe ich mit Python in AWS Lambda implementiert.
Statt für jede Spielfunktion eine separate Lambda-Funktion zu erstellen, habe ich eine einzige Funktion entworfen, die mehrere Aktionen auf Grundlage der eingehenden Anfrage verarbeitet.
Das Backend unterstützt drei Hauptaktionen:
generate: Erstellt ein neues Mysterium auf Grundlage der gewählten Kategorie und des Schwierigkeitsgrads.
hint: Erzeugt einen hilfreichen Hinweis, ohne die Lösung direkt preiszugeben.
check: Bewertet die Antwort des Spielers und liefert Feedback sowie eine Punktzahl zurück.
Dieser Ansatz hält das Backend vergleichsweise einfach und unterstützt dennoch die wichtigsten Gameplay-Funktionen der Anwendung.
Die Lambda-Funktion kommuniziert über die Bedrock Converse API mit Amazon Bedrock.
Ich habe Amazon Nova Lite verwendet, um Mysterien zu generieren, Hinweise zu erstellen und Antworten zu bewerten.
Für die Mysteriums-Generierung fordert der Prompt eine strukturierte Ausgabe mit Feldern wie den folgenden an:
Das Anfordern einer strukturierten JSON-Antwort erleichtert dem Frontend die Darstellung des Mysteriums und der zugehörigen Informationen.
Dasselbe Modell kann unterschiedliche Interaktionen unterstützen, indem für jede Aktion separate Prompts verwendet werden.
Amazon API Gateway stellt die Lambda-Funktion über einen HTTP-Endpunkt bereit.
API Gateway ruft die Lambda-Funktion auf.
Lambda kommuniziert mit Amazon Bedrock.
Die generierten Inhalte oder das Bewertungsergebnis werden an den Browser zurückgegeben.
Diese Architektur hält Frontend und Backend getrennt und erspart die Verwaltung eines klassischen Anwendungsservers.
Prompt Engineering für interaktives Gameplay
Einer der interessanten Aspekte dieses Projekts war die Nutzung von Prompts, um unterschiedliche KI-Verhalten zu steuern.
Mysteriums-Generierung, Hinweis-Generierung und Antwortbewertung erfordern unterschiedliche Anweisungen, obwohl sie dasselbe zugrunde liegende Modell verwenden.
So kann beispielsweise ein Prompt zur Mysteriums-Generierung Folgendes vorgeben:
Das Ergebnis in einem strukturierten JSON-Format zurückgeben.
Der tatsächliche Prompt kann an das erwartete Antwortschema der Anwendung angepasst werden.
Für Hinweise müssen die Anweisungen den Spieler lenken, ohne die Lösung sofort preiszugeben. Für die Bewertung der Antworten muss das Modell die eingereichte Antwort mit der vorgesehenen Lösung vergleichen und nützliches Feedback geben.
Dies zeigt, wie Prompt-Design dazu beitragen kann, dass ein einzelnes Foundation Model mehrere Funktionen innerhalb einer Anwendung unterstützt.
Der Aufbau der Anwendung brachte mehrere praktische Entwicklungsherausforderungen mit sich.
Zunächst erwartete die Lambda-Funktion Anfragen im Format, das von API Gateway erzeugt wird.
Ereignisse, die direkt über die Lambda-Konsole übermittelt wurden, hatten jedoch eine andere Struktur, was während der Tests zu Fehlern führte.
Ich habe die Funktion so aktualisiert, dass sie sowohl API-Gateway-Anfragen als auch direkte Lambda-Testereignisse verarbeiten kann.
Dadurch wurde es einfacher, einzelne Backend-Operationen zu testen, bevor das Frontend integriert wurde.
Frontend und Backend wurden separat gehostet, sodass die Sicherheitsbeschränkungen des Browsers die API-Kommunikation beeinträchtigten.
Ich habe Cross-Origin Resource Sharing (CORS) in API Gateway konfiguriert und die API erneut bereitgestellt.
Nach den erforderlichen Konfigurationsänderungen konnte das Frontend erfolgreich mit dem Backend kommunizieren.
Statt sofort alle Komponenten miteinander zu verbinden, habe ich die Lambda-Funktion zunächst unabhängig getestet.
Dies half dabei, Probleme mit dem Event-Parsing und der Backend-Verarbeitung zu erkennen, bevor zusätzliche Variablen durch Frontend- und API-Integration hinzukamen.
Sobald das Backend funktionierte, habe ich es mit der Browser-Oberfläche verbunden und den kompletten Arbeitsablauf getestet.
Das Frontend benötigt vorhersagbare Daten, um die generierte Geschichte, Hinweise, Tipps und Bewertungsergebnisse anzuzeigen.
In einer Produktionsanwendung sollte die Antwort auch validiert werden, bevor sie vom Frontend verwendet wird, da generative KI-Modelle nicht bei jeder Anfrage eine perfekt formatierte Ausgabe garantieren.
AWS IAM steuert die Berechtigungen, die die Lambda-Funktion benötigt, um Amazon Bedrock aufzurufen und Ausführungsprotokolle zu schreiben.
Die Lambda-Ausführungsrolle sollte nur über die Mindestberechtigungen verfügen, die zur Ausführung dieser Operationen erforderlich sind.
Für Produktionsbereitstellungen sollte der Zugriff auf das benötigte Bedrock-Modell beschränkt und unnötig weitreichende Berechtigungen vermieden werden.
Dies folgt dem Prinzip der geringsten Privilegien und verringert die potenziellen Auswirkungen einer Fehlkonfiguration.
Dieses Projekt hat mir praktische Erfahrung beim Aufbau einer interaktiven generativen KI-Anwendung mit AWS vermittelt.
Die Integration von Amazon Bedrock mit AWS Lambda über die Converse API.
Der Einsatz von Prompt Engineering zur Unterstützung mehrerer Anwendungsfunktionen.
Der Aufbau von HTTP-APIs mit Amazon API Gateway.
Der Umgang mit verschiedenen Lambda-Ereignisformaten.
Die Konfiguration von CORS für browserbasierte Anwendungen.
Das unabhängige Testen serverless-Backends.
Die Bereitstellung eines öffentlichen Frontends mit Netlify.
Die Kombination von KI-generierten Inhalten mit einfachen Spielmechaniken.
Am wichtigsten ist, dass ich gelernt habe, dass generative KI interaktive Erlebnisse antreiben kann, statt auf Chatbots und Textgenerierungswerkzeuge beschränkt zu sein.
Es gibt mehrere Möglichkeiten, wie ich AI Mystery Game erweitern könnte:
Mehrere Enden: Spielerentscheidungen sollen den Ausgang beeinflussen.
Schwierigkeitsprogression: Künftige Mystery-Fälle sollen an die Leistung der Spieler angepasst werden.
Mystery-Verlauf: Spieler sollen frühere Fälle erneut aufrufen können.
Punkte und Erfolge: Einführung von Punkten, Serien und Bestenlisten.
Mehrspielermodus: Freunde sollen gemeinsam denselben Fall lösen können.
Weitere Kategorien: Hinzufügung historischer Mystery-Fälle, Rätsel und Detektiv-Herausforderungen.
Verbesserte Antwortbewertung: Unterstützung alternativer korrekter Antworten und Teilpunkte.
Persistente Spielerprofile: Speicherung von Fortschritt und Präferenzen zwischen den Sitzungen.
Diese Verbesserungen könnten das Projekt in ein vollständigeres KI-gestütztes Spielerlebnis verwandeln.
Die Anwendung ist öffentlich zugänglich, und der Quellcode ist auf GitHub verfügbar.
Live-Demo: https://ai-mystery-game-jyo.netlify.app/
Quellcode: https://github.com/GunnerJyo/ai-mystery-game
Probiert aus, ein Mysterium zu generieren, einen Hinweis anzufordern und eine Antwort einzureichen, um zu sehen, wie die verschiedenen KI-Interaktionen zusammenwirken.
AI Mystery Game kombiniert generative KI mit interaktivem Gameplay und schafft so bei jedem Durchlauf ein neues Erlebnis.
Mit Amazon Bedrock, Amazon Nova Lite, AWS Lambda und Amazon API Gateway habe ich eine serverlose Anwendung gebaut, in der Spieler Mysterien generieren, Hinweisen nachgehen, Tipps anfordern und Antworten zur KI-Bewertung einreichen koennen.
Dieses Projekt war eine praktische Erkundung, wie sich verwaltete AWS-Services und generative KI fuer die Entwicklung kreativer Anwendungen nutzen lassen, ohne klassische Server-Infrastruktur verwalten zu muessen.
Wenn ihr ein KI-gestuetztes Spiel mit Amazon Bedrock bauen koenntet, was wuerdet ihr entwickeln?
Automatisch übersetzt. Das Original auf Englisch ist unten aufklappbar.
Original (Englisch) anzeigen
What if you could generate a completely new mystery every time you play, investigate the clues, request hints, and let AI evaluate your answer?
I built AI Mystery Game, a browser-based game that combines generative AI with interactive gameplay using Amazon Bedrock, AWS Lambda, and Amazon API Gateway.
Players can choose a difficulty level and mystery category, generate an original case, investigate the story, ask for hints, and submit their answers for AI-powered evaluation.
🔗 Live Demo: https://ai-mystery-game-jyo.netlify.app/
💻 GitHub Repository: https://github.com/GunnerJyo/ai-mystery-game
I wanted to build something that used generative AI for more than answering questions or generating ordinary text.
The idea was to create an interactive experience where AI generates the content and the player becomes part of the story.
🕵️ Generate unique AI-created mysteries.
🧩 Choose categories such as Logic, Crime, Fantasy, Science, and Adventure.
📖 Explore new stories every time they play.
The mysteries are generated dynamically using Amazon Nova Lite through Amazon Bedrock, making each game a new experience.
I used a lightweight serverless architecture to connect the browser-based game with a generative AI backend.
The frontend is hosted on Netlify, while the backend processing and AI generation are handled by AWS.
Mystery generation, hints, and answer evaluation
HTTP API connecting the frontend and backend
I divided the application into two main components: the frontend game interface and the serverless backend.
The interface includes controls for selecting a mystery category and difficulty level, along with buttons to generate a mystery, request a hint, and submit an answer.
I implemented the backend using Python in AWS Lambda.
Rather than creating a separate Lambda function for every game feature, I designed a single function that handles multiple actions based on the incoming request.
The backend supports three main actions:
generate — Creates a new mystery based on the selected category and difficulty.
hint — Generates a helpful clue without directly revealing the solution.
check — Evaluates the player's answer and returns feedback and a score.
This approach keeps the backend relatively simple while supporting the application's main gameplay features.
The Lambda function communicates with Amazon Bedrock using the Bedrock Converse API.
I used Amazon Nova Lite to generate mysteries, create hints, and evaluate answers.
For mystery generation, the prompt requests structured output containing fields such as:
Requesting a structured JSON response makes it easier for the frontend to display the mystery and its associated information.
The same model can support different interactions by using separate prompts for each action.
Amazon API Gateway exposes the Lambda function through an HTTP endpoint.
API Gateway invokes the Lambda function.
Lambda communicates with Amazon Bedrock.
The generated content or evaluation result is returned to the browser.
This architecture keeps the frontend separate from the backend and avoids the need to manage a traditional application server.
🧠 Prompt Engineering for Interactive Gameplay
One of the interesting parts of this project was using prompts to control different AI behaviors.
Mystery generation, hint generation, and answer evaluation require different instructions, even though they use the same underlying model.
For example, a mystery-generation prompt can specify:
Return the result in a structured JSON format.
The actual prompt can be adjusted to match the application's expected response schema.
For hints, the instructions need to guide the player without immediately revealing the answer. For answer evaluation, the model needs to compare the submitted response with the intended solution and provide useful feedback.
This demonstrates how prompt design can help one foundation model support multiple features within a single application.
Building the application involved several practical development challenges.
Initially, the Lambda function expected requests in the format generated by API Gateway.
However, events submitted directly through the Lambda console had a different structure, causing errors during testing.
I updated the function to handle both API Gateway requests and direct Lambda test events.
This made it easier to test individual backend operations before integrating the frontend.
The frontend and backend were hosted separately, so browser security restrictions affected API communication.
I configured Cross-Origin Resource Sharing (CORS) in API Gateway and redeployed the API.
After making the necessary configuration changes, the frontend could communicate with the backend successfully.
Instead of immediately connecting every component, I tested the Lambda function independently first.
This helped identify problems with event parsing and backend processing before introducing additional frontend and API integration variables.
Once the backend was working, I connected it to the browser interface and tested the complete workflow.
The frontend needs predictable data to display the generated story, clues, hints, and evaluation results.
In a production application, the response should also be validated before it is used by the frontend, since generative AI models do not guarantee perfectly formatted output on every request.
AWS IAM controls the permissions required by the Lambda function to invoke Amazon Bedrock and write execution logs.
The Lambda execution role should have the minimum permissions needed to perform these operations.
For production deployments, restrict access to the required Bedrock model and avoid granting unnecessarily broad permissions.
This follows the principle of least privilege and reduces the potential impact of misconfiguration.
This project gave me hands-on experience building an interactive generative AI application using AWS.
Integrating Amazon Bedrock with AWS Lambda using the Converse API.
Using prompt engineering to support multiple application features.
Building HTTP APIs with Amazon API Gateway.
Handling different Lambda event formats.
Configuring CORS for browser-based applications.
Testing serverless backends independently.
Deploying a public frontend with Netlify.
Combining AI-generated content with simple game mechanics.
Most importantly, I learned that generative AI can power interactive experiences rather than being limited to chatbots and text-generation tools.
There are several ways I could extend AI Mystery Game:
Multiple endings: Let player decisions influence the outcome.
Difficulty progression: Adjust future mysteries based on player performance.
Mystery history: Allow players to revisit previous cases.
Scoring and achievements: Introduce points, streaks, and leaderboards.
Multiplayer mode: Allow friends to solve the same mystery together.
More categories: Add historical mysteries, puzzles, and detective challenges.
Improved answer evaluation: Support alternative correct answers and partial credit.
Persistent player profiles: Save progress and preferences between sessions.
These improvements could turn the project into a more complete AI-powered gaming experience.
The application is publicly available, and the source code is available on GitHub.
Live Demo: https://ai-mystery-game-jyo.netlify.app/
Source Code: https://github.com/GunnerJyo/ai-mystery-game
Try generating a mystery, requesting a hint, and submitting your answer to see how the different AI interactions work together.
AI Mystery Game combines generative AI with interactive gameplay to create a different experience each time someone plays.
Using Amazon Bedrock, Amazon Nova Lite, AWS Lambda, and Amazon API Gateway, I built a serverless application where players can generate mysteries, investigate clues, request hints, and submit answers for AI evaluation.
This project was a practical exploration of how managed AWS services and generative AI can be used to build creative applications without managing traditional server infrastructure.
If you could build an AI-powered game using Amazon Bedrock, what would you create?