Serendipity Engine

Inspiration

My inspiration for the Serendipity Engine came from two distinct but related frustrations. The first is a technical one: as a developer, I am fascinated by the creative power of Large Language Models, but deeply concerned by their unreliability. The tendency for LLMs to "hallucinate" facts makes them a risky foundation for real-world applications where truth matters. This creates a significant trust deficit that I wanted to solve.

The second frustration is personal. I, like many people, have experienced the modern "paradox of choice"—endlessly scrolling through lists of restaurants, movies, and events, only to be overwhelmed and fall back on the same old options. The perpetual question of "What should we do tonight?" often leads to decision fatigue rather than excitement. I was inspired to build a tool that could answer that question in a truly personal and delightful way, architecting a sense of discovery and serendipity that is often missing from our digitally-planned lives. I wanted to build an AI that could be a creative partner, but one whose suggestions were always anchored in reality.

What it does

Serendipity Engine is an AI-powered life concierge that transforms your abstract tastes and moods into concrete, factually-grounded, and bookable real-world experiences. Instead of giving you a simple recommendation for a single thing, it curates a complete, multi-part itinerary where every part is thematically connected.

For example, a user can input a simple, natural language prompt like, "My partner and I love Studio Ghibli films and cozy cafes." The Serendipity Engine doesn't just find a Japanese restaurant. It synthesizes the "vibe" and generates a cohesive plan: an afternoon at a sunlit cafe known for its handcrafted latte art, followed by dinner at a small, family-run spot serving authentic comfort food, and concluding with a visit to a nearby immersive art installation that evokes a sense of wonder.

Crucially, every single recommendation—every restaurant, cinema, or cocktail bar—is grounded in Qloo's vast and verifiable Taste AI knowledge graph. This ensures all suggestions are factually accurate, preventing the LLM from inventing places or details. It delivers this hyper-personalized experience while operating on a strict Zero-PII basis, meaning it never asks for, processes, or stores any of the user's personal information.

How I built it

I built the Serendipity Engine using a modern, decoupled architecture with a mobile-first approach. The frontend is a cross-platform mobile app built with React Native and Expo, ensuring a polished, native user experience. The backend is a serverless orchestrator built using Next.js, deployed on Vercel.

The core of the project is the Graph-Agentic Retrieval-Augmented Generation (GA-RAG) framework I implemented in the backend. This isn't a simple RAG pipeline; it's an intelligent, multi-step process:

Agentic Planning: When a user enters a prompt, I use an OpenAI GPT-4 powered agent not to find an answer, but to create a plan. The agent deconstructs the user's mood ("adventurous," "cozy") into a structured, machine-readable query, identifying the key entities and taste domains (like dining, film, nightlife) to explore.

GraphRAG Execution: Using this structured plan, the system then performs a multi-hop traversal across Qloo's Taste AI API. Instead of just searching for keywords, it navigates the explicit relationships in Qloo's knowledge graph. This allows it to find the hidden correlations between, for example, the aesthetic of a film director and the ambiance of a bar, which is the key to creating a thematically coherent itinerary.

Self-Correction & Critique: Before generating a response, the agent performs a critical self-reflection check. It uses the LLM to assess the data retrieved from Qloo, asking itself if the information is sufficient and relevant to create a high-quality experience. This step ensures robustness and prevents the system from producing a weak or disjointed plan.

Grounded Synthesis: Only after the data is verified does the agent proceed to the final step. It creatively weaves the factually-grounded data points from Qloo into a compelling, narrative-style itinerary. I engineered the final prompt to strictly command the LLM to use only the provided Qloo data for factual claims (names, locations), which effectively prevents hallucinations while allowing for creative descriptions.

The entire stack is written in TypeScript for type safety, ensuring a more robust and maintainable codebase.

Challenges I ran into

The primary challenge was taming the LLM's creativity to ensure absolute factual accuracy. Early on, I realized that simply providing context to an LLM wasn't enough; it would still occasionally embellish details. The solution required meticulous prompt engineering for the final synthesis step. I had to craft a directive that was unambiguous: act as a creative concierge, but treat the provided Qloo data as an immutable source of truth for any factual claim. This was the critical defense against hallucination.

Another significant challenge was translating a user's abstract "vibe" into something a machine could understand and act upon. A query like "a night that feels like a sci-fi movie" is too ambiguous for a standard API. I overcame this by designing the two-part agentic process. Using the LLM first as an interpreter to break down the vibe into concrete search terms, and then using those terms to traverse Qloo's graph, provided the necessary bridge between human emotion and structured data.

Finally, ensuring the different parts of the itinerary felt truly connected was difficult. A simple search could return a sci-fi movie and a spicy restaurant, but they might not feel like part of the same experience. Solving this required moving from simple API calls to a genuine GraphRAG approach, where I focused on querying Qloo for the intersections between taste profiles, allowing me to find places that had a high correlation with the entire synthesized taste vector of the user.

Accomplishments that I’m proud of

I am most proud of successfully implementing the full, end-to-end GA-RAG framework. It's more than just an application; it's a robust and reusable pattern for building the next generation of trustworthy AI tools. The system's ability to plan, execute, critique its own findings, and then synthesize a creative response feels like a significant step forward.

I am also incredibly proud of achieving true "experience synthesis." The app doesn't just return a list; it generates a novel, narrative-driven plan that I often wouldn't have constructed on my own. Seeing it produce a perfectly coherent and appealing evening from a simple prompt was the moment I knew the core concept was a success.

Finally, I am proud to have built a deeply personal application that is also deeply respectful of user privacy. Proving that I could deliver this level of hyper-personalization without collecting any PII is a critical accomplishment. It shows a viable, ethical path forward for AI applications in a world that is increasingly wary of data surveillance.

What I learned

This project taught me that the most powerful application of an LLM is not as an oracle, but as a flexible reasoning engine. Using an LLM to plan, critique, and creatively structure verified external data is a far more reliable and potent paradigm than simply asking it for an answer. The LLM becomes the intelligent orchestrator, while Qloo's API serves as the infallible source of ground truth.

I also learned the immense value of a structured knowledge graph. Interacting with the Qloo API demonstrated that the ability to traverse explicit, weighted relationships between entities is what unlocks complex, cross-domain reasoning. This is a capability that a standard vector search across an unstructured blob of text simply cannot replicate.

Finally, I learned that prompt engineering is a form of software architecture. The design of the layered prompts that guide the agent through the Plan-Critique-Synthesize cycle is as critical to the system's success as any part of the code. The precision of those instructions defines the agent's behavior and is the ultimate guarantor of its reliability.

What's next for Serendipity Engine

The immediate next step for the Serendipity Engine is to make the experience completely seamless. This involves moving beyond deep-linking to implement direct API integrations with booking services for restaurants, movie theaters, and events. The goal is for a user to go from discovery to a fully booked itinerary in just a few taps.

Looking further, I see a powerful B2B2C opportunity. I plan to package the engine as a white-label solution for businesses in the experience economy, such as hospitality brands, airlines, and even dating apps. These companies could integrate the Serendipity Engine into their own platforms to offer their customers hyper-personalized, curated local itineraries, creating a potent tool for engagement and loyalty.

Finally, I will expand the application's scope by adding support for more cities and introducing optional, privacy-first user profiles. This will allow users to save their favorite generated experiences and enable the engine to learn their preferences over time, making the serendipity it creates even more magical.

Built With

• api-gateway
• cloud-services
• expo.io
• javascript
• next.js
• openai-api
• python
• qloo-taste-ai-api
• react-native
• typescript
• vercel