Key facts
| Embeddings | Live embeddings API for item and user-interest vectors |
| Ranking | Vector similarity plus your own business rules and filters |
| Router model | plugsky-fusion escalates for explanation generation (live) |
| Refresh | Re-embed only changed items by hash |
| Models | 30+ models; cheap tiers suit short explanations |
| Pricing | Flat monthly self-serve plans with no per-token charges on self-serve |
| Free tier | plugsky-micro and plugsky-lite on the free plan, no card required |
| Roadmap | Batch re-embedding is coming soon; run bounded refresh jobs today |
TL;DR
- Rank with embeddings; do not pay a language model per impression.
- Refresh vectors incrementally as items change.
- Cache recommendation sets for stable user segments.
- Generate explanations on demand, on cheap tiers.
- Measure cost per served recommendation, not per model call.
How it works, step by step
- Embed items and their attributes once, and store vectors with filterable metadata.
- Derive user-interest vectors from behaviour and preferences.
- Rank by similarity plus business rules such as availability, margin and diversity.
- Re-embed only items whose content or attributes changed, tracked by hash.
- Cache recommendation sets for users or segments with short expiry.
- Generate explanations or summaries on demand with cheap tiers and strict length caps.
- Track cost per served recommendation, click-through and explanation usage.
Try it yourself
Open the embedding cost calculator →
Embeddings do the heavy lifting
Recommendation is fundamentally a similarity problem: rank items by closeness to a user's interests, then apply business rules. Embeddings solve similarity cheaply and deterministically at query time, without a language model involved. Chat models add nothing to ranking except expense and latency.
Where teams go wrong is generating personalised prose for every impression. That is a content-generation workload disguised as a recommendation, and it should be opt-in, cached, or removed entirely. Most interfaces work better with item metadata than with generated copy.
Refreshing vectors efficiently
Catalogue churn drives cost: prices, stock, descriptions and attributes change constantly, and re-embedding everything on a schedule is wasteful. Hash item content and re-embed only what changed. For high-volume feeds, batch refresh jobs during low-traffic windows and keep the previous vector until the replacement is indexed.
- Separate slowly changing attributes from fast-changing ones; embed the stable combination.
- Store business-rule fields in metadata so ranking can filter without another model call.
- Version vectors so an algorithm change can be rolled back without re-embedding.
- Watch staleness metrics: embedding age by item category.
Explanations, caching and measurement
Explanations — 'why am I seeing this?' — are valuable but rare. Serve them on demand from cheap tiers with a short output cap, and cache the result per item and user segment. That keeps a premium feature affordable without degrading the core ranking experience.
Measure cost per served recommendation alongside click-through, conversion and diversity, and compare against a rules-only baseline. If embeddings are not improving outcomes measurably, the honest optimisation is to simplify. Flat self-serve plans keep serving costs predictable — see the live pricing page for plans — and the free plan with plugsky-micro and plugsky-lite is enough to build and evaluate the pipeline.
Honest comparison
| Recommendation choice | Embedding-ranked on Plugsky | LLM ranking per impression | Rules-only ranking |
|---|---|---|---|
| Ranking | Vector similarity plus rules | Language model per request | Deterministic rules |
| Refresh | Incremental by hash | Often full rebuilds | Not applicable |
| Explanations | On demand, cheap tier, cached | Generated every time | Static text |
| Repeat impressions | Cached sets | Paid again | Free |
| Economics | Cost per served recommendation | Cost per impression | No model cost |
Frequently asked questions
Do recommendations need a language model?
Not for ranking. Embeddings handle similarity cheaply and deterministically. Language models are useful for on-demand explanations and summaries, which can be capped and cached.
How do I keep embedding costs down?
Embed once, re-embed only changed items by hash, and batch refresh jobs in low-traffic windows. Catalogue churn should drive cost, not the calendar.
How do I add business rules?
Store availability, margin, category and diversity fields in vector metadata and apply them as filters after similarity ranking. That avoids extra model calls.
Should I generate personalised copy?
Only where it changes behaviour. Personalised prose per impression is expensive and often less useful than clear item metadata. Make it opt-in and cached.
How do I measure success?
Cost per served recommendation plus click-through, conversion and diversity, compared against a rules-only baseline. Ranking quality is the point, not model usage.
Can recommendations run in real time?
Vector similarity is fast enough for real time when the index is well maintained. Cache recommendation sets for stable segments to remove repeated work.
Is batch re-embedding available?
Not yet — batch endpoints are coming soon. Run bounded refresh jobs today and keep previous vectors until replacements are ready.
Can I test cheaply?
Yes. plugsky-micro and plugsky-lite are on the free plan with no card, and the 14-day full-access trial covers stronger models for explanation features.