Why Structured Wine Pairing Differs from Generative AI

Ask ChatGPT "what wine with carbonara?" three times. You'll get three different answers. Sometimes it recommends Chardonnay. Sometimes Pinot Grigio. Sometimes it suggests a Pecorino (the wine, not the cheese -- though it has confused those too).

This isn't a bug. It's the fundamental nature of large language models: they generate plausible-sounding text, not deterministic answers. For creative writing, that's a feature. For recommending a specific wine to pair with a specific dish, it's a dealbreaker.

We built something different. The SommelierX Wine DNA algorithm is a deterministic flavour-matching system that calculates wine-food pairings across 17 food dimensions and 19 wine dimensions. Same input, same output. Every time. This post explains why we chose this approach, how it works, and where LLMs still play a role in our stack.

The Problem with LLM Wine Advice

Generative AI and a structured pairing model solve different problems. The table below describes those architectural differences; it is not presented as an independent benchmark.

Metric	LLMs (avg)	Wine DNA
Repeatability	Can vary with model, prompt and settings	Deterministic for the same structured input
Pairing method	Generates an answer from language patterns	Calculates from profiled wine and dish dimensions
Knowledge structure	Broad, general-purpose context	609 wine styles, 19 wine dimensions and 17 dish dimensions
Output form	Narrative recommendation	Compatibility score with dimension-level explanation
Explainability	Narrative (variable)	Score breakdown per dimension

A language model is valuable for conversation and interpretation. A structured model is useful when the same input must lead to the same calculation. SommelierX combines those roles where appropriate, while keeping the pairing calculation itself structured.

The Wine DNA Approach: Structured Flavour Dimensions

Instead of asking a language model to generate a recommendation, we built a system that calculates one. Here's the architecture:

Step 1: Decompose Every Dish into Ingredients

Every dish in the system is broken down into its constituent ingredients. A carbonara becomes: pasta (neutral), egg yolk (rich, fatty), pecorino (salty, umami), guanciale (smoky, salty, fatty), black pepper (spicy). Each ingredient has a pre-scored flavour profile across 19 wine dimensions and 17 dish dimensions.

Step 2: Calculate the Dish's Composite Flavour Profile

The ingredient profiles are weighted and combined into a single dish vector. The weighting considers ingredient prominence (is it a main ingredient or a garnish?), cooking method impact (grilling adds smokiness, frying adds richness), and ingredient interactions (tomato + basil = more than the sum of parts).

Step 3: Match Against Wine Style Profiles

Every wine style in our database (609 MetaWijn archetypes, representing every meaningful wine style in the world) has a 19-dimension flavour profile scored by our sommelier team. The matching algorithm calculates compatibility across all dimensions simultaneously, producing a match score from 0-100.

The 17 Food Dimensions

• Acidity, Sweetness, Bitterness, Umami, Saltiness
• Fat/Richness, Spice/Heat, Smoke
• Herbs, Earthy, Mineral
• Fruit (fresh), Fruit (cooked/dried)
• Dairy/Cream, Nuts, Fermented, Charred

The 19 Wine Dimensions

• Acidity, Sweetness, Bitterness, Tannin (grip), Tannin (texture)
• Body/Weight, Alcohol warmth, Fruit intensity, Fruit type (red/dark/tropical/citrus)
• Oak influence, Herbal character, Earthy/mineral
• Floral, Spice, Smoke, Oxidative notes
• Effervescence, Salinity, Complexity

Why Deterministic Beats Generative (For This Domain)

The choice between deterministic and generative AI isn't absolute -- it depends on the domain. Here's why wine pairing is firmly in the deterministic camp:

1. Reproducibility

A sommelier who recommends Barolo with venison on Monday should recommend Barolo with venison on Tuesday. Consistency is a quality signal in this domain. Our algorithm provides it by design. LLMs provide it by chance.

2. Explainability

When a user asks "why this wine?", we can show the exact dimension-by-dimension breakdown: "This Sangiovese scores 92% because its acidity (8/10) matches the tomato's acidity (7/10), its tannin (6/10) complements the protein density (5/10), and its herbal character (7/10) harmonises with the basil (8/10)."

An LLM generates a plausible-sounding explanation, but it's post-hoc narrative, not causal reasoning. It might say "Sangiovese pairs well because Italian wine goes with Italian food" -- which is a correlation, not a mechanism.

3. Auditability

When our sommelier team disagrees with a recommendation, they can examine the exact scores and identify which dimension is miscalibrated. With an LLM, debugging a bad recommendation means... prompting differently and hoping for a better answer.

4. Predictable processing

