AI DEV CASE STUDY
Vatrina: A Realtime AI Shopping Assistant Powered by RAG and GenAI
How WebSpero built the realtime conversational chatbot and product recommendation engine at the heart of Vatrina, with RAG-backed context retrieval, live inventory sync, and sub-2.5-second AI responses.
Project Context
Client
Vatrina
Niche
Social Commerce · Conversational AI
The Tech Stack
- Ruby on Rails
- PostgreSQL
- pgVector (Vector Database)
- OpenAI (GenAI + Function Calls)
- WebSockets (Realtime Delivery)
"We wanted a realtime conversational shopping assistant that could actually understand a shopper's intent, recommend the right product, and hand off to a human when it mattered."
The brief scoped a chatbot that could act as a conversational AI, a product recommendation engine, and an intelligent router in one. It had to answer complex customer queries in natural language, surface the right product from a live inventory, respect budget and occasion constraints, and know when to bring a human in.
Vatrina Team
A product of Escape Ventures LLC · Doha, Qatar
HOW WE BUILT IT
An Engineering-First Process for a Realtime, Stock-Aware GenAI System
Vatrina’s chatbot has three jobs at once: understand the shopper, recommend the right product from a live catalog, and escalate cleanly when the AI is out of its depth. Every milestone below was built and validated against those three constraints before we moved forward.
DISCOVERY
A working session with the Vatrina team to capture the shopping assistant vision, the shopper journey, and the non-negotiables: realtime, stock-aware, and guardrailed.
REQUIREMENT ANALYSIS
Broke the brief into the chat surface, the recommendation engine, the inventory sync pipeline,and the human handoff layer that ties
them together.
ARCHITECTURE & PLANNING
Chose Ruby on Rails as the service layer, PostgreSQL with pgVector for the vector store, OpenAI for reasoning and function calls,
and WebSockets for realtime delivery to the shopper.
RAG PIPELINE DESIGN
Designed the retrieval-augmented generation flow: how product data is embedded, indexed in pgVector, retrieved on a query, and fed back into the
OpenAI prompt as grounded context.
REALTIME PIPELINE
Built the realtime response loop with WebSockets, OpenAI function calls, and streamed output so a shopper sees an answer forming inside the sub-2.5
-second latency budget.
INVENTORY SYNC AUTOMATION
Automated the RAG data pipeline: new products, product updates, and stock changes flow into embeddings and
pgVector without a human touch, so the AI always reads a current catalog.
GUARDRAILS & HANDOFF
Wrote prompt guardrails that keep conversations to shopping topics, and built the escalation flow that routes queries needing human
attention to a real agent without breaking the chat.
QA, LATENCY & LAUNCH
Measured turn latency, tested recommendation accuracy against the live catalog, verified handoff behaviour, and shipped the module into
the Vatrina platform with monitoring in place.
Conversational Shopping Chatbot
The shopper-facing chat surface. Handles natural-language queries about products, occasions, and budgets. Understands intent, keeps context across turns, and returns grounded, catalog-accurate answers rather than generic AI output.
RAG-Powered Recommendation Engine
The recommendation engine is retrieval-augmented from the ground up. Product data is embedded and stored in pgVector. On a query, the system pulls the most semantically relevant products, feeds them to OpenAI as grounded context, and returns recommendations tied to real SKUs, not hallucinations.
Realtime Response Pipeline: WebSockets + OpenAI Function Calls
The response loop is streamed. WebSockets carry each token as it is generated, OpenAI function calls fetch live inventory and product data mid-response, and the whole turn lands inside an average sub-2.5-second latency budget. The shopper sees the answer forming, not a loading spinner.
Automated RAG Ingestion Pipeline
Every new product, every catalog edit, and every stock update flows through an automated pipeline: normalise, embed, upsert into pgVector, and rebuild the retrieval index. There is no manual step. The AI is reading the same catalog the shopper is browsing.
Live Inventory Sync: Stock-Aware Recommendations
OpenAI function calls query the live inventory before a recommendation goes out, so an out-of-stock product never gets recommended. Constraints from the shopper (budget, occasion, category) combine with the current stock state to return only what is actually buyable right now.
Prompt Guardrails: Shopping-Only Enforcement
A structured prompt layer keeps every conversation on shopping topics. Off-topic queries are politely redirected, off-brand tangents never make it through, and the AI is never asked to answer something it should not. The guardrails are the reason the chatbot is trusted on a customer-facing surface.
Human Handoff Flow for Special Queries
When a shopper needs something the AI cannot resolve (a bespoke order, a sensitive complaint, a special request), the module escalates to a human agent inside the same chat. The shopper does not restart. Context, transcript, and intent classification travel with the handoff.
WHAT TO EXPECT FROM US
Transparent Engineering for Realtime Conversational AI Products
If you are building a conversational AI or a RAG-backed product and weighing engineering partners, here is what working with our team actually looks like.
A plan before a proposal.
We start with a working session to understand what your product needs to do, who it serves, and where the hard parts are. For a conversational AI product, that means surfacing the latency, grounding, and guardrail constraints before we write a line of code.
A live demo every two weeks.
At the end of every sprint, you see the actual product: what is built, what is working, and what we are still figuring out. You always know where your product stands.
Engineering, not prompt tweaking.
GenAI products live or die on the engineering around the model: retrieval, function calls, guardrails, streaming, observability. We treat the model as one component in a real system, not the system itself.
Experience with the hard parts.
Realtime pipelines, vector databases, retrieval-augmented generation, prompt guardrails, and human handoff flows: we have shipped these into production. They are not research projects for us, which means you skip a year of trial and error.
Quality that does not depend on one person.
Every change is tested before it reaches you. Latency, retrieval accuracy, and guardrail behaviour are regression-checked on every release, not by one engineer eyeballing a chat transcript.
Reliability built in from day one.
Third-party AI services will fail. Your product should not. We design retry, fallback, and stateful recovery into the architecture from the first sprint, not as a bolt-on after the first outage.
You own what we build.
At handover you get the full system: source code, prompt libraries, ingestion pipeline, infrastructure, and documentation. Your team can take it forward independently or keep us on; that is your choice.
A founder-friendly working rhythm.
You are in every demo, every trade-off conversation, every milestone. You are not a ticket number to us; you are the product’s first and most important user.