This case study explores how Datastax built UnReel, an innovative multiplayer movie trivia game that showcases the practical challenges and solutions in deploying LLMs in a production environment. The project is particularly interesting as it demonstrates the intersection of AI content generation, real-time multiplayer gaming, and distributed systems architecture. The core challenge was creating an engaging game experience that leverages AI to generate believable movie quotes while maintaining real-time synchronization across multiple players. This required careful consideration of both AI implementation and distributed systems architecture. ## AI Implementation and RAG System The heart of the system relies on two distinct AI pipelines implemented through Langflow: * The first pipeline handles real movie quotes and generates plausible alternative movies that could have been the source * The second pipeline generates entirely fake movie quotes that need to be convincingly realistic The team's experience with LLM selection and tuning provides valuable insights into production AI deployment. They experimented with multiple LLM providers including Groq, OpenAI, Mistral, and Anthropic before settling on MistralAI's open-mixtral-8x7b model. The choice of a temperature setting of 0.5 represents a careful balance between creativity and control - enough variation to create interesting content while maintaining believability. A particularly interesting challenge emerged in the form of unexpected LLM behaviors, such as the models' tendency to include food references in generated quotes. This highlights the importance of thorough testing and iteration in production LLM applications. The team's solution involved careful prompt engineering and model parameter tuning to achieve the desired output quality. ## Production Architecture and State Management The system architecture demonstrates several important principles for production LLM applications: The game uses Cloudflare Durable Objects for multiplayer coordination, with each game room implemented as a separate Durable Object. This provides automatic load balancing and helps manage game state across distributed players. The architecture emphasizes the importance of maintaining a single source of truth for game state, with all UI states derived from the server state. Data storage is handled through Astra DB, which stores movie content and generated questions. The integration of RAG with real-time multiplayer functionality required careful consideration of performance optimization. The team discovered that batch-generating multiple questions at once was more efficient than generating them one at a time, an important consideration for production LLM applications where response time is critical. ## Key LLMOps Lessons Several valuable LLMOps lessons emerged from this project: * Initial GenAI implementation can be deceptively quick, but achieving production-quality output often requires significant fine-tuning and iteration. The team found that while basic functionality was implemented within days, perfecting the LLM outputs took considerably longer. * Batch processing for LLM operations can be more efficient than individual requests. In this case, generating 10 questions at once proved faster than sequential generation, an important consideration for production deployment. * State management in distributed AI systems requires careful design. The team learned that maintaining a single source of truth for state and deriving UI states from it was crucial for system stability. * Idempotency is crucial in distributed AI systems. The team encountered issues with duplicate events affecting game scores, highlighting the importance of designing systems that handle repeated identical events gracefully. ## Technical Implementation Details The system's architecture combines several modern technologies: * Langflow for AI pipeline implementation and RAG * Astra DB for data storage * PartyKit for real-time multiplayer functionality * Cloudflare Durable Objects for state management The multiplayer coordination system is implemented through a server class that handles various game events and maintains game state. This implementation demonstrates how to integrate AI-generated content with real-time interactive features while maintaining system stability. ## Production Considerations The case study highlights several important considerations for production AI applications: * The importance of thorough testing with different LLM providers and configurations * The need to balance creativity with control in LLM outputs * The critical role of proper state management in distributed AI systems * The value of batch processing for LLM operations * The importance of idempotency in distributed systems This project serves as an excellent example of the challenges and solutions involved in deploying LLMs in production, particularly in interactive, real-time applications. It demonstrates how careful architecture decisions, proper state management, and thoughtful LLM integration can create engaging user experiences while maintaining system stability and performance.