The structured score calculation avoids a new generative answer for every comparison. That gives the recommendation layer predictable behavior and makes its latency and infrastructure cost easier to control. Exact response time still depends on recognition, network and the endpoint used.

5. Clear system boundaries

Recognition and calculation are separate steps. The current app uses server-backed flows and therefore requires a connection for those functions; the deterministic calculation refers to how the recommendation is produced, not to a promise of offline availability.

Where LLMs Are Brilliant (And We Use Them)

We're not anti-LLM. We use them where they genuinely excel:

Recipe URL Extraction

When a user pastes a recipe URL, we use an LLM to extract the ingredient list and cooking method from unstructured HTML. This is a perfect LLM task: understanding natural language in varied formats, where small variations in output are acceptable.

Photo Recognition

Users can photograph their dish, and a vision model identifies the food and its likely ingredients. This feeds into the deterministic algorithm, which then calculates the pairing. LLM for perception, algorithm for recommendation.

Natural Language Queries

When a user types "what wine with my grandmother's Sunday roast with gravy and Yorkshire pudding?", an LLM parses this into structured ingredients that the algorithm can process. The LLM is the interface layer, not the recommendation engine.

The Hybrid Architecture

Our stack looks like this:

User Input (text/URL/photo)
    |
    v
[LLM Layer] -- Parse, extract, identify
    |
    v
Structured Ingredients + Method
    |
    v
[Wine DNA Algorithm] -- Calculate match scores
    |
    v
Ranked Wine Recommendations (deterministic)

This gives us the best of both worlds: the flexibility of LLMs for input processing, and the reliability of a deterministic algorithm for the recommendation itself.

The data: 17 years of structured expertise

The algorithm is only as useful as its structured domain data. The model has been built over 17 years with scientists and professional sommeliers. It combines expert knowledge with explicit wine and dish dimensions rather than deriving the pairing score from scraped reviews.

The database currently contains:

• 609 calculated wine styles with 19-dimensional Wine DNA profiles
• 17 dish dimensions used to represent the complete dish structure
• 314,000+ concrete wines mapped to the foundational wine-style layer

Try It Yourself

We've opened the algorithm to developers and integrators:

• API: docs.sommelierx.com -- RESTful API for wine pairing, wine search, and wine data
• MCP Server: npx @sommelierx/mcp-server -- integrate wine pairing into Claude, GPT, and other AI assistants via the Model Context Protocol
• Consumer App: app.sommelierx.com -- try pairings directly, scan wine labels, and explore

The MCP server is particularly interesting for developers building AI assistants. Instead of having your LLM hallucinate wine recommendations, you can route the query to a deterministic algorithm and return a validated answer. Best of both worlds.

Conclusion: Right Tool for the Right Job

LLMs are extraordinary tools. They've transformed how we interact with computers, and they play a critical role in our stack. But they're not the right tool for every job.

Wine-food pairing is a domain-specific, consistency-critical problem. A structured calculation and a general-purpose language model serve different roles: the language model can interpret flexible input, while the Wine DNA model produces the repeatable score and explanation.

The lesson generalises: before reaching for an LLM, ask yourself whether your problem requires generation or calculation. If the answer is calculation, you might be better off with a structured algorithm. If the answer is generation, LLMs are unbeatable. And if the answer is "both" -- as it is for us -- build a hybrid.

Frequently Asked Questions

Why not just use ChatGPT for wine pairing?

LLMs like ChatGPT give different answers every time you ask. Ask "what wine with carbonara" three times and you'll get three different recommendations. For a domain where precision matters -- recommending a specific wine to pair with a specific dish -- this non-determinism is a dealbreaker. Our algorithm gives the same answer every time, because it's calculating, not generating.

How many flavour dimensions does the Wine DNA algorithm use?

The algorithm uses 17 food dimensions and 19 wine dimensions. Food dimensions include acidity, sweetness, umami, bitterness, fat/richness, spice/heat, smoke, herbs, and more. Wine dimensions include similar taste metrics plus tannin structure, fruit intensity, oak influence, and minerality. The match score is calculated across all dimensions simultaneously.

Is the SommelierX API available for developers?

Yes. The SommelierX API is available at docs.sommelierx.com. You can also use our MCP server (npx @sommelierx/mcp-server) to integrate wine pairing into AI assistants and tools. The consumer app is available at app.sommelierx.com.

How does the algorithm handle recipes it has never seen?

Every recipe is decomposed into individual ingredients, each with a known flavour profile. Even novel combinations are handled because the algorithm understands ingredient-level properties. A dish the system has never seen before is just a new combination of known flavour vectors -- the math works the same way.