From c803b2c38d030b6157514e56e4e8076f11c3e5a0 Mon Sep 17 00:00:00 2001 From: Leonie Monigatti Date: Tue, 29 Sep 2026 12:19:33 +0200 Subject: [PATCH 1/5] add decision model docs page and migration guide --- docs.json | 6 +- guides/decision-model-guide.mdx | 550 +++++++++++++++++++++++++++ lfm/models/complete-library.mdx | 7 + lfm/models/decision-models.mdx | 639 ++++++++++++++++++++++++++++++++ link-snapshot.yaml | 2 + 5 files changed, 1202 insertions(+), 2 deletions(-) create mode 100644 guides/decision-model-guide.mdx create mode 100644 lfm/models/decision-models.mdx diff --git a/docs.json b/docs.json index 9b9d7ae..0e9dda7 100644 --- a/docs.json +++ b/docs.json @@ -1,7 +1,7 @@ { "$schema": "https://mintlify.com/docs.json", "banner": { - "content": "🚀 New: LFM2.5-VL-3B — our most capable vision-language model is now available! [Learn more →](/lfm/models/lfm25-vl-3b)", + "content": "🚀 New: d1 — our first decision model is now available! [Learn more →](/lfm/models/decision-models)", "dismissible": true }, "theme": "mint", @@ -68,6 +68,7 @@ "lfm/models/text-models", "lfm/models/vision-models", "lfm/models/audio-models", + "lfm/models/decision-models", "lfm/models/liquid-nanos" ] }, @@ -125,7 +126,8 @@ "pages": [ "guides/hardware-evaluation", "guides/use-case-evaluation", - "guides/migration-guide" + "guides/migration-guide", + "guides/decision-model-guide" ] }, { diff --git a/guides/decision-model-guide.mdx b/guides/decision-model-guide.mdx new file mode 100644 index 0000000..fd65e1d --- /dev/null +++ b/guides/decision-model-guide.mdx @@ -0,0 +1,550 @@ +--- +title: "Decision Model Guide" +description: "Replace LLM classification, routing, and scoring calls with decision models for faster, cheaper, and more consistent structured decisions." +--- + +If you use an LLM to classify text, route requests, score content, or make yes/no decisions, you are paying for text generation to get a structured answer. Decision models return typed decisions directly without generating tokens, parsing JSON, or validating schemas. + +This guide shows when and how to migrate these calls from LLMs to the [d1 decision model](/lfm/models/decision-models). + +## When and When Not to Migrate + +Migrate when the LLM's output is a **bounded decision**, meaning the set of possible answers is known before the call. + +| Task | LLM pattern | Primitive | +|---|---|---| +| [Classification](#classification) | Structured output with enum or JSON schema | [Choice](/lfm/models/decision-models#choice) | +| [Routing](#routing) | Prompt that picks from a list | [Choice](/lfm/models/decision-models#choice) | +| [Binary decision](#binary-decision) | Prompt that returns true/false | [Noul](/lfm/models/decision-models#noul) | +| [Scoring](#scoring) | Prompt that returns a number or rating | [Score](/lfm/models/decision-models#score) | +| [Reranking](#reranking) | LLM scores or filters search results | [Noul](/lfm/models/decision-models#noul) or [Score](/lfm/models/decision-models#score) | + +Keep your LLM when the task requires **generating new content**: + +- **Text generation**: drafting emails, summaries, reports, code +- **Open-ended Q&A**: answering user questions in natural language +- **Extraction of arbitrary values**: pulling names, dates, or amounts from text where the values are not known in advance +- **Multi-turn conversation**: chatbots and copilots +- **Complex reasoning**: multi-step logic, math, planning + +If the answer is one of N known options, use a decision model. If the answer is a new string the model must compose, use an LLM. + +| | LLM | Decision model (d1) | +|---|---|---| +| **Output** | Generated tokens parsed into a label | Typed decision with probabilities | +| **Latency** | 200ms to 2s per call | Around 100 to 200ms per call | +| **Output tokens** | Billed (even for a one-word answer) | Zero. No tokens generated. | +| **Confidence** | Not available, or an unreliable self-reported number | Calibrated probability distribution | +| **Schema errors** | Possible (malformed JSON, out-of-schema values) | Guaranteed by type system | +| **Multiple decisions** | Sequential calls or complex prompt | One call, all evaluated in parallel | + +## Setup + +Install the relevant SDK and configure your client. The LLM examples use the OpenAI SDK, which works with any OpenAI-compatible endpoint. The decision model examples use the [TypeSafe SDK](https://pypi.org/project/typesafe-sdk/) to call the [d1 decision model](/lfm/models/decision-models) through the Liquid AI API. + + + + ```bash + pip install openai pydantic + ``` + + ```python + import os + from openai import OpenAI + + client = OpenAI( + base_url=os.environ["LLM_BASE_URL"], + api_key=os.environ["LLM_API_KEY"], + ) + ``` + + + ```bash + pip install typesafe-sdk + ``` + + ```python + import os + from typesafe_sdk import TypeSafeClient + + client = TypeSafeClient( + api_key=os.environ["LIQUID_API_KEY"], + base_url="https://api.liquid.ai", + ) + ``` + + + +## Migration Examples + +Each example below shows how to migrate the same task solved with an LLM to solving it with a decision model. + +### Classification + +The standard LLM pattern for classification uses a JSON schema or enum constraint. The model generates tokens that conform to the schema, which you then parse. + + + + ```python + from pydantic import BaseModel + from typing import Literal + + class Classification(BaseModel): + department: Literal["billing", "technical", "shipping", "returns", "account"] + + inquiry = "I was charged twice for my subscription last month." + + completion = client.beta.chat.completions.parse( + model="your-model", + messages=[ + { + "role": "system", + "content": "Classify this customer inquiry into a department.", + }, + {"role": "user", "content": inquiry}, + ], + response_format=Classification, + ) + + department = completion.choices[0].message.parsed.department # "billing" + ``` + + + ```python + from typesafe_sdk import Choice + + inquiry = "I was charged twice for my subscription last month." + + result = client.system_one( + model="LiquidAI/d1", + state=inquiry, + questions={ + "department": Choice( + instructions="Which department should handle this customer inquiry?", + criteria={ + "billing": "Charges, invoices, refunds, or payment methods", + "technical": "Bug reports, feature requests, or how-to questions", + "shipping": "Order status, delivery tracking, or address changes", + "returns": "Return requests, exchanges, or product condition", + "account": "Login issues, profile updates, or subscription management", + }, + ), + }, + ) + + department = result.answers["department"].choice # "billing" + confidence = result.answers["department"].confidence # 0.82 + runner_up = sorted( + result.answers["department"].probabilities.items(), + key=lambda x: x[1], reverse=True, + )[1] # ("account", 0.07) + ``` + + + +**What changes:** +- Options are defined inline with descriptions. No Pydantic model or JSON schema needed. +- You get a probability distribution over all options and a confidence score alongside the top pick. +- Zero output tokens generated. The model evaluates all options in a single forward pass. +- Descriptions in `criteria` tell the model what each option means, while the LLM's enum only provides label names. + +### Routing + +A common pattern uses a small, cheap LLM to classify the complexity of an incoming request and route it to the appropriate model. + + + + ```python + from pydantic import BaseModel + from typing import Literal + + class Route(BaseModel): + complexity: Literal["simple", "complex"] + + user_message = "What's the weather like today?" + + completion = client.beta.chat.completions.parse( + model="your-model", + messages=[ + { + "role": "system", + "content": "Classify this request as simple or complex. " + "Simple: greetings, factual lookups, short answers. " + "Complex: analysis, multi-step reasoning, code generation.", + }, + {"role": "user", "content": user_message}, + ], + response_format=Route, + ) + + selected = completion.choices[0].message.parsed.complexity # "simple" + ``` + + + ```python + from typesafe_sdk import Choice + + user_message = "What's the weather like today?" + + result = client.system_one( + model="LiquidAI/d1", + state=user_message, + questions={ + "route": Choice( + instructions="Which model tier should handle this request?", + criteria={ + "fast": "Greetings, factual lookups, short answers, simple formatting", + "standard": "Moderate analysis, summarization, structured output", + "powerful": "Multi-step reasoning, code generation, complex analysis", + }, + ), + }, + ) + + route = result.answers["route"] + selected = route.choice # "fast" + confidence = route.confidence # 0.91 + # If confidence is low, fall back to the most capable model + ``` + + + +**What changes:** +- The router call is faster and cheaper than even the smallest LLM. +- You get confidence, so you can fall back to a stronger model when the router is uncertain instead of trusting a binary label. +- Adding a third tier (or more) is a criteria change, not a prompt rewrite. +- In production benchmarks, decision model routers have been measured at 8x faster while maintaining higher accuracy than LLM-based routers. + +### Binary Decision + +The typical LLM approach asks whether content is safe, either with structured output or by parsing a yes/no from the response. + + + + ```python + from pydantic import BaseModel + + class ModerationResult(BaseModel): + is_harmful: bool + + user_message = "You're an absolute idiot and I hope your company goes bankrupt." + + completion = client.beta.chat.completions.parse( + model="your-model", + messages=[ + { + "role": "system", + "content": "Determine if this message contains harmful, threatening, or abusive content.", + }, + {"role": "user", "content": user_message}, + ], + response_format=ModerationResult, + ) + + is_harmful = completion.choices[0].message.parsed.is_harmful # True + ``` + + + ```python + from typesafe_sdk import Noul + + user_message = "You're an absolute idiot and I hope your company goes bankrupt." + + result = client.system_one( + model="LiquidAI/d1", + state=user_message, + questions={ + "is_harmful": Noul( + instructions="Does this message contain harmful, threatening, or abusive content?", + ), + }, + ) + + p = result.answers["is_harmful"].noul + if p > 0.8: + action = "block" + elif p > 0.3: + action = "human_review" + else: + action = "allow" + ``` + + + +**What changes:** +- The probability (0.0 to 1.0) lets you set thresholds for different actions instead of committing to a binary label. +- The result is always a float. No string parsing or schema validation needed. +- Decision models produce more consistent results on repeated evaluations of the same input, reducing verdict flips. + +### Scoring + +The LLM approach for scoring asks the model to rate something on a scale, typically by generating a number or picking from a rubric with structured output. + + + + ```python + from pydantic import BaseModel, Field + from typing import Literal + + class UrgencyRating(BaseModel): + urgency: Literal[1, 2, 3, 4] = Field( + description="1=Can wait, 2=Handle today, 3=Within hours, 4=Critical" + ) + + ticket_text = ( + "Our production API is returning 500 errors on every request. " + "All customers are affected. Revenue impact is approximately $12,000 per hour. " + "Started 15 minutes ago." + ) + + completion = client.beta.chat.completions.parse( + model="your-model", + messages=[ + { + "role": "system", + "content": "Rate the urgency of this support request on a scale of 1-4:\n" + "1 = Can wait, no immediate impact\n" + "2 = Should handle today\n" + "3 = Time-sensitive, needs attention within hours\n" + "4 = Critical system failure", + }, + {"role": "user", "content": ticket_text}, + ], + response_format=UrgencyRating, + ) + + urgency = completion.choices[0].message.parsed.urgency # 4 + ``` + + + ```python + from typesafe_sdk import Score + + ticket_text = ( + "Our production API is returning 500 errors on every request. " + "All customers are affected. Revenue impact is approximately $12,000 per hour. " + "Started 15 minutes ago." + ) + + result = client.system_one( + model="LiquidAI/d1", + state=ticket_text, + questions={ + "urgency": Score( + instructions="How urgent is this support request?", + criteria=[ + "Can wait: no immediate business impact", + "Should handle today: minor inconvenience", + "Time-sensitive: noticeable customer impact, needs attention within hours", + "Critical: system failure affecting customers or revenue", + ], + ), + }, + ) + + score = result.answers["urgency"].score # 2.96 (continuous) + confidence = result.answers["urgency"].confidence # 0.96 + distribution = result.answers["urgency"].probabilities + # {"0": 0.0, "1": 0.0, "2": 0.04, "3": 0.96} + ``` + + + +**What changes:** +- The score is continuous (2.96), not a forced integer. It captures how strongly the model leans toward a level. +- You get the full probability distribution across all levels, so you can detect ambiguous cases. +- No JSON parsing, no schema validation, no retries on malformed output. + +### Reranking + +In retrieval-augmented generation (RAG) pipelines, a common pattern uses an LLM to score the relevance of each retrieved chunk before passing results to the generation step. + + + + ```python + from pydantic import BaseModel, Field + from typing import Literal + + class RelevanceScore(BaseModel): + score: Literal[1, 2, 3, 4, 5] = Field( + description="1=Not relevant, 5=Highly relevant" + ) + + query = "How do I reset my API key?" + chunks = [ + "To reset your API key, go to Dashboard > API Keys and click 'Regenerate'.", + "Our pricing plans start at $29/month for the Starter tier.", + "API keys are scoped to a single project. Each project can have up to 5 active keys.", + ] + + scored_chunks = [] + for chunk in chunks: + completion = client.beta.chat.completions.parse( + model="your-model", + messages=[ + { + "role": "system", + "content": f"Rate how relevant this passage is to the query: '{query}'\n" + "1 = not relevant, 5 = highly relevant.", + }, + {"role": "user", "content": chunk}, + ], + response_format=RelevanceScore, + ) + scored_chunks.append({ + "chunk": chunk, + "score": completion.choices[0].message.parsed.score, + }) + + top_chunks = sorted(scored_chunks, key=lambda x: x["score"], reverse=True) + ``` + + + ```python + from typesafe_sdk import Noul + + query = "How do I reset my API key?" + chunks = [ + "To reset your API key, go to Dashboard > API Keys and click 'Regenerate'.", + "Our pricing plans start at $29/month for the Starter tier.", + "API keys are scoped to a single project. Each project can have up to 5 active keys.", + ] + + scored_chunks = [] + for chunk in chunks: + result = client.system_one( + model="LiquidAI/d1", + state=f"Query: {query}\n\nPassage: {chunk}", + questions={ + "relevant": Noul( + instructions="Is this passage relevant to answering the query?", + ), + }, + ) + scored_chunks.append({ + "chunk": chunk, + "score": result.answers["relevant"].noul, + }) + + top_chunks = sorted(scored_chunks, key=lambda x: x["score"], reverse=True) + # Each score is a calibrated probability (0.0 to 1.0). + # Set a threshold to filter: [c for c in scored_chunks if c["score"] > 0.5] + ``` + + + +**What changes:** +- Each relevance score is a calibrated probability, not an arbitrary integer on a 1-5 scale. +- You can threshold directly (keep everything above 0.5) instead of guessing where to draw the line on integer scores. +- Each call is faster and cheaper, which compounds across large result sets. + +### Multi-Question + +LLM pipelines often chain multiple classification calls sequentially. Decision models evaluate all questions against the same state in a single call. + + + + ```python + from pydantic import BaseModel + from typing import Literal + + message = ( + "The checkout page crashes with a white screen whenever I try to apply a promo code. " + "I've tried three different browsers." + ) + + # Call 1: Classify intent + class IntentResult(BaseModel): + intent: Literal["billing", "technical", "shipping", "account"] + + intent_completion = client.beta.chat.completions.parse( + model="your-model", + messages=[ + {"role": "system", "content": "Classify the primary intent of this message."}, + {"role": "user", "content": message}, + ], + response_format=IntentResult, + ) + intent = intent_completion.choices[0].message.parsed.intent + + # Call 2: Score urgency + class UrgencyResult(BaseModel): + urgency: Literal[1, 2, 3] + + urgency_completion = client.beta.chat.completions.parse( + model="your-model", + messages=[ + {"role": "system", "content": "Rate the urgency of this message from 1 to 3."}, + {"role": "user", "content": message}, + ], + response_format=UrgencyResult, + ) + urgency = urgency_completion.choices[0].message.parsed.urgency + + # Call 3: Check if it's a bug + class BugCheck(BaseModel): + is_bug: bool + + bug_completion = client.beta.chat.completions.parse( + model="your-model", + messages=[ + {"role": "system", "content": "Determine if this message is a bug report."}, + {"role": "user", "content": message}, + ], + response_format=BugCheck, + ) + is_bug = bug_completion.choices[0].message.parsed.is_bug + ``` + + + ```python + from typesafe_sdk import Choice, Noul, Score + + message = ( + "The checkout page crashes with a white screen whenever I try to apply a promo code. " + "I've tried three different browsers." + ) + + result = client.system_one( + model="LiquidAI/d1", + state=message, + questions={ + "intent": Choice( + instructions="What is the primary topic of this inquiry?", + criteria={ + "billing": "Charges, invoices, refunds, or payment methods", + "technical": "Bug reports, feature requests, or product questions", + "shipping": "Order status, delivery, or address changes", + "account": "Login, profile, or subscription management", + }, + ), + "urgency": Score( + instructions="How urgent is this request?", + criteria=[ + "Can wait: no immediate impact", + "Should handle today: minor inconvenience", + "Time-sensitive: significant business impact", + ], + ), + "is_bug": Noul( + instructions="Is the customer reporting a software bug?", + ), + }, + ) + + intent = result.answers["intent"].choice + urgency = result.answers["urgency"].score + is_bug = result.answers["is_bug"].noul > 0.7 + ``` + + + +**What changes:** +- Three network round-trips become one. +- All three decisions are evaluated against the exact same snapshot of state. +- Total latency is roughly the same as a single decision, not 3x. + +## Next Steps + +- [Decision Models](/lfm/models/decision-models) for the API reference, primitives, and full code examples +- [Model Library](/lfm/models/complete-library) for all available Liquid AI models diff --git a/lfm/models/complete-library.mdx b/lfm/models/complete-library.mdx index a21407a..4dfca1f 100644 --- a/lfm/models/complete-library.mdx +++ b/lfm/models/complete-library.mdx @@ -38,6 +38,10 @@ Start with the model family that matches your input and output shape, then choos Interleaved audio/text models for TTS, ASR, and voice chat. + + Purpose-built models for classification, routing, and scoring. + + Task-specific models for extraction, summarization, RAG, and translation. @@ -116,4 +120,7 @@ Quantization reduces model size and speeds up inference with minimal quality los | [LFM2-350M-PII-Extract-JP](/lfm/models/lfm2-350m-pii-extract-jp) | LFM2 | [✓](https://huggingface.co/LiquidAI/LFM2-350M-PII-Extract-JP) | [✓](https://huggingface.co/LiquidAI/LFM2-350M-PII-Extract-JP-GGUF) | ✗ | ✗ | Yes (TRL) | | [LFM2-2.6B-Transcript](/lfm/models/lfm2-2.6b-transcript) | LFM2 | [✓](https://huggingface.co/LiquidAI/LFM2-2.6B-Transcript) | [✓](https://huggingface.co/LiquidAI/LFM2-2.6B-Transcript-GGUF) | ✗ | [✓](https://huggingface.co/onnx-community/LFM2-2.6B-Transcript-ONNX) | Yes (TRL) | +| **Decision Models** | | | | | | | +| [d1](/lfm/models/decision-models) | d1 | API | — | — | — | No | + Looking for an older model? Deprecated models and their recommended replacements are listed on the [Deprecations](/lfm/help/deprecations) page. diff --git a/lfm/models/decision-models.mdx b/lfm/models/decision-models.mdx new file mode 100644 index 0000000..4f1da50 --- /dev/null +++ b/lfm/models/decision-models.mdx @@ -0,0 +1,639 @@ +--- +title: "Decision Models" +description: "Purpose-built models for structured decisions: classification, routing, and scoring in a single forward pass with zero generated tokens" +icon: "scale-balanced" +--- + +Decision models are a new class of AI model purpose-built for structured decisions. Instead of generating text token by token, a decision model evaluates a situation and returns calibrated probabilities across a fixed set of outcomes in a single forward pass with zero generated tokens. + +## Primitives + +Every question you ask a decision model uses one of three types: + +- **Noul**: A yes/no question that returns a probability between 0 and 1. Think of it as a boolean on a sliding scale. "Is this message spam?" might return `0.92`, meaning the model is 92% confident the answer is yes. + +- **Choice**: A pick-one-from-many question that returns a probability distribution over named options. "Which department should handle this?" might return `{"billing": 0.65, "technical": 0.30, "account": 0.05}`. + +- **Score**: A rate-on-a-scale question that returns a probability-weighted position on an ordered rubric. "How urgent is this?" with three levels might return a score of `1.85` (between "Medium" and "High"), with a probability distribution over each level. + +Pick the type that matches the shape of the answer your code needs. + +| If the answer is... | Use | Example | +|---|---|---| +| Pick one from a set of unordered categories | **Choice** | Which department handles this ticket? | +| Rate something along an ordered scale with defined levels | **Score** | How severe is this bug? | +| Yes or no, where the probability itself is useful | **Noul** | Does this message contain personal data? | + +**Noul vs Score**: A Noul at 0.5 means maximum uncertainty between yes and no. It says nothing about degree or intensity. If you want to measure degree (skill level, frustration, severity), use a Score with defined levels. If you need a yes/no gate, use a Noul. + +**When the answer could fit more than one type**, think about what your code does next. If it branches on a category, use a Choice. If it compares against a threshold on a continuum, use a Score. If it gates on a boolean, use a Noul. + +## Setup + +1. Go to [console.liquid.ai](https://console.liquid.ai). +2. Navigate to **Dashboard > API Keys**. +3. Create a new key and copy it. Keys are prefixed with `liquid_`. + +Set the key as an environment variable: + +```bash +export LIQUID_API_KEY="liquid_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +``` + +## Your First Call + +A single API call contains three things: + +1. **Model**: which decision model to use. +2. **State**: the context the model should evaluate. This can be plain text (a customer message, an email, a log entry) or a JSON object with structured fields. +3. **Questions**: one or more typed questions, each with a name, a type, instructions, and criteria. You can ask multiple questions in the same call, and the model evaluates them all at once. + + + + ```bash + curl -s https://api.liquid.ai/v1/systemone \ + -H "Authorization: Bearer $LIQUID_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "model": "LiquidAI/d1", + "state": "I have been waiting over three weeks for my order and nobody has responded to my emails. This is completely unacceptable.", + "questions": { + "is_complaint": { + "type": "noul", + "instructions": "Is this message a complaint from the customer?" + } + } + }' + ``` + + + ```bash + pip install typesafe-sdk + ``` + + ```python + import os + from typesafe_sdk import TypeSafeClient, Noul + + client = TypeSafeClient( + api_key=os.environ["LIQUID_API_KEY"], + base_url="https://api.liquid.ai", + ) + + result = client.system_one( + model="LiquidAI/d1", + state="I have been waiting over three weeks for my order and nobody has responded to my emails. This is completely unacceptable.", + questions={ + "is_complaint": Noul( + instructions="Is this message a complaint from the customer?", + ), + }, + ) + print(result.answers["is_complaint"].noul) # 0.97 + ``` + + + ```bash + npm install @typesafe-ai/sdk + ``` + + ```typescript + import { TypeSafeClient } from "@typesafe-ai/sdk"; + + const client = new TypeSafeClient({ + apiKey: process.env.LIQUID_API_KEY!, + baseURL: "https://api.liquid.ai", + }); + + const result = await client.systemOne({ + model: "LiquidAI/d1", + state: "I have been waiting over three weeks for my order and nobody has responded to my emails. This is completely unacceptable.", + questions: { + is_complaint: { + type: "noul", + instructions: "Is this message a complaint from the customer?", + }, + }, + }); + console.log(result.answers.is_complaint.noul); // 0.97 + ``` + + + +**Response:** + +```json +{ + "model": "LiquidAI/d1", + "answers": { + "is_complaint": { + "type": "noul", + "noul": 0.97 + } + }, + "usage": { + "input_tokens": 142, + "output_tokens": 0 + } +} +``` + +**Reading the response:** + +- **`answers.is_complaint.noul`**: The probability that the answer is "yes." Here, `0.97` means the model is 97% confident this is a complaint. +- **`usage.output_tokens`**: Always `0`. Decision models do not generate tokens. +- **`usage.input_tokens`**: The total tokens consumed to evaluate the state and questions. + +The response contains one answer per question, each with a top-level result, a full probability distribution, and a confidence score. + +## Usage Examples + +### Noul + +A Noul question returns a single probability between 0 and 1. Your code receives a float that you can threshold to make a binary decision, use as a weight, or pass directly to downstream logic. Values near the extremes express high confidence; values near 0.5 express genuine uncertainty. + + + + ```bash + curl -s https://api.liquid.ai/v1/systemone \ + -H "Authorization: Bearer $LIQUID_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "model": "LiquidAI/d1", + "state": "You'\''re an absolute idiot and I hope your company goes bankrupt. I'\''m going to find out where you work.", + "questions": { + "is_harmful": { + "type": "noul", + "instructions": "Does this user message contain harmful, threatening, or abusive content?" + } + } + }' + ``` + + + ```python + result = client.system_one( + model=MODEL, + state="You're an absolute idiot and I hope your company goes bankrupt. I'm going to find out where you work.", + questions={ + "is_harmful": Noul( + instructions="Does this user message contain harmful, threatening, or abusive content?", + ), + }, + ) + ``` + + + ```typescript + const result = await client.systemOne({ + model: MODEL, + state: "You're an absolute idiot and I hope your company goes bankrupt. I'm going to find out where you work.", + questions: { + is_harmful: { + type: "noul", + instructions: "Does this user message contain harmful, threatening, or abusive content?", + }, + }, + }); + ``` + + + +**Response:** + +```json +{ + "is_harmful": { + "type": "noul", + "noul": 0.94 + } +} +``` + +**Using the result:** + +```python +p = result.answers["is_harmful"].noul + +if p > 0.8: + action = "block" +elif p < 0.2: + action = "allow" +else: + action = "human_review" +``` + +### Choice + +A Choice question returns the selected option, a probability distribution over all options, and a confidence score. The distribution tells you not just the top pick but how much probability mass sits on the runner-up, which is useful for flagging ambiguous cases or routing to a fallback. + + + + ```bash + curl -s https://api.liquid.ai/v1/systemone \ + -H "Authorization: Bearer $LIQUID_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "model": "LiquidAI/d1", + "state": "Hi, I was charged twice for my subscription last month. The amounts are $29.99 on March 3rd and again on March 5th. Can you refund the duplicate charge?", + "questions": { + "intent": { + "type": "choice", + "instructions": "What is the primary topic of this customer inquiry?", + "criteria": { + "billing": "Questions about charges, invoices, refunds, or payment methods", + "technical": "Bug reports, feature requests, or how-to questions about the product", + "shipping": "Order status, delivery tracking, or shipping address changes", + "returns": "Return requests, exchanges, or product condition issues", + "account": "Login issues, profile updates, or subscription management" + } + } + } + }' + ``` + + + ```python + result = client.system_one( + model=MODEL, + state="Hi, I was charged twice for my subscription last month. The amounts are $29.99 on March 3rd and again on March 5th. Can you refund the duplicate charge?", + questions={ + "intent": Choice( + instructions="What is the primary topic of this customer inquiry?", + criteria={ + "billing": "Questions about charges, invoices, refunds, or payment methods", + "technical": "Bug reports, feature requests, or how-to questions about the product", + "shipping": "Order status, delivery tracking, or shipping address changes", + "returns": "Return requests, exchanges, or product condition issues", + "account": "Login issues, profile updates, or subscription management", + }, + ), + }, + ) + ``` + + + ```typescript + const result = await client.systemOne({ + model: MODEL, + state: "Hi, I was charged twice for my subscription last month. The amounts are $29.99 on March 3rd and again on March 5th. Can you refund the duplicate charge?", + questions: { + intent: { + type: "choice", + instructions: "What is the primary topic of this customer inquiry?", + criteria: { + billing: "Questions about charges, invoices, refunds, or payment methods", + technical: "Bug reports, feature requests, or how-to questions about the product", + shipping: "Order status, delivery tracking, or shipping address changes", + returns: "Return requests, exchanges, or product condition issues", + account: "Login issues, profile updates, or subscription management", + }, + }, + }, + }); + ``` + + + +**Response:** + +```json +{ + "intent": { + "type": "choice", + "choice": "billing", + "probabilities": { + "billing": 0.89, + "account": 0.07, + "technical": 0.02, + "returns": 0.01, + "shipping": 0.01 + }, + "confidence": 0.82 + } +} +``` + +**Using the result:** + +```python +intent = result.answers["intent"].choice +confidence = result.answers["intent"].confidence + +queue_map = { + "billing": "billing-team", + "technical": "engineering-support", + "shipping": "logistics", + "returns": "returns-desk", + "account": "account-management", +} + +target_queue = queue_map[intent] +print(f"Route to: {target_queue} (confidence: {confidence:.2f})") +# Route to: billing-team (confidence: 0.82) +``` + +### Score + +A Score question returns a continuous value across an ordered rubric you define, plus the probability distribution over each level. The value is the probability-weighted position on the scale: if you define four levels (0 through 3), a score of `2.96` means the model places nearly all weight on the top level. + + + + ```bash + curl -s https://api.liquid.ai/v1/systemone \ + -H "Authorization: Bearer $LIQUID_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "model": "LiquidAI/d1", + "state": "Our production API is returning 500 errors on every request. All customers are affected. Revenue impact is approximately $12,000 per hour. Started 15 minutes ago.", + "questions": { + "urgency": { + "type": "score", + "instructions": "How urgent is this support request?", + "criteria": [ + "Can wait: no immediate business impact, can be addressed in normal queue", + "Should handle today: minor inconvenience or non-blocking issue", + "Time-sensitive: noticeable customer impact, needs attention within hours", + "Blocking revenue: critical system failure affecting customers or revenue" + ] + } + } + }' + ``` + + + ```python + result = client.system_one( + model=MODEL, + state="Our production API is returning 500 errors on every request. All customers are affected. Revenue impact is approximately $12,000 per hour. Started 15 minutes ago.", + questions={ + "urgency": Score( + instructions="How urgent is this support request?", + criteria=[ + "Can wait: no immediate business impact, can be addressed in normal queue", + "Should handle today: minor inconvenience or non-blocking issue", + "Time-sensitive: noticeable customer impact, needs attention within hours", + "Blocking revenue: critical system failure affecting customers or revenue", + ], + ), + }, + ) + ``` + + + ```typescript + const result = await client.systemOne({ + model: MODEL, + state: "Our production API is returning 500 errors on every request. All customers are affected. Revenue impact is approximately $12,000 per hour. Started 15 minutes ago.", + questions: { + urgency: { + type: "score", + instructions: "How urgent is this support request?", + criteria: [ + "Can wait: no immediate business impact, can be addressed in normal queue", + "Should handle today: minor inconvenience or non-blocking issue", + "Time-sensitive: noticeable customer impact, needs attention within hours", + "Blocking revenue: critical system failure affecting customers or revenue", + ], + }, + }, + }); + ``` + + + +**Response:** + +```json +{ + "urgency": { + "type": "score", + "score": 2.96, + "confidence": 0.96, + "probabilities": { + "0": 0.0, + "1": 0.0, + "2": 0.04, + "3": 0.96 + }, + "legend": { + "0": "Can wait: no immediate business impact, can be addressed in normal queue", + "1": "Should handle today: minor inconvenience or non-blocking issue", + "2": "Time-sensitive: noticeable customer impact, needs attention within hours", + "3": "Blocking revenue: critical system failure affecting customers or revenue" + } + } +} +``` + +**Using the result:** + +```python +score = result.answers["urgency"].score + +if score >= 2.5: + print("ACTION: Page on-call engineer immediately") +elif score >= 1.5: + print("ACTION: Escalate to senior support") +else: + print("ACTION: Add to standard queue") +``` + +### Combining All Three Primitives + +You can ask multiple questions of different types in the same call. The model evaluates all of them at once against the same state, so you get a complete decision in one round trip. This is useful when a single piece of input needs to be classified, routed, and prioritized together. + + + + ```bash + curl -s https://api.liquid.ai/v1/systemone \ + -H "Authorization: Bearer $LIQUID_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "model": "LiquidAI/d1", + "state": "{\"message\": \"The checkout page crashes with a white screen whenever I try to apply a promo code. I'\''ve tried three different browsers. This is blocking a $4,200 order for our team and we need to place it before our procurement window closes on Friday.\", \"account\": {\"plan\": \"enterprise\", \"arr\": 52000, \"customer_since\": \"2022-03-15\"}}", + "questions": { + "is_bug": { + "type": "noul", + "instructions": "Is the customer reporting a software bug (as opposed to a usage question, feature request, or account issue)?" + }, + "team": { + "type": "choice", + "instructions": "Which team should handle this ticket?", + "criteria": { + "billing": "Billing, invoicing, charges, and payment method issues", + "engineering": "Software bugs, crashes, and technical malfunctions", + "frontend": "UI/UX issues, display problems, and browser-specific bugs", + "account": "Account setup, permissions, plan changes, and access issues" + } + }, + "urgency": { + "type": "score", + "instructions": "How urgent is this ticket? Consider business impact, time sensitivity, and customer tier.", + "criteria": [ + "Low: no immediate impact, standard queue", + "Medium: some business impact, handle within 24 hours", + "High: significant business impact or time-sensitive, handle within 4 hours" + ] + } + } + }' + ``` + + + ```python + import json + + ticket = { + "message": "The checkout page crashes with a white screen whenever I try to apply a promo code. I've tried three different browsers. This is blocking a $4,200 order for our team and we need to place it before our procurement window closes on Friday.", + "account": { + "plan": "enterprise", + "arr": 52000, + "customer_since": "2022-03-15", + }, + } + + result = client.system_one( + model=MODEL, + state=json.dumps(ticket), + questions={ + "is_bug": Noul( + instructions="Is the customer reporting a software bug (as opposed to a usage question, feature request, or account issue)?", + ), + "team": Choice( + instructions="Which team should handle this ticket?", + criteria={ + "billing": "Billing, invoicing, charges, and payment method issues", + "engineering": "Software bugs, crashes, and technical malfunctions", + "frontend": "UI/UX issues, display problems, and browser-specific bugs", + "account": "Account setup, permissions, plan changes, and access issues", + }, + ), + "urgency": Score( + instructions="How urgent is this ticket? Consider business impact, time sensitivity, and customer tier.", + criteria=[ + "Low: no immediate impact, standard queue", + "Medium: some business impact, handle within 24 hours", + "High: significant business impact or time-sensitive, handle within 4 hours", + ], + ), + }, + ) + ``` + + + ```typescript + const ticket = { + message: "The checkout page crashes with a white screen whenever I try to apply a promo code. I've tried three different browsers. This is blocking a $4,200 order for our team and we need to place it before our procurement window closes on Friday.", + account: { + plan: "enterprise", + arr: 52000, + customer_since: "2022-03-15", + }, + }; + + const result = await client.systemOne({ + model: MODEL, + state: JSON.stringify(ticket), + questions: { + is_bug: { + type: "noul", + instructions: "Is the customer reporting a software bug (as opposed to a usage question, feature request, or account issue)?", + }, + team: { + type: "choice", + instructions: "Which team should handle this ticket?", + criteria: { + billing: "Billing, invoicing, charges, and payment method issues", + engineering: "Software bugs, crashes, and technical malfunctions", + frontend: "UI/UX issues, display problems, and browser-specific bugs", + account: "Account setup, permissions, plan changes, and access issues", + }, + }, + urgency: { + type: "score", + instructions: "How urgent is this ticket? Consider business impact, time sensitivity, and customer tier.", + criteria: [ + "Low: no immediate impact, standard queue", + "Medium: some business impact, handle within 24 hours", + "High: significant business impact or time-sensitive, handle within 4 hours", + ], + }, + }, + }); + ``` + + + +**Response:** + +```json +{ + "is_bug": { + "type": "noul", + "noul": 0.95 + }, + "team": { + "type": "choice", + "choice": "frontend", + "probabilities": { + "frontend": 0.62, + "engineering": 0.33, + "billing": 0.04, + "account": 0.01 + }, + "confidence": 0.38 + }, + "urgency": { + "type": "score", + "score": 1.88, + "confidence": 0.87, + "probabilities": { + "0": 0.01, + "1": 0.11, + "2": 0.88 + }, + "legend": { + "0": "Low: no immediate impact, standard queue", + "1": "Medium: some business impact, handle within 24 hours", + "2": "High: significant business impact or time-sensitive, handle within 4 hours" + } + } +} +``` + +**Using the result:** + +```python +answers = result.answers + +is_bug = answers["is_bug"].noul > 0.7 +team = answers["team"].choice +team_confidence = answers["team"].confidence +urgency = answers["urgency"].score + +if is_bug and urgency > 1.5: + print(f"ESCALATE to {team} on-call (SLA: 4h)") +elif urgency > 1.0: + print(f"PRIORITIZE in {team} queue (SLA: 24h)") +else: + print(f"QUEUE in {team} standard backlog") + +if team_confidence < 0.5: + probs = answers["team"].probabilities + runner_up = sorted(probs.items(), key=lambda x: x[1], reverse=True)[1] + print(f"NOTE: Routing uncertain. Runner-up: {runner_up[0]} ({runner_up[1]:.0%})") + +# ESCALATE to frontend on-call (SLA: 4h) +# NOTE: Routing uncertain. Runner-up: engineering (33%) +``` + +## When to Use Decision Models + +Decision models are a good fit when the answer is a structured decision: classification, categorization, routing (tickets, emails, requests), scoring, triage, content moderation, guardrails and safety checks, LLM-as-judge replacement, agent tool-call approval, and model routing or cascades. + +Use a language model instead for free-form text generation, creative writing, multi-turn conversation, complex multi-step reasoning, open-ended Q&A, summarization, and code generation. + +## Next Steps + +- [Model Library](/lfm/models/complete-library) for all available Liquid AI models diff --git a/link-snapshot.yaml b/link-snapshot.yaml index 2d73719..d91eea8 100644 --- a/link-snapshot.yaml +++ b/link-snapshot.yaml @@ -119,6 +119,7 @@ active: - /examples/web/audio-webgpu-demo - /examples/web/hand-voice-racer - /examples/web/vl-webgpu-demo + - /guides/decision-model-guide - /guides/hardware-evaluation - /guides/migration-guide - /guides/use-case-evaluation @@ -151,6 +152,7 @@ active: - /lfm/key-concepts/vision-capabilities - /lfm/models/audio-models - /lfm/models/complete-library + - /lfm/models/decision-models - /lfm/models/lfm2-1.2b - /lfm/models/lfm2-1.2b-extract - /lfm/models/lfm2-1.2b-rag From 709cf80a0b3c47f0cebab05b3f15c8277d0eebb3 Mon Sep 17 00:00:00 2001 From: Leonie Monigatti Date: Tue, 29 Sep 2026 13:17:18 +0200 Subject: [PATCH 2/5] initial review --- guides/decision-model-guide.mdx | 77 ++++++++++++++++++--------------- lfm/models/decision-models.mdx | 50 ++++++++++++--------- 2 files changed, 72 insertions(+), 55 deletions(-) diff --git a/guides/decision-model-guide.mdx b/guides/decision-model-guide.mdx index fd65e1d..433ae76 100644 --- a/guides/decision-model-guide.mdx +++ b/guides/decision-model-guide.mdx @@ -7,7 +7,7 @@ If you use an LLM to classify text, route requests, score content, or make yes/n This guide shows when and how to migrate these calls from LLMs to the [d1 decision model](/lfm/models/decision-models). -## When and When Not to Migrate +## When to Migrate Migrate when the LLM's output is a **bounded decision**, meaning the set of possible answers is known before the call. @@ -18,12 +18,12 @@ Migrate when the LLM's output is a **bounded decision**, meaning the set of poss | [Binary decision](#binary-decision) | Prompt that returns true/false | [Noul](/lfm/models/decision-models#noul) | | [Scoring](#scoring) | Prompt that returns a number or rating | [Score](/lfm/models/decision-models#score) | | [Reranking](#reranking) | LLM scores or filters search results | [Noul](/lfm/models/decision-models#noul) or [Score](/lfm/models/decision-models#score) | +| [Multiple decisions](#multi-question) | Several classification calls on the same input | Any combination, in one call | Keep your LLM when the task requires **generating new content**: - **Text generation**: drafting emails, summaries, reports, code - **Open-ended Q&A**: answering user questions in natural language -- **Extraction of arbitrary values**: pulling names, dates, or amounts from text where the values are not known in advance - **Multi-turn conversation**: chatbots and copilots - **Complex reasoning**: multi-step logic, math, planning @@ -32,15 +32,15 @@ If the answer is one of N known options, use a decision model. If the answer is | | LLM | Decision model (d1) | |---|---|---| | **Output** | Generated tokens parsed into a label | Typed decision with probabilities | -| **Latency** | 200ms to 2s per call | Around 100 to 200ms per call | +| **Latency** | Grows with output length and reasoning | Low and predictable. No tokens to generate. | | **Output tokens** | Billed (even for a one-word answer) | Zero. No tokens generated. | -| **Confidence** | Not available, or an unreliable self-reported number | Calibrated probability distribution | -| **Schema errors** | Possible (malformed JSON, out-of-schema values) | Guaranteed by type system | +| **Uncertainty** | Not available, or an unreliable self-reported number | Calibrated probabilities for every answer | +| **Schema errors** | Possible (malformed JSON, out-of-schema values) | None. Answers always match the question type. | | **Multiple decisions** | Sequential calls or complex prompt | One call, all evaluated in parallel | ## Setup -Install the relevant SDK and configure your client. The LLM examples use the OpenAI SDK, which works with any OpenAI-compatible endpoint. The decision model examples use the [TypeSafe SDK](https://pypi.org/project/typesafe-sdk/) to call the [d1 decision model](/lfm/models/decision-models) through the Liquid AI API. +Install the relevant SDK and configure your client. The LLM examples use the OpenAI SDK, which works with any OpenAI-compatible endpoint. The decision model examples use the [TypeSafe SDK](https://pypi.org/project/typesafe-sdk/) to call the [d1 decision model](/lfm/models/decision-models) through the Liquid AI API. To get an API key, see [Decision Models: Setup](/lfm/models/decision-models#setup). @@ -77,7 +77,7 @@ Install the relevant SDK and configure your client. The LLM examples use the Ope ## Migration Examples -Each example below shows how to migrate the same task solved with an LLM to solving it with a decision model. +Each example shows the same task solved with an LLM and with a decision model. ### Classification @@ -94,7 +94,7 @@ The standard LLM pattern for classification uses a JSON schema or enum constrain inquiry = "I was charged twice for my subscription last month." - completion = client.beta.chat.completions.parse( + completion = client.chat.completions.parse( model="your-model", messages=[ { @@ -144,9 +144,9 @@ The standard LLM pattern for classification uses a JSON schema or enum constrain **What changes:** - Options are defined inline with descriptions. No Pydantic model or JSON schema needed. -- You get a probability distribution over all options and a confidence score alongside the top pick. -- Zero output tokens generated. The model evaluates all options in a single forward pass. -- Descriptions in `criteria` tell the model what each option means, while the LLM's enum only provides label names. +- You get a probability distribution over all options alongside the top pick, plus a `confidence` value that summarizes how clear-cut the answer is. +- Zero output tokens generated. The model evaluates all options in a single call. +- Each option's description lives next to its label in `criteria` instead of in a separate prompt. ### Routing @@ -159,25 +159,26 @@ A common pattern uses a small, cheap LLM to classify the complexity of an incomi from typing import Literal class Route(BaseModel): - complexity: Literal["simple", "complex"] + tier: Literal["fast", "standard", "powerful"] user_message = "What's the weather like today?" - completion = client.beta.chat.completions.parse( + completion = client.chat.completions.parse( model="your-model", messages=[ { "role": "system", - "content": "Classify this request as simple or complex. " - "Simple: greetings, factual lookups, short answers. " - "Complex: analysis, multi-step reasoning, code generation.", + "content": "Which model tier should handle this request?\n" + "fast: greetings, factual lookups, short answers, simple formatting\n" + "standard: moderate analysis, summarization, structured output\n" + "powerful: multi-step reasoning, code generation, complex analysis", }, {"role": "user", "content": user_message}, ], response_format=Route, ) - selected = completion.choices[0].message.parsed.complexity # "simple" + selected = completion.choices[0].message.parsed.tier # "fast" ``` @@ -204,16 +205,18 @@ A common pattern uses a small, cheap LLM to classify the complexity of an incomi route = result.answers["route"] selected = route.choice # "fast" confidence = route.confidence # 0.91 - # If confidence is low, fall back to the most capable model + + # If the router is uncertain, fall back to the most capable tier + if confidence < 0.5: + selected = "powerful" ``` **What changes:** -- The router call is faster and cheaper than even the smallest LLM. -- You get confidence, so you can fall back to a stronger model when the router is uncertain instead of trusting a binary label. -- Adding a third tier (or more) is a criteria change, not a prompt rewrite. -- In production benchmarks, decision model routers have been measured at 8x faster while maintaining higher accuracy than LLM-based routers. +- The router call is typically faster and cheaper than an LLM-based router. +- You get a `confidence` value, so you can fall back to a stronger model when the router is uncertain instead of trusting a binary label. +- Adding or removing a tier is a change to `criteria`, not a prompt rewrite. ### Binary Decision @@ -229,7 +232,7 @@ The typical LLM approach asks whether content is safe, either with structured ou user_message = "You're an absolute idiot and I hope your company goes bankrupt." - completion = client.beta.chat.completions.parse( + completion = client.chat.completions.parse( model="your-model", messages=[ { @@ -260,13 +263,14 @@ The typical LLM approach asks whether content is safe, either with structured ou }, ) - p = result.answers["is_harmful"].noul + p = result.answers["is_harmful"].noul # 0.94 + if p > 0.8: action = "block" - elif p > 0.3: - action = "human_review" - else: + elif p < 0.2: action = "allow" + else: + action = "human_review" ``` @@ -297,7 +301,7 @@ The LLM approach for scoring asks the model to rate something on a scale, typica "Started 15 minutes ago." ) - completion = client.beta.chat.completions.parse( + completion = client.chat.completions.parse( model="your-model", messages=[ { @@ -351,7 +355,8 @@ The LLM approach for scoring asks the model to rate something on a scale, typica **What changes:** -- The score is continuous (2.96), not a forced integer. It captures how strongly the model leans toward a level. +- Levels are indexed from 0 in the order you list them, so a 4-level rubric scores from 0 to 3. A score of 2.96 means nearly all weight is on the top level (Critical). +- The score is continuous, not a forced integer. It captures how strongly the model leans toward a level. - You get the full probability distribution across all levels, so you can detect ambiguous cases. - No JSON parsing, no schema validation, no retries on malformed output. @@ -379,7 +384,7 @@ In retrieval-augmented generation (RAG) pipelines, a common pattern uses an LLM scored_chunks = [] for chunk in chunks: - completion = client.beta.chat.completions.parse( + completion = client.chat.completions.parse( model="your-model", messages=[ { @@ -437,10 +442,11 @@ In retrieval-augmented generation (RAG) pipelines, a common pattern uses an LLM - Each relevance score is a calibrated probability, not an arbitrary integer on a 1-5 scale. - You can threshold directly (keep everything above 0.5) instead of guessing where to draw the line on integer scores. - Each call is faster and cheaper, which compounds across large result sets. +- If you need graded relevance instead of relevant/not relevant, use a [Score](/lfm/models/decision-models#score) with defined relevance levels. ### Multi-Question -LLM pipelines often chain multiple classification calls sequentially. Decision models evaluate all questions against the same state in a single call. +LLM pipelines often chain multiple classification calls sequentially, one per decision. Decision models evaluate all questions against the same state in a single call. @@ -457,7 +463,7 @@ LLM pipelines often chain multiple classification calls sequentially. Decision m class IntentResult(BaseModel): intent: Literal["billing", "technical", "shipping", "account"] - intent_completion = client.beta.chat.completions.parse( + intent_completion = client.chat.completions.parse( model="your-model", messages=[ {"role": "system", "content": "Classify the primary intent of this message."}, @@ -471,7 +477,7 @@ LLM pipelines often chain multiple classification calls sequentially. Decision m class UrgencyResult(BaseModel): urgency: Literal[1, 2, 3] - urgency_completion = client.beta.chat.completions.parse( + urgency_completion = client.chat.completions.parse( model="your-model", messages=[ {"role": "system", "content": "Rate the urgency of this message from 1 to 3."}, @@ -485,7 +491,7 @@ LLM pipelines often chain multiple classification calls sequentially. Decision m class BugCheck(BaseModel): is_bug: bool - bug_completion = client.beta.chat.completions.parse( + bug_completion = client.chat.completions.parse( model="your-model", messages=[ {"role": "system", "content": "Determine if this message is a bug report."}, @@ -542,7 +548,8 @@ LLM pipelines often chain multiple classification calls sequentially. Decision m **What changes:** - Three network round-trips become one. - All three decisions are evaluated against the exact same snapshot of state. -- Total latency is roughly the same as a single decision, not 3x. +- Each question keeps its own type and probabilities. With an LLM you could merge the three schemas into one call, but you would still get only labels, with no probabilities. +- Questions are evaluated in parallel, so adding a question adds little latency compared to adding another LLM call. ## Next Steps diff --git a/lfm/models/decision-models.mdx b/lfm/models/decision-models.mdx index 4f1da50..9ac061c 100644 --- a/lfm/models/decision-models.mdx +++ b/lfm/models/decision-models.mdx @@ -1,16 +1,16 @@ --- title: "Decision Models" -description: "Purpose-built models for structured decisions: classification, routing, and scoring in a single forward pass with zero generated tokens" +description: "Purpose-built models for structured decisions: classification, routing, and scoring in a single call with zero generated tokens" icon: "scale-balanced" --- -Decision models are a new class of AI model purpose-built for structured decisions. Instead of generating text token by token, a decision model evaluates a situation and returns calibrated probabilities across a fixed set of outcomes in a single forward pass with zero generated tokens. +Decision models are a new class of AI model purpose-built for structured decisions. Instead of generating text token by token, a decision model evaluates a situation and returns calibrated probabilities across a fixed set of outcomes in a single call with zero generated tokens. ## Primitives Every question you ask a decision model uses one of three types: -- **Noul**: A yes/no question that returns a probability between 0 and 1. Think of it as a boolean on a sliding scale. "Is this message spam?" might return `0.92`, meaning the model is 92% confident the answer is yes. +- **Noul**: A yes/no question that returns a probability between 0 and 1. Think of it as a boolean on a sliding scale. "Is this message spam?" might return `0.92`, meaning a 0.92 probability that the answer is yes. - **Choice**: A pick-one-from-many question that returns a probability distribution over named options. "Which department should handle this?" might return `{"billing": 0.65, "technical": 0.30, "account": 0.05}`. @@ -46,7 +46,7 @@ A single API call contains three things: 1. **Model**: which decision model to use. 2. **State**: the context the model should evaluate. This can be plain text (a customer message, an email, a log entry) or a JSON object with structured fields. -3. **Questions**: one or more typed questions, each with a name, a type, instructions, and criteria. You can ask multiple questions in the same call, and the model evaluates them all at once. +3. **Questions**: one or more typed questions, each with a name, a type, and instructions. Choice and Score questions also take criteria that define the options or levels. You can ask multiple questions in the same call, and the model evaluates them all at once. @@ -140,17 +140,17 @@ A single API call contains three things: **Reading the response:** -- **`answers.is_complaint.noul`**: The probability that the answer is "yes." Here, `0.97` means the model is 97% confident this is a complaint. +- **`answers.is_complaint.noul`**: The probability that the answer is "yes." Here, `0.97` means a 0.97 probability that this is a complaint. - **`usage.output_tokens`**: Always `0`. Decision models do not generate tokens. - **`usage.input_tokens`**: The total tokens consumed to evaluate the state and questions. -The response contains one answer per question, each with a top-level result, a full probability distribution, and a confidence score. +The response contains one answer per question, keyed by the question name. A Noul answer is a single probability. Choice and Score answers also include a full probability distribution and a `confidence` value. ## Usage Examples ### Noul -A Noul question returns a single probability between 0 and 1. Your code receives a float that you can threshold to make a binary decision, use as a weight, or pass directly to downstream logic. Values near the extremes express high confidence; values near 0.5 express genuine uncertainty. +A Noul question returns a single probability between 0 and 1. Your code receives a float that you can threshold to make a binary decision, use as a weight, or pass directly to downstream logic. Values near 0 or 1 express a clear answer; values near 0.5 express genuine uncertainty. @@ -172,8 +172,10 @@ A Noul question returns a single probability between 0 and 1. Your code receives ```python + from typesafe_sdk import Noul + result = client.system_one( - model=MODEL, + model="LiquidAI/d1", state="You're an absolute idiot and I hope your company goes bankrupt. I'm going to find out where you work.", questions={ "is_harmful": Noul( @@ -186,7 +188,7 @@ A Noul question returns a single probability between 0 and 1. Your code receives ```typescript const result = await client.systemOne({ - model: MODEL, + model: "LiquidAI/d1", state: "You're an absolute idiot and I hope your company goes bankrupt. I'm going to find out where you work.", questions: { is_harmful: { @@ -199,7 +201,7 @@ A Noul question returns a single probability between 0 and 1. Your code receives -**Response:** +**Response** (`answers` field): ```json { @@ -225,7 +227,7 @@ else: ### Choice -A Choice question returns the selected option, a probability distribution over all options, and a confidence score. The distribution tells you not just the top pick but how much probability mass sits on the runner-up, which is useful for flagging ambiguous cases or routing to a fallback. +A Choice question returns the selected option, a probability distribution over all options, and a `confidence` value. `confidence` summarizes how clear-cut the answer is: high when one option clearly wins, lower when the probability is spread across several options. The distribution tells you not just the top pick but how much probability mass sits on the runner-up, which is useful for flagging ambiguous cases or routing to a fallback. @@ -254,8 +256,10 @@ A Choice question returns the selected option, a probability distribution over a ```python + from typesafe_sdk import Choice + result = client.system_one( - model=MODEL, + model="LiquidAI/d1", state="Hi, I was charged twice for my subscription last month. The amounts are $29.99 on March 3rd and again on March 5th. Can you refund the duplicate charge?", questions={ "intent": Choice( @@ -275,7 +279,7 @@ A Choice question returns the selected option, a probability distribution over a ```typescript const result = await client.systemOne({ - model: MODEL, + model: "LiquidAI/d1", state: "Hi, I was charged twice for my subscription last month. The amounts are $29.99 on March 3rd and again on March 5th. Can you refund the duplicate charge?", questions: { intent: { @@ -295,7 +299,7 @@ A Choice question returns the selected option, a probability distribution over a -**Response:** +**Response** (`answers` field): ```json { @@ -363,8 +367,10 @@ A Score question returns a continuous value across an ordered rubric you define, ```python + from typesafe_sdk import Score + result = client.system_one( - model=MODEL, + model="LiquidAI/d1", state="Our production API is returning 500 errors on every request. All customers are affected. Revenue impact is approximately $12,000 per hour. Started 15 minutes ago.", questions={ "urgency": Score( @@ -383,7 +389,7 @@ A Score question returns a continuous value across an ordered rubric you define, ```typescript const result = await client.systemOne({ - model: MODEL, + model: "LiquidAI/d1", state: "Our production API is returning 500 errors on every request. All customers are affected. Revenue impact is approximately $12,000 per hour. Started 15 minutes ago.", questions: { urgency: { @@ -402,7 +408,7 @@ A Score question returns a continuous value across an ordered rubric you define, -**Response:** +**Response** (`answers` field): ```json { @@ -483,6 +489,7 @@ You can ask multiple questions of different types in the same call. The model ev ```python import json + from typesafe_sdk import Choice, Noul, Score ticket = { "message": "The checkout page crashes with a white screen whenever I try to apply a promo code. I've tried three different browsers. This is blocking a $4,200 order for our team and we need to place it before our procurement window closes on Friday.", @@ -494,7 +501,7 @@ You can ask multiple questions of different types in the same call. The model ev } result = client.system_one( - model=MODEL, + model="LiquidAI/d1", state=json.dumps(ticket), questions={ "is_bug": Noul( @@ -533,7 +540,7 @@ You can ask multiple questions of different types in the same call. The model ev }; const result = await client.systemOne({ - model: MODEL, + model: "LiquidAI/d1", state: JSON.stringify(ticket), questions: { is_bug: { @@ -565,7 +572,7 @@ You can ask multiple questions of different types in the same call. The model ev -**Response:** +**Response** (`answers` field): ```json { @@ -634,6 +641,9 @@ Decision models are a good fit when the answer is a structured decision: classif Use a language model instead for free-form text generation, creative writing, multi-turn conversation, complex multi-step reasoning, open-ended Q&A, summarization, and code generation. +To move existing LLM calls to d1, see the [Decision Model Guide](/guides/decision-model-guide). + ## Next Steps +- [Decision Model Guide](/guides/decision-model-guide) for migrating LLM classification, routing, and scoring calls to d1 - [Model Library](/lfm/models/complete-library) for all available Liquid AI models From 7ba06ff58d11d8b2285a420f65346be97fbd9e6e Mon Sep 17 00:00:00 2001 From: Leonie Monigatti Date: Tue, 29 Sep 2026 13:26:13 +0200 Subject: [PATCH 3/5] fix numbers and model name after actual run --- guides/decision-model-guide.mdx | 28 ++++----- lfm/models/decision-models.mdx | 100 ++++++++++++++++---------------- 2 files changed, 64 insertions(+), 64 deletions(-) diff --git a/guides/decision-model-guide.mdx b/guides/decision-model-guide.mdx index 433ae76..419e208 100644 --- a/guides/decision-model-guide.mdx +++ b/guides/decision-model-guide.mdx @@ -116,7 +116,7 @@ The standard LLM pattern for classification uses a JSON schema or enum constrain inquiry = "I was charged twice for my subscription last month." result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state=inquiry, questions={ "department": Choice( @@ -133,11 +133,11 @@ The standard LLM pattern for classification uses a JSON schema or enum constrain ) department = result.answers["department"].choice # "billing" - confidence = result.answers["department"].confidence # 0.82 + confidence = result.answers["department"].confidence # 0.99 runner_up = sorted( result.answers["department"].probabilities.items(), key=lambda x: x[1], reverse=True, - )[1] # ("account", 0.07) + )[1] # ("account", 0.0006) ``` @@ -188,7 +188,7 @@ A common pattern uses a small, cheap LLM to classify the complexity of an incomi user_message = "What's the weather like today?" result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state=user_message, questions={ "route": Choice( @@ -204,7 +204,7 @@ A common pattern uses a small, cheap LLM to classify the complexity of an incomi route = result.answers["route"] selected = route.choice # "fast" - confidence = route.confidence # 0.91 + confidence = route.confidence # 0.98 # If the router is uncertain, fall back to the most capable tier if confidence < 0.5: @@ -254,7 +254,7 @@ The typical LLM approach asks whether content is safe, either with structured ou user_message = "You're an absolute idiot and I hope your company goes bankrupt." result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state=user_message, questions={ "is_harmful": Noul( @@ -263,7 +263,7 @@ The typical LLM approach asks whether content is safe, either with structured ou }, ) - p = result.answers["is_harmful"].noul # 0.94 + p = result.answers["is_harmful"].noul # 0.98 if p > 0.8: action = "block" @@ -331,7 +331,7 @@ The LLM approach for scoring asks the model to rate something on a scale, typica ) result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state=ticket_text, questions={ "urgency": Score( @@ -346,16 +346,16 @@ The LLM approach for scoring asks the model to rate something on a scale, typica }, ) - score = result.answers["urgency"].score # 2.96 (continuous) - confidence = result.answers["urgency"].confidence # 0.96 + score = result.answers["urgency"].score # 2.999 (continuous) + confidence = result.answers["urgency"].confidence # 0.998 distribution = result.answers["urgency"].probabilities - # {"0": 0.0, "1": 0.0, "2": 0.04, "3": 0.96} + # {0: 0.0, 1: 0.0, 2: 0.001, 3: 0.999} ``` **What changes:** -- Levels are indexed from 0 in the order you list them, so a 4-level rubric scores from 0 to 3. A score of 2.96 means nearly all weight is on the top level (Critical). +- Levels are indexed from 0 in the order you list them, so a 4-level rubric scores from 0 to 3. A score of 2.999 means nearly all weight is on the top level (Critical). - The score is continuous, not a forced integer. It captures how strongly the model leans toward a level. - You get the full probability distribution across all levels, so you can detect ambiguous cases. - No JSON parsing, no schema validation, no retries on malformed output. @@ -418,7 +418,7 @@ In retrieval-augmented generation (RAG) pipelines, a common pattern uses an LLM scored_chunks = [] for chunk in chunks: result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state=f"Query: {query}\n\nPassage: {chunk}", questions={ "relevant": Noul( @@ -512,7 +512,7 @@ LLM pipelines often chain multiple classification calls sequentially, one per de ) result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state=message, questions={ "intent": Choice( diff --git a/lfm/models/decision-models.mdx b/lfm/models/decision-models.mdx index 9ac061c..5ebe258 100644 --- a/lfm/models/decision-models.mdx +++ b/lfm/models/decision-models.mdx @@ -55,7 +55,7 @@ A single API call contains three things: -H "Authorization: Bearer $LIQUID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ - "model": "LiquidAI/d1", + "model": "d1:free", "state": "I have been waiting over three weeks for my order and nobody has responded to my emails. This is completely unacceptable.", "questions": { "is_complaint": { @@ -81,7 +81,7 @@ A single API call contains three things: ) result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state="I have been waiting over three weeks for my order and nobody has responded to my emails. This is completely unacceptable.", questions={ "is_complaint": Noul( @@ -89,7 +89,7 @@ A single API call contains three things: ), }, ) - print(result.answers["is_complaint"].noul) # 0.97 + print(result.answers["is_complaint"].noul) # 0.999 ``` @@ -106,7 +106,7 @@ A single API call contains three things: }); const result = await client.systemOne({ - model: "LiquidAI/d1", + model: "d1:free", state: "I have been waiting over three weeks for my order and nobody has responded to my emails. This is completely unacceptable.", questions: { is_complaint: { @@ -115,7 +115,7 @@ A single API call contains three things: }, }, }); - console.log(result.answers.is_complaint.noul); // 0.97 + console.log(result.answers.is_complaint.noul); // 0.999 ``` @@ -124,15 +124,15 @@ A single API call contains three things: ```json { - "model": "LiquidAI/d1", + "model": "d1:free", "answers": { "is_complaint": { "type": "noul", - "noul": 0.97 + "noul": 0.999 } }, "usage": { - "input_tokens": 142, + "input_tokens": 84, "output_tokens": 0 } } @@ -140,7 +140,7 @@ A single API call contains three things: **Reading the response:** -- **`answers.is_complaint.noul`**: The probability that the answer is "yes." Here, `0.97` means a 0.97 probability that this is a complaint. +- **`answers.is_complaint.noul`**: The probability that the answer is "yes." Here, `0.999` means a 0.999 probability that this is a complaint. - **`usage.output_tokens`**: Always `0`. Decision models do not generate tokens. - **`usage.input_tokens`**: The total tokens consumed to evaluate the state and questions. @@ -159,7 +159,7 @@ A Noul question returns a single probability between 0 and 1. Your code receives -H "Authorization: Bearer $LIQUID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ - "model": "LiquidAI/d1", + "model": "d1:free", "state": "You'\''re an absolute idiot and I hope your company goes bankrupt. I'\''m going to find out where you work.", "questions": { "is_harmful": { @@ -175,7 +175,7 @@ A Noul question returns a single probability between 0 and 1. Your code receives from typesafe_sdk import Noul result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state="You're an absolute idiot and I hope your company goes bankrupt. I'm going to find out where you work.", questions={ "is_harmful": Noul( @@ -188,7 +188,7 @@ A Noul question returns a single probability between 0 and 1. Your code receives ```typescript const result = await client.systemOne({ - model: "LiquidAI/d1", + model: "d1:free", state: "You're an absolute idiot and I hope your company goes bankrupt. I'm going to find out where you work.", questions: { is_harmful: { @@ -207,7 +207,7 @@ A Noul question returns a single probability between 0 and 1. Your code receives { "is_harmful": { "type": "noul", - "noul": 0.94 + "noul": 0.99 } } ``` @@ -236,7 +236,7 @@ A Choice question returns the selected option, a probability distribution over a -H "Authorization: Bearer $LIQUID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ - "model": "LiquidAI/d1", + "model": "d1:free", "state": "Hi, I was charged twice for my subscription last month. The amounts are $29.99 on March 3rd and again on March 5th. Can you refund the duplicate charge?", "questions": { "intent": { @@ -259,7 +259,7 @@ A Choice question returns the selected option, a probability distribution over a from typesafe_sdk import Choice result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state="Hi, I was charged twice for my subscription last month. The amounts are $29.99 on March 3rd and again on March 5th. Can you refund the duplicate charge?", questions={ "intent": Choice( @@ -279,7 +279,7 @@ A Choice question returns the selected option, a probability distribution over a ```typescript const result = await client.systemOne({ - model: "LiquidAI/d1", + model: "d1:free", state: "Hi, I was charged twice for my subscription last month. The amounts are $29.99 on March 3rd and again on March 5th. Can you refund the duplicate charge?", questions: { intent: { @@ -307,13 +307,13 @@ A Choice question returns the selected option, a probability distribution over a "type": "choice", "choice": "billing", "probabilities": { - "billing": 0.89, - "account": 0.07, - "technical": 0.02, - "returns": 0.01, - "shipping": 0.01 + "billing": 0.9997, + "account": 0.0002, + "returns": 0.00005, + "shipping": 0.00003, + "technical": 0.00002 }, - "confidence": 0.82 + "confidence": 0.9996 } } ``` @@ -334,12 +334,12 @@ queue_map = { target_queue = queue_map[intent] print(f"Route to: {target_queue} (confidence: {confidence:.2f})") -# Route to: billing-team (confidence: 0.82) +# Route to: billing-team (confidence: 1.00) ``` ### Score -A Score question returns a continuous value across an ordered rubric you define, plus the probability distribution over each level. The value is the probability-weighted position on the scale: if you define four levels (0 through 3), a score of `2.96` means the model places nearly all weight on the top level. +A Score question returns a continuous value across an ordered rubric you define, plus the probability distribution over each level. The value is the probability-weighted position on the scale: if you define four levels (0 through 3), a score of `2.9995` means the model places nearly all weight on the top level. @@ -348,7 +348,7 @@ A Score question returns a continuous value across an ordered rubric you define, -H "Authorization: Bearer $LIQUID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ - "model": "LiquidAI/d1", + "model": "d1:free", "state": "Our production API is returning 500 errors on every request. All customers are affected. Revenue impact is approximately $12,000 per hour. Started 15 minutes ago.", "questions": { "urgency": { @@ -370,7 +370,7 @@ A Score question returns a continuous value across an ordered rubric you define, from typesafe_sdk import Score result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state="Our production API is returning 500 errors on every request. All customers are affected. Revenue impact is approximately $12,000 per hour. Started 15 minutes ago.", questions={ "urgency": Score( @@ -389,7 +389,7 @@ A Score question returns a continuous value across an ordered rubric you define, ```typescript const result = await client.systemOne({ - model: "LiquidAI/d1", + model: "d1:free", state: "Our production API is returning 500 errors on every request. All customers are affected. Revenue impact is approximately $12,000 per hour. Started 15 minutes ago.", questions: { urgency: { @@ -414,13 +414,13 @@ A Score question returns a continuous value across an ordered rubric you define, { "urgency": { "type": "score", - "score": 2.96, - "confidence": 0.96, + "score": 2.9995, + "confidence": 0.9995, "probabilities": { - "0": 0.0, - "1": 0.0, - "2": 0.04, - "3": 0.96 + "0": 0.00001, + "1": 0.00002, + "2": 0.0004, + "3": 0.9996 }, "legend": { "0": "Can wait: no immediate business impact, can be addressed in normal queue", @@ -456,7 +456,7 @@ You can ask multiple questions of different types in the same call. The model ev -H "Authorization: Bearer $LIQUID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ - "model": "LiquidAI/d1", + "model": "d1:free", "state": "{\"message\": \"The checkout page crashes with a white screen whenever I try to apply a promo code. I'\''ve tried three different browsers. This is blocking a $4,200 order for our team and we need to place it before our procurement window closes on Friday.\", \"account\": {\"plan\": \"enterprise\", \"arr\": 52000, \"customer_since\": \"2022-03-15\"}}", "questions": { "is_bug": { @@ -501,7 +501,7 @@ You can ask multiple questions of different types in the same call. The model ev } result = client.system_one( - model="LiquidAI/d1", + model="d1:free", state=json.dumps(ticket), questions={ "is_bug": Noul( @@ -540,7 +540,7 @@ You can ask multiple questions of different types in the same call. The model ev }; const result = await client.systemOne({ - model: "LiquidAI/d1", + model: "d1:free", state: JSON.stringify(ticket), questions: { is_bug: { @@ -578,27 +578,27 @@ You can ask multiple questions of different types in the same call. The model ev { "is_bug": { "type": "noul", - "noul": 0.95 + "noul": 0.9998 }, "team": { "type": "choice", - "choice": "frontend", + "choice": "engineering", "probabilities": { - "frontend": 0.62, - "engineering": 0.33, - "billing": 0.04, - "account": 0.01 + "engineering": 0.80, + "frontend": 0.18, + "billing": 0.02, + "account": 0.0005 }, - "confidence": 0.38 + "confidence": 0.74 }, "urgency": { "type": "score", - "score": 1.88, - "confidence": 0.87, + "score": 1.996, + "confidence": 0.995, "probabilities": { - "0": 0.01, - "1": 0.11, - "2": 0.88 + "0": 0.0002, + "1": 0.004, + "2": 0.996 }, "legend": { "0": "Low: no immediate impact, standard queue", @@ -631,8 +631,8 @@ if team_confidence < 0.5: runner_up = sorted(probs.items(), key=lambda x: x[1], reverse=True)[1] print(f"NOTE: Routing uncertain. Runner-up: {runner_up[0]} ({runner_up[1]:.0%})") -# ESCALATE to frontend on-call (SLA: 4h) -# NOTE: Routing uncertain. Runner-up: engineering (33%) +# ESCALATE to engineering on-call (SLA: 4h) +# The NOTE line only prints when team confidence is below 0.5. ``` ## When to Use Decision Models From ead8b601de24cb4128316d83a21bd510c6191466 Mon Sep 17 00:00:00 2001 From: Leonie Monigatti Date: Tue, 29 Sep 2026 14:19:57 +0200 Subject: [PATCH 4/5] add cookbook example --- docs.json | 1 + examples/index.mdx | 4 + .../build-a-game-with-decision-models.mdx | 206 ++++++++++++++++++ .../laptop-examples/road-decider/demo.png | Bin 0 -> 140418 bytes link-snapshot.yaml | 1 + 5 files changed, 212 insertions(+) create mode 100644 examples/laptop-examples/build-a-game-with-decision-models.mdx create mode 100644 images/examples/laptop-examples/road-decider/demo.png diff --git a/docs.json b/docs.json index 0e9dda7..1e18a3b 100644 --- a/docs.json +++ b/docs.json @@ -161,6 +161,7 @@ "icon": "laptop", "pages": [ "examples/laptop-examples/invoice-extractor-tool-with-liquid-nanos", + "examples/laptop-examples/build-a-game-with-decision-models", "examples/laptop-examples/audio-to-text-in-real-time", "examples/laptop-examples/lfm2-english-to-korean", "examples/laptop-examples/flight-search-assistant", diff --git a/examples/index.mdx b/examples/index.mdx index f9d4ee6..fb32af7 100644 --- a/examples/index.mdx +++ b/examples/index.mdx @@ -10,6 +10,10 @@ title: "Examples Library" Turn invoices into structured JSON using a lightweight Vision Language Model. 100% local, no API costs. + + Build a pixel-art racing game where d1 chooses the safest lane in real time using structured decision outputs. + + Build a real-time audio transcription CLI using LFM2-Audio-1.5B with llama.cpp. 100% local processing without internet connection. diff --git a/examples/laptop-examples/build-a-game-with-decision-models.mdx b/examples/laptop-examples/build-a-game-with-decision-models.mdx new file mode 100644 index 0000000..cc05c8c --- /dev/null +++ b/examples/laptop-examples/build-a-game-with-decision-models.mdx @@ -0,0 +1,206 @@ +--- +title: "Build a game with decision models" +--- + + + Browse the complete example on GitHub + + +This example shows how to use Liquid's [decision model](/lfm/models/decision-models) to make structured choices in real time. You will build a pixel-art survival racer where an AI chooses which lane to drive in, hundreds of times per race. + +![Road Decider demo](/images/examples/laptop-examples/road-decider/demo.png) + +Two cars race side by side on identical roads that get faster over time. Each car has three lives, and hitting traffic costs one. Play **You vs d1** with the arrow keys, or watch **Jev vs d1** to compare two decision models head-to-head. + +Decision models are purpose-built for classification, routing, and scoring. Instead of generating text token by token, they return a structured answer in a single call. That makes them fast enough to use inside a game loop, and cheap enough to call on every tick. + +## Quickstart + +### 1. Clone the repository + +```sh +git clone https://github.com/Liquid4All/cookbook.git +cd cookbook/examples/road-decider +``` + +### 2. Add your API keys + +Create a `.env` file from the template: + +```sh +cp .env.example .env +``` + +Add your Liquid API key: + +```sh +LIQUID_API_KEY=your-liquid-api-key +``` + + + Jev vs d1 mode is optional. To enable it, add an OpenRouter key as `JEV_API_KEY`. + + +### 3. Install dependencies and start the demo + +```sh +npm install +npm run dev +``` + +Open [http://localhost:5173](http://localhost:5173) and start a race. If a key is missing, the start screen tells you which one and disables the modes that need it. + +## What's inside? + +The project is a vanilla JavaScript browser game with a Vite dev-server proxy: + +- `ai/ai.js` defines the decision question, builds the game state, calls the proxy route, and normalizes the answer. +- `game/game.js` owns the game loop, AI tick scheduling, collisions, and race results. +- `game/road.js` and `game/items.js` generate identical traffic patterns for both roads. +- `ui/` renders the canvas sprites, confidence bars, HUD, and keyboard input. +- `vite.config.js` keeps API keys server-side and forwards decision requests to Liquid or OpenRouter. + +## How it works + +Every decision tick, the AI car does four things: + +1. Defines a structured **choice** question. +2. Summarizes the road ahead as a compact text state. +3. Sends the state and question to the decision API. +4. Applies the returned lane choice to the car. + +### Define the question + +The game asks the model to pick one of three named lanes: + +```js +const QUESTION = { + lane: { + type: "choice", + instructions: + "Pick the safest lane. Row 1 is most urgent. Prefer the current lane when options are equally safe.", + criteria: { + left: "Left lane", + center: "Center lane", + right: "Right lane", + }, + }, +}; +``` + +The `type` tells the model what kind of answer to return. The `criteria` object lists the available options. + +### Build the state + +The AI does not receive the entire game screen. Instead, the game summarizes the nearest obstacle in each lane: + +```js +export function buildState(car, road) { + const currentLane = LANES[Math.round(car.laneIndex)]; + const lookAhead = road.getLookAhead(car.y, CONFIG.LOOK_AHEAD_ROWS); + + const laneSummaries = LANES.map((lane) => { + const firstObstacle = lookAhead[lane].findIndex((item) => item !== null); + if (firstObstacle === -1) return `${lane}: clear`; + return `${lane}: obstacle at row ${firstObstacle + 1}`; + }); + + return [ + `Current lane: ${currentLane}. Pick the lane with the most room ahead.`, + "", + ...laneSummaries, + ].join("\n"); +} +``` + +That produces a state like: + +```txt +Current lane: center. Pick the lane with the most room ahead. + +left: obstacle at row 2 +center: clear +right: obstacle at row 4 +``` + +This compact format gives the model the safety-relevant information without asking it to reason over raw pixels or a full grid. + +### Call the decision API + +The browser calls a local proxy route for each racer: + +```js +fetch(`/api/decision/${racer}`, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ + state, + questions: QUESTION, + }), +}); +``` + +The Vite proxy adds the API key and model server-side: + +```js +const upstream = await fetch(racer.url, { + method: "POST", + headers: { + Authorization: `Bearer ${racer.apiKey}`, + "Content-Type": "application/json", + }, + body: JSON.stringify({ ...body, model: racer.model }), +}); +``` + +This keeps keys out of the browser while letting the frontend use a simple local API. + +### Interpret the response + +The API returns the selected choice, per-lane probabilities, and confidence: + +```json +{ + "answers": { + "lane": { + "type": "choice", + "choice": "center", + "probabilities": { "left": 0.03, "center": 0.93, "right": 0.04 }, + "confidence": 0.93 + } + } +} +``` + +The game validates that the choice is one of the known lanes, moves the car, and updates the live confidence display below the road. + +## Configuration + +By default, d1 runs through Liquid's API and Jev runs through OpenRouter: + +| Variable | Default | Description | +| --- | --- | --- | +| `LIQUID_API_KEY` | | API key for d1. Required. | +| `LIQUID_MODEL_NAME` | `d1:free` | d1 model name. | +| `LIQUID_BASE_URL` | `https://api.liquid.ai` | API host for d1. | +| `JEV_API_KEY` | | OpenRouter API key. Required for Jev vs d1 mode. | +| `JEV_MODEL_NAME` | `typesafe/jev-1.13` | Jev model name. | +| `JEV_BASE_URL` | `https://openrouter.ai` | API host for Jev. | + +To run d1 through OpenRouter instead of Liquid's API: + +```sh +LIQUID_API_KEY=your-openrouter-api-key +LIQUID_MODEL_NAME=your-openrouter-d1-model +LIQUID_BASE_URL=https://openrouter.ai +``` + +## Need help? + + + + + Connect with the community and ask questions about this example. + + + diff --git a/images/examples/laptop-examples/road-decider/demo.png b/images/examples/laptop-examples/road-decider/demo.png new file mode 100644 index 0000000000000000000000000000000000000000..32b0d4e59d9108f1f16bf3b3274bfb6a2dbf6f2c GIT binary patch literal 140418 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 E2Zl$p$^ZZW literal 0 HcmV?d00001 diff --git a/link-snapshot.yaml b/link-snapshot.yaml index d91eea8..80bb432 100644 --- a/link-snapshot.yaml +++ b/link-snapshot.yaml @@ -112,6 +112,7 @@ active: - /examples/laptop-examples/audio-car-cockpit - /examples/laptop-examples/audio-to-text-in-real-time - /examples/laptop-examples/browser-control + - /examples/laptop-examples/build-a-game-with-decision-models - /examples/laptop-examples/flight-search-assistant - /examples/laptop-examples/invoice-extractor-tool-with-liquid-nanos - /examples/laptop-examples/lfm2-english-to-korean From b2da1597da704fb62d499cd0f5a5b1c5663a5f5d Mon Sep 17 00:00:00 2001 From: Leonie Monigatti Date: Tue, 29 Sep 2026 20:09:22 +0200 Subject: [PATCH 5/5] add review patches --- .../build-a-game-with-decision-models.mdx | 14 ++++++++++---- lfm/models/decision-models.mdx | 12 ++++++------ 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/examples/laptop-examples/build-a-game-with-decision-models.mdx b/examples/laptop-examples/build-a-game-with-decision-models.mdx index cc05c8c..f6cb585 100644 --- a/examples/laptop-examples/build-a-game-with-decision-models.mdx +++ b/examples/laptop-examples/build-a-game-with-decision-models.mdx @@ -31,6 +31,12 @@ Create a `.env` file from the template: cp .env.example .env ``` +Obtain a LIQUID_API_KEY: + +1. Go to [console.liquid.ai](https://console.liquid.ai). If you don't have an account yet, register and join an organization. +2. Navigate to **Dashboard > API Keys**. +3. Create a new key and copy it. Keys are prefixed with `liquid_`. + Add your Liquid API key: ```sh @@ -38,7 +44,7 @@ LIQUID_API_KEY=your-liquid-api-key ``` - Jev vs d1 mode is optional. To enable it, add an OpenRouter key as `JEV_API_KEY`. + Jev vs d1 mode is optional. To enable it, add an OpenRouter key as `OPENROUTER_API_KEY`. ### 3. Install dependencies and start the demo @@ -183,9 +189,9 @@ By default, d1 runs through Liquid's API and Jev runs through OpenRouter: | `LIQUID_API_KEY` | | API key for d1. Required. | | `LIQUID_MODEL_NAME` | `d1:free` | d1 model name. | | `LIQUID_BASE_URL` | `https://api.liquid.ai` | API host for d1. | -| `JEV_API_KEY` | | OpenRouter API key. Required for Jev vs d1 mode. | -| `JEV_MODEL_NAME` | `typesafe/jev-1.13` | Jev model name. | -| `JEV_BASE_URL` | `https://openrouter.ai` | API host for Jev. | +| `OPENROUTER_API_KEY` | | OpenRouter API key. Required for Jev vs d1 mode. | +| `OPENROUTER_MODEL_NAME` | `typesafe/jev-1.13` | Jev model name. | +| `OPENROUTER_BASE_URL` | `https://openrouter.ai` | API host for Jev. | To run d1 through OpenRouter instead of Liquid's API: diff --git a/lfm/models/decision-models.mdx b/lfm/models/decision-models.mdx index 5ebe258..c59cad3 100644 --- a/lfm/models/decision-models.mdx +++ b/lfm/models/decision-models.mdx @@ -30,7 +30,7 @@ Pick the type that matches the shape of the answer your code needs. ## Setup -1. Go to [console.liquid.ai](https://console.liquid.ai). +1. Go to [console.liquid.ai](https://console.liquid.ai). If you don't have an account yet, register and join an organization. 2. Navigate to **Dashboard > API Keys**. 3. Create a new key and copy it. Keys are prefixed with `liquid_`. @@ -51,7 +51,7 @@ A single API call contains three things: ```bash - curl -s https://api.liquid.ai/v1/systemone \ + curl -s https://api.liquid.ai/decisions/v1/systemone \ -H "Authorization: Bearer $LIQUID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ @@ -155,7 +155,7 @@ A Noul question returns a single probability between 0 and 1. Your code receives ```bash - curl -s https://api.liquid.ai/v1/systemone \ + curl -s https://api.liquid.ai/decisions/v1/systemone \ -H "Authorization: Bearer $LIQUID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ @@ -232,7 +232,7 @@ A Choice question returns the selected option, a probability distribution over a ```bash - curl -s https://api.liquid.ai/v1/systemone \ + curl -s https://api.liquid.ai/decisions/v1/systemone \ -H "Authorization: Bearer $LIQUID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ @@ -344,7 +344,7 @@ A Score question returns a continuous value across an ordered rubric you define, ```bash - curl -s https://api.liquid.ai/v1/systemone \ + curl -s https://api.liquid.ai/decisions/v1/systemone \ -H "Authorization: Bearer $LIQUID_API_KEY" \ -H "Content-Type: application/json" \ -d '{ @@ -452,7 +452,7 @@ You can ask multiple questions of different types in the same call. The model ev ```bash - curl -s https://api.liquid.ai/v1/systemone \ + curl -s https://api.liquid.ai/decisions/v1/systemone \ -H "Authorization: Bearer $LIQUID_API_KEY" \ -H "Content-Type: application/json" \ -d '{