How much energy does an AI movie recommendation use?

The thesis: intelligence belongs in the data, not in every request

Large language models answer every question by activating their entire world knowledge at runtime. That is impressive, but wasteful once the same task recurs thousands of times. A movie recommendation does not need world knowledge on every call. It needs a precise, reusable understanding of movies and of your taste.

MovieMind puts that understanding into the data pipeline. Every movie is embedded as a vector exactly once, with its description, genres, director and keywords, and that knowledge is shared across all users. Your taste sits next to it as a structure over your own ratings. A prediction then becomes a neighborhood lookup in that space, and a language search becomes a small language step over prefiltered candidates. Data structure replaces compute. That is exactly where the measured factors in this article come from.

The example user

Alex has rated 120 movies and uses MovieMind for a typical month: 20 natural-language vibe searches, 1 profile summary and 250 rating predictions. The predictions are no side note: every vibe search shows a personal prediction for each of its 6 results, which is 120 per month from searches alone, plus a good 4 per day while browsing lists and detail views. All MovieMind figures in this article were measured on 2026-07-28 with real API requests (model: gemini-3.1-flash-lite (thinking: low)), not estimated.

The measurements

Token usage of real, production-identical requests:

Vibe search (MovieMind)

1042 input + 725 output + 128 reasoning = 1895 tokens

Profile summary (MovieMind)

509 tokens

Rating prediction (MovieMind)

0 LLM tokens, one pgvector database query, under 0.001 Wh

Chatbot equivalent of one prediction (titles + ratings only)

2667 input tokens for the pasted rating list (verified via countTokens), around 3300 tokens in total

Chatbot equivalent at equal information

11,425 input tokens for 120 titles with description, genres, director and tagline each (measured via countTokens, about 95 tokens per title), around 12,100 tokens in total

Measurement 1: the language search, 2 to 10 times leaner

Where language has to be understood, MovieMind does use a language model, but the smallest capable one with throttled reasoning: a measured 1895 tokens per vibe search, only 128 of them reasoning tokens. The actual recommendation intelligence sits not in the model but in the vector search in front of it, which filters thousands of titles down to 18 candidates before the model ever runs. A large chatbot would need your history in context for the same task, around 3,900 tokens or about 1.3 Wh. Depending on the model assumption this yields factor 2 (conservative: our small model counted like a large one) to 10 (realistic).

The advantage is not static: it grows with every movie you rate. Imagine keeping your ratings in a spreadsheet and pasting them into ChatGPT for every search. That list grows with every movie night. MovieMind's search cost stays flat at 1895 tokens because the recommendation intelligence lives in pre-computed embeddings and the pgvector search, not in the LLM prompt. The LLM only selects from 18 pre-filtered candidates and writes the rationale.

The formula is transparent: chatbot context = 1,260 overhead tokens (system prompt, query, output, reasoning) + 22 tokens per rated title. MovieMind stays at 1895 tokens regardless of collection size. The conservative lower end counts Flash-Lite at the same energy rate as a large chatbot model; the realistic upper end counts it at one fifth.

Measurement 2: the rating prediction, more than 1,000 times leaner

MovieMind answers how much you would like a movie without any language model: as a similarity-weighted average of the most similar titles you have already rated. That is a database query with an upper bound of 0.001 Wh. A chatbot has no store of your movie history, so it has to go into the prompt on every single request. The floor is a bare title-and-rating list: a measured 2667 tokens for 120 titles, around 3300 tokens in total, roughly 1.1 Wh, a factor above 1,000. That floor is deliberately chatbot-friendly, because it assumes the model reliably knows every title from training. True for blockbusters, not reliable for niche titles, releases after the training cutoff or ambiguous names. For the same information base MovieMind computes with (description, genres, director and tagline for every rated title), we rebuilt the prompt from 120 real titles and measured it: 11,425 input tokens, around 12,100 tokens in total, about 4.1 Wh, a factor of roughly 4,000. The gap grows with the library: at 500 rated titles it is around 48,200 tokens, about 16 Wh, a factor of roughly 16,000. The MovieMind query stays constant regardless of collection size.

Measurement 3: a full month, at least 20 times, realistically up to 350 times leaner

Alex's MovieMind month: 20 vibe searches and 1 summary add up to roughly 38,000 LLM tokens, plus 250 predictions as database queries that together cost less than 0.3 Wh. Total: about 3 to 13 Wh. The same utility via chatbot already costs roughly 900,000 tokens or about 300 Wh in the chatbot-friendly title-list variant. At equal information, meaning descriptions in every request, it is roughly 3.3 million tokens or about 1,100 Wh, a factor of 80 to 350. The structural reason stays the same: MovieMind computes a movie's embedding exactly once and shares it across all users, a chatbot re-derives the taste understanding in every session.

Why quality rises rather than falls

Efficiency sounds like a compromise. Here it is the opposite. A chatbot only knows your taste if you hand it your complete rating list with every question, and even then it has to re-derive it from a text list. MovieMind permanently computes with your full rating history in the same vector space the movies live in. Every new rating sharpens the picture without anything having to be explained again. A recommendation is therefore not a model's opinion but a traceable derivation from your own judgments.

Assumptions and conversion

• Conversion: 0.34 Wh per average chatbot query (OpenAI) at an assumed ~1,000 processed tokens, energy scaled proportionally to token count.
• Conservative variant: our Flash-Lite requests are counted at the same energy rate as a large chatbot model. Realistic variant: one fifth of that, since Lite-class models are much smaller.
• The kNN prediction is stated as an upper bound (a few milliseconds of database time on shared infrastructure).
• Excluded on both sides: base model training, network and end-user devices. The comparison covers inference per request.
• Chatbot memory doesn't change the math: stored notes are injected as context tokens on every request and never hold a complete, structured rating list. Prompt caching only lowers cost while the cache is alive (typically minutes), and never to zero.
• The equal-information measurement is itself conservative: the up to 15 keywords per title that feed the real MovieMind embedding text are missing from the rebuilt prompt. True parity would sit even higher.
• All factors are deliberately rounded in favor of the chatbot.

Sources

• OpenAI (Juni 2025): ~0.34 Wh per average ChatGPT query
• Google (August 2025): ~0.24 Wh per median Gemini text prompt