Senior AI/ML Engineer· 2026

The AI behind Rezolve Ai's shopping assistant

PythonLLM evaluationVector searchFine-tuningLearning to rankRetailLangChainLangGraphLoop engineering

What I do

I design and build an AI shopping assistant end to end. I write the design doc, then build it across the chat service, the catalog enrichment pipeline, shared libraries and deployment config.

I own the AI/ML behind it: catalog-aware conversation, retrieval and vector search, intent matching, attribute extraction, vision models for product images, and model routing.

Better models from real labels: fine-tuning embedding, extraction and vision models, and learning to rank results from shopper signals.

One shopping assistant for any catalogue

The problem: The assistant was built around fashion. Each new kind of merchant, like sports or grocery, meant new code paths, new prompts and new bugs.

What I did: I led the redesign into a neutral core plus thin vertical layers. The intent classifier and search tools work from each catalogue's own schema, not hard-coded product types. Each vertical adds a short prompt overlay and a few interface hints, nothing more. Cart, recall and similar-product tools resolve products generically for any catalogue.

The result: Adding a vertical became configuration instead of engineering. For a new sports vertical, the overlay took the extraction eval pass rate from about a third to 100%, with no regressions on existing cases.

Making an LLM pipeline feel fast

The problem: Each shopper turn chained several LLM calls: understand the turn, extract attributes, search, write the reply. Replies took over 10 seconds.

What I did: I ran attribute extraction at the same time as intent classification, so it left the critical path. When the shopper tapped a button and the intent was already known, the classification call was skipped. I reordered prompts so the model server could reuse cached work between turns, and added an instant acknowledgement so the wait felt shorter. I measured with alternating benchmark runs, so drift on the model server couldn't flatter the result.

The result: About 30% faster first response and about 20% faster full reply. A rewrite of the reply prompt also made it about 60% smaller.

A knowledge layer merchants write

The problem: A good shop assistant knows what to ask first ("road or trail?") and what to explain before selling. A general model doesn't know that about each merchant.

What I did: I designed a knowledge layer that merchants write: one playbook per shopper situation, each with must-know questions, advice and catalogue filters. The assistant uses it to pick its next move: ask, explain or show products. Every version is checked against the live catalogue and can't go live until a recognition eval passes. AI-assisted authoring drafts playbooks grounded in the merchant's real product values, and the same layer is served through an API that answers in tens of milliseconds, with no LLM call.

The result: In blind comparisons, the assistant with the knowledge layer was preferred in about two thirds of conversations. Recognition reached over 95% top-3 on a second vertical with no vertical-specific code.

Measuring an LLM product honestly

The problem: "It feels better" isn't evidence, and one LLM judge on its own is noisy.

What I did: I built a side-by-side harness: scripted shopper conversations, each played several times per variant, about 100 conversations per run. I added a blind LLM judge, then measured its own run-to-run noise. Code checks cover everything verifiable without a model: right category, gender and budget, products actually shown, usable replies, no products named that aren't on screen. Models are chosen by bake-off with decision rules written down in advance: I kept the cheaper embedding model because the alternative gained 3 points at about 4× the query cost. When the numbers showed a trial didn't help, I dropped it.

The result: The code checks matched hand-checked results exactly, so most regressions now get caught without a judge call. One finding, hidden reasoning using up the reply's token budget, took broken replies from about 7% to zero.

Vision models for product data

The problem: Merchant feeds often carry wrong or meaningless colours, like SKU codes or guesses, and product photos come with no labels for which angle they show.

What I did: I added a step that checks the listed colour against the product photo and replaces it only when the image clearly disagrees or the value is junk. I built image-angle labelling that sends several photos per vision call, routed footwear, the hardest category, to a larger vision model while everything else stays on a smaller, cheaper one, and added retries so one failed image download no longer blanks a product's visual attributes.

The result: Cleaner colour data for search, with every change counted (replaced, kept or unsure) so merchants can review it.

Vector ingestion at scale

The problem: Large catalogue ingests kept dying partway through. About a minute of blocking work made the server miss its health checks, so it was restarted and the job was lost.

What I did: I moved the heavy loading and enrichment off the main event loop, added a clean stop on shutdown, and made restarts resume: they look up which products are already done and embed only the rest.

The result: Reliable ingestion past 800,000 products. A restart now costs seconds instead of re-embedding the whole catalogue.

How changes ship

I build with AI coding agents every day, and I own what they write. User stories and behavioural checks tell them what the code must do and how it must behave under load and across tangled dependencies, so they work like clones of me. I review their output like a new hire's work.

A change ships only when an evaluation says it is better: latency comparisons, recognition tests and blind side-by-side conversation judges.

Output: 260+ merged pull requests in my first five months.