Scenario Hands-On: Choose Your Track
💡 Goal: Pick one Jev hands-on track and finish it completely — Track A has 4 lessons taking about 65 minutes, Track B has 5 lessons taking about 82 minutes, and Track C has 6 lessons taking about 105 minutes. At the end you'll have not just notes, but a complete, runnable set of case code adapted from the official cookbook.
🎯 Stage Goals
- Be able to map your business problem to the right place: say which track it belongs to (content moderation and classification / LLM and Agent applications / documents and data) and which lesson to read first
- Finish at least one track completely and get a set of code you can adapt directly — for example, a live-stream danmaku (bullet-comment) filtering pipeline, or a RAG passage gatekeeping setup
- Know how to plan your order using the official difficulty labels: Beginner cases run if you just follow along; for Intermediate cases, cover the prerequisite lessons first before starting
⏳ Estimated Time
- 15 lessons total about 252 minutes (about 4 hours 12 minutes); to do everything, reserve a buffer of about 176–328 minutes
- You don't have to read everything — pick any one of the three tracks: Track A about 65 minutes (46–85), Track B about 82 minutes (57–107), Track C about 105 minutes (74–137)
- Each lesson stands on its own and can be read individually; within the same track, follow the numbered order — later lessons reuse earlier code
🚀 Before You Start
- Completed Daily Use: master the five ways of asking Jev questions — the official cookbook assumes you know the question types (primitives) and confidence: the scenario lessons assume you can pose Choice / Score / Noul / Box questions and read probability distributions
- Your environment still runs:
.venvhastypesafe-sdkinstalled, andTYPESAFE_API_KEYis in your environment variables (Installation and Your First Request) - (makes some lessons smoother) You've read Efficient Workflows: the prerequisites for B4 include Parallel Questions
- A cup of coffee ☕ — every lesson is a complete mini-project: real data + problem definition + runnable code
📚 Choose Your Track
The 15 lessons in this stage are all adapted from the official Cookbooks. The official definition of a cookbook is just three things: a real dataset, a set of TypeSafe questions that make judgments on it, and the code that turns those judgments into a usable system.
So no lesson here is a toy demo — the data is real (SEC annual reports, CLERC legal queries, GitHub terms of service, scanned vaccine documents), the code is complete, and the official docs say it plainly: take one and use it as the starting point for your own project.
How do you pick a track? The official Example use cases distills all usage patterns into ten "judgment shapes," and the 15 application scenarios in this stage cover the most common ones. Find your match:
| The judgment you need to make | Official term | Which track |
|---|---|---|
| What label to assign, which category it belongs to, whether to block it | Classification / Detection | Track A: Content Moderation and Classification |
| Whether an LLM's input and output are safe, whether a retrieved passage should enter the context, which tool to call | Verification / Retrieval / Routing | Track B: LLM and Agent Applications |
| Which fields to extract from text and images, which entries are most relevant, which items refer to the same thing | Structured Data Extraction / Search / Ranking | Track C: Documents and Data |
Each lesson's duration and difficulty are listed in the course table; the difficulty labels come straight from the official cookbook index: Beginner cases run if you just follow along; Intermediate cases have more complex structures — multiple requests, larger question groups, or cross-model coordination — and go more smoothly after you've covered the prerequisite lessons.
💡 Your industry isn't in the table?
The official use-case map also lists a batch of judgment ideas by industry: recruiting, lead qualification, customer support, insurance claims, financial crime, legal compliance, e-commerce products, community trust and safety, advertising, gaming, risk assessment, demand forecasting… Map your case to one of these, then assemble it with the question types and patterns taught in this section.
⚠️ Test Chinese-language content before going live
The official docs state: English is Jev's primary training language; other languages (including Chinese) work but with lower accuracy. For Chinese-language scenarios like danmaku filtering or document extraction, run a round of testing with your own real data before launch, focusing on confidence and probability distributions, then set your thresholds.
Track A: Content Moderation and Classification (A1–A4, about 65 minutes)
Who it's for: streamers and live-stream operators, trust-and-safety developers at community and content platforms, and anyone who needs to "label content and act on the labels."
You may be wrestling with problems like these:
- Abuse, spoilers, and spam ads flood the live chat all at once; manual moderation can't keep up, and keyword rules keep getting bypassed
- Products, emails, and documents need to be sorted into category trees dozens of levels deep; the shallow levels are easy, but deeper down nobody can say for sure
- The moderation system lets borderline content through one moment and deletes it the next; users send screenshots and ask: is the standard a dice roll?
| Lesson | What You'll Build | Duration | Difficulty |
|---|---|---|---|
| A1 Live Chat Filtering | One request per message with three questions, processed concurrently; abuse, spoilers, and spam judged together, with code rules deciding what viewers see | 15 minutes | Beginner |
| A2 Deep Hierarchical Classification | Parallel beam search walks down Choice probabilities to sort documents to the deepest levels of patent, retail, biomedical, and source-code categories | 20 minutes | Intermediate |
| A3 75-Category Industry Classification | SEC annual reports sorted into 75 industry groups; when the answer's own confidence is not enough, report the broader industry group above it | 15 minutes | Beginner |
| A4 Self-Consistency | Add an "uncertain" exit to a review system: if the top probability doesn't pass the threshold, escalate to a human. Official testing showed decision agreement rising from 90.8% to 99.2% | 15 minutes | Beginner |
Track B: LLM and Agent Applications (B1–B5, about 82 minutes)
Who it's for: developers building RAG, Agents, Chatbots, or any product where "the LLM does the work in the middle."
You may be wrestling with problems like these:
- LLM applications have no security screening at their entry and exit points: jailbreaks, prompt injection, and sensitive data flow straight in and out
- RAG stuffs every retrieved passage into the context regardless of relevance, so answer quality drifts along with it
- An Agent facing hundreds of skills doesn't know which one to call; turning natural language into function calls relies entirely on parsing the JSON the model emits
| Lesson | What You'll Build | Duration | Difficulty |
|---|---|---|---|
| B1 LLM Guardrails | Run a full security check on every message entering and leaving an LLM application in a single request, then allow, review, block, or route to support based on the thresholds you set | 20 minutes | Intermediate |
| B2 Citation Checking | A single Choice question determines whether the citation's context supports the claim, catching hallucinated citations | 12 minutes | Beginner |
| B3 RAG Passage Gatekeeping | Score each retrieved passage for relevance in a single request; your code decides which passages reach the answering model | 15 minutes | Intermediate |
| B4 Agent Decisions | Pick at most one of the 194 skills in the Hermes catalog (two requests: ranking + rechecking the top three); convert natural-language trade requests into typed function calls | 20 minutes | Intermediate |
| B5 Simple Memory System | Let Jev decide which requests and answers are worth remembering; a small function carries memory into subsequent calls | 15 minutes | Beginner |
Track C: Documents and Data (C1–C6, about 105 minutes)
Who it's for: developers building data pipelines, document processing, enterprise search, or OCR post-processing — any job that involves "rescuing structured data from messy-format input."
You may be wrestling with problems like these:
- Emails, phone numbers, amounts, and dates are scattered across messy text; regex pulls out a pile of candidates and you don't know which one is right
- Plain text that lost its formatting when copied and pasted needs to be restored to Markdown before it can go into a knowledge base
- BM25 search results aren't accurate enough; OCR-extracted values go straight into the database without anyone verifying them
| Lesson | What You'll Build | Duration | Difficulty |
|---|---|---|---|
| C1 Value Extraction | Dates are extracted by asking the model for components and parsed/validated in code; emails, phone numbers, and amounts are found as regex candidates, Jev picks the correct one, and the value is normalized | 15 minutes | Beginner |
| C2 Structure Recovery | Two requests restore format-stripped plain text to Markdown: one reassembles lines broken by hard line wraps, the other classifies each block | 15 minutes | Beginner |
| C3 Natural-Language Ordering | Coffee orders become a structured shopping cart: a Choice-narrowing loop finds each item, then a batch of requests per item fills in the fields | 15 minutes | Beginner |
| C4 Search and Matching | Re-ranking lifts CLERC legal-query top-1 hits from 5% to 18% and top-10 from 38% to 62%; line-by-line semantic search over 218 lines of the GitHub ToS; entity alignment of two beer catalogs with 450 pairs | 20 minutes | Beginner |
| C5 Cascaded Extraction | A cheap model extracts first, Jev verifies field by field, and only escalates to the reasoning model when verification raises an alarm | 20 minutes | Intermediate |
| C6 Images in Practice | On vaccine scans, Noul + Box locate the record and Choice reads the year (allowed to answer "can't read it clearly"); invoice OCR values are checked item by item, with low scores routed to humans; bird-feeder camera frames generate a species visit log | 20 minutes | Intermediate |
The official cookbook has 25 recipes — which ones does this cover?
The official TypeSafe cookbook index has 25 cases in total; this stage's 15 lessons cover 22 of them (lessons with multiple cases are covered together). Where the other three went:
- Parallel questions——already covered in 3.1 Parallel Questions and Speculative Fan-out: 13 questions in a single request, officially measured as 12.2× cheaper and 10.0× faster, with unchanged answers
- Intelliprompter (teleprompter for live speeches)——scores your notes point by point against uncovered items while you speak live, checking them off once they pass the threshold; not yet a standalone lesson, you can read the official original
- Autoresearch feature discovery (official difficulty: Advanced)——uses TypeSafe questions to turn free text into numerical features, then uses model error to improve a CatBoost regression; not yet a standalone lesson, you can read the official original
🎒 What You Will Gain
- Complete Chinese walkthroughs of 15 real-world Jev case studies: real data, problem definitions, runnable code, with duration and difficulty labeled for each lesson
- A "slot-into-place" breakdown method: when you receive a business problem, first state its judgment shape—classification, verification, or extraction—then choose a route, a task type, and a mode
- At least one template per route that you can directly adapt into your project: a danmaku (bullet-comment) filtering pipeline, RAG passage gating, a cascaded extraction pipeline
- Deployment habits for Chinese-language scenarios: first run a round of testing with real data, watch the confidence scores, then set thresholds—the official docs explicitly state that CJK accuracy is lower
Beyond the three routes there are two extension paths: if you want to systematically learn the methodology of "how to break business processes into atomic judgments," go back to the four architectural patterns in Efficient Workflows; if you want Jev to directly operate a browser and complete tasks for you, go to the Advanced Handbook to meet the Jev Ultrafast Browser Agent.