The format breaks.
Of course! The classification result is as follows.
{"team": "shipping}
It cannot be read by the program because a greeting is added or quotation marks are missing.
Deterministic AI · Local Model · Full-Stack Design
The AI decision engine running on my computer
A Full-Stack Service Built with Open-Jev
Run a deterministic AI that answers with probabilities instead of text directly on your Mac, and build end-to-end a service that uses those probabilities to classify customer inquiries and moderate posts with FastAPI, Next.js, and SQLite.
- 12 sections · 32 lessons
- Approximately 5 hours
- Introductory to Beginner
- Complete 2 real-world services
고객 문의 · state
I haven’t been able to track my delivery for a week. When on earth is it going to arrive? I’m really angry.
모델이 준 것 · 선택지마다 확률
teamchoiceconfidence 71.7%angrynoul
애플리케이션이 정한 것 · 판정
Assigned to the shipping team
Assigning this to the shipping team with 72% confidence.
Our code's rule: if the confidence level is 50% or higher, assign it to the appropriate team; otherwise, pass it to a human.
Why deterministic AI?
What happens when you have an LLM handle classification
"Classify this inquiry as one of billing, shipping, or technical, and respond only in JSON." Most of the time, it works well. However, when operating it as a service, responses like this inevitably get mixed in.
It invents choices that don't exist.
{"team": "refund"}
It was asked to choose one of the three, but it made up a fourth answer.
You don't know how certain it is
{"team": "billing"}
We cannot tell whether it is a certain answer or just a rough guess.
The above answer is an example for explanation.
Deterministic AI does not write text. It simply assigns a probability to each option we provide and returns the results, so there is no risk of the format breaking or the model making up an answer that does not exist, and its level of confidence is shown numerically. Jev, released in September 2026, attracted attention with this approach, and in this course, you will practice with Open-Jev, an independent open-source implementation inspired by Jev.
One sentence repeated throughout the course
The model provides the probabilities; our code makes the decisions.
The model only provides probabilities,
and the application decides what to do.
Automatic Classification of Customer Inquiries
Determine it by looking at the confidence level for the question’s assigned team.
- Confidence of 50% or higherAssign to the responsible team
- Below 50% confidenceHuman classification
Content review
Determined based on the probability of “yes” for profanity, spam, and personal information.
- 0.8 or higherBlock
- 0.5 or higherHuman review
- Other Allowed
Preview of the completed project
Once you complete the course, this service will run on your computer.
This is the actual execution result shown in the lecture video. The model, backend, and interface all run on my computer.
고객 문의
I haven’t been able to track my delivery for a week. When on earth is it coming? I’m really angry.
모델의 판단 근거
teamchoice · Assigned teamConfidence 71.7%urgencyscore · urgencyconfidence 23.9%Expected value 1.15 / 3
angrynoul · Customer sentiment
최종 판정 · ROUTE
Assign to the Delivery Team
Assigning it to the delivery team with 72% confidence.
If the confidence in the assigned team is 50% or higher, it is assigned; otherwise, a person classifies it.
This is the actual execution result shown in the lecture video (0-1) · Open-Jev 2B
게시글
My number is 010-1234-5678. Please contact me.
모델의 판단 근거 · 항목별 '예'일 확률
abusenoul · Abusive language / derogatory remarksspamnoul · Advertising / Spamprivacynoul · Personal Information
최종 판정 · REVIEW
Needs review
Human review is required: 80% exposure of personal information
If the probability of 'Yes' is 0.8 or higher, it is blocked; if it is 0.5 or higher, it is reviewed by a person.
These are the actual execution results shown in the lecture video (0–1) · Open-Jev 2B
- PlaygroundCreate questions and choices yourself and view the probabilities
- Preset managementSave and edit question sets and decision criteria
- Decision historyRecord every decision in SQLite and search · view statistics
Architecture at a Glance
We build everything ourselves, from the browser to the model.
브라우저
View the results as probability bars and decisions.
Next.js 화면:3000
API layer, shared hooks, and components
FastAPI 백엔드:8000
coredecisionpresethistory
Open-Jev 모델 서버:8791
Qwen3.5-2B + LoRA, Mac GPU(MPS)
SQLite · Decision record storage
Beyond working code, structured code
Apply design patterns to real-world problems.
It is a modular monolith: deployed as a single unit, but with the code divided into modules by business function. Each module is split into Controller, Service, and Mapper layers, and architecture tests automatically enforce these rules.
| Pattern | Where is it used? | What improves? |
|---|---|---|
| MVC | FastAPI router · domain · Next.js screen | Separate the recipient, processor, and presenter. |
| Strategy + Factory | Mock and real model clientsSection 7 | Swap out the model with a single line of configuration. |
| Strategy + Registry | Decision policies by preset Section 8 | For a new policy, just create one class and register it. |
| Facade | DecisionFacade.decide()Section 8 | Other modules only need to know a single entry point. |
| Observer | Event Bus and Logging Module Section 9 | Even if the logging module is removed, the decision functionality continues to work as before. |
| Data Mapper · DTO | SQL results, domain, and API input/outputSections 6 · 7 | The SQL is visible, and invalid requests are blocked in advance. |
You can learn things like this.
What You’ll Be Able to Do After Completing the Course
- You can explain the difference between generative AI and deterministic AI and choose problems suited to deterministic AI.
- You can run the Open-Jev 2B model directly on your Mac's GPU and call it via HTTP.
- You can design a FastAPI backend using a modular monolith and layered architecture.
- You can work with SQLite using a MyBatis-style Mapper that writes SQL directly.
- You can apply the Strategy, Factory, Facade, and Observer patterns to real-world problems.
- You can build a screen that displays decision results with Next.js.
- You can complete two practical services that turn model probabilities into business rules.
Curriculum
Experience → Environment → Design → Backend → Frontend → Practice
12 sections, 32 lessons. First, experience the completed projects and decision-making AI, then finalize the design and build up the code layer by layer.
ExperienceSections 0–1
Section 0 · Orientation What you will build and how you will learn
- 0-1Course Introduction and Preview of the Finished Project
- 0-2How the Course Works and What You Need to Prepare
- 0-3What is Jev: The decision-based AI making headlines these days
Section 1 · Understanding Jev and Open-Jev Experience AI that does not generate
- 1-1Generative AI and Deterministic AI
- 1-2Three question types: choice, score, noul
- 1-3Experience it firsthand in the playground
EnvironmentSections 2–3
Section 2 · Preparing the development environment First run in Mock mode
- 2-1Install Python, uv, Node.js, and pnpm
- 2-2 Get the project and run it in Mock mode
Section 3 · Launching a Local Model Server Open-Jev 2B on a Mac GPU
- 3-1 Downloading the model: setup.sh and Hugging Face
- 3-2Run and Call the Model Server with MPS
Design Section 4
Section 4 · Design First: An Overview of the Architecture Structure Before Code
- 4-1Layered Architecture and MVC
- 4-2Modular Monolith: Why Divide Modules
- 4-3Enforcing Rules with Tests: Architecture Testing
BackendSections 5–9
Section 5 · The core layer: The foundation of every module
- 5-1Configuration and Application Factory
- 5-2Transactions, Exceptions, and Event Bus
Section 6 · SQL Mapper and SQLite
- 6-1Why We Write SQL Directly and the MyBatis Style
- 6-2Creating a SqlMapper Base Class
- 6-3Writing the Schema, Seed, and Mapper
Section 7 · decision module: The module that calls the model
- 7-1Validating Requests with DTOs (Pydantic)
- 7-2Strategy and Factory: Switching Between Mock and Real Models
- 7-3Complete the Service and Controller
Section 8 · preset module: Question Bundles and Policies
- 8-1Create Preset CRUD
- 8-2Connecting Modules with a Facade
- 8-3Turning Probability into Action: The Policy Pattern
Section 9 · history Module: Recording History with Events
- 9-1 Observer: Saving Records as Events
- 9-2Dynamic Search, Pagination, and Statistics SQL
FrontendSection 10
Section 10 · Next.js Frontend
- 10-1Project Structure and API Layer
- 10-2useFetch, useAction Hooks and Shared Components
- 10-3 Playground and Activity Log Screen
Hands-on Section 11
Section 11 · Practical Examples and Wrap-Up
- 11-1Practical 1: Automated Customer Inquiry Classification
- 11-2Practical 2: Content Moderation and Question Language Experiment
- 11-3Testing, Limitations, and Next Steps
Recommended for those who
- For those who want to try out the currently popular decision-based AI themselves rather than just hearing about it in explanations
- Those who have only used AI via APIs and want to run it directly on their own computer.
- People learning for the first time how to write code not just to "run" but with "structure"
- Those who have heard a little about MyBatis or Spring and are curious about Python backends
Prerequisites
- Python basics (variables, functions, classes, and module imports)
- Run basic commands such as cd and ls in the terminal
- Having seen HTML and JavaScript before (React experience is not required)
Practice Environment
You can do the exercises even if you don't have a Mac.
Both environments produce the same response format, so you can follow the backend and frontend exercises in exactly the same way.
Actual model
Apple Silicon Mac (M1 or later) · 16GB or more of memory · 10GB of free disk space
./dev.sh --model
Run Open-Jev 2B directly on your Mac’s GPU. The model downloads approximately 5GB the first time.
Mock Mode
Windows · Linux · Intel Mac
./dev.sh
All coding exercises use a fake model that responds in the same format as the real model. For Windows, we provide a PDF with instructions for setting up WSL.
Common tools: Python 3.12 or later, uv, Node.js 20 or later, pnpm, and VS Code or Cursor
Things to know before taking the course
- Open-Jev is not JevJev is a model from TypeSafe AI. Its weights are not publicly available, so it can only be used through the company-operated API. Open-Jev is an independent open-source implementation created by developer Zefan Cai. While its request structure is similar, its quality and speed are different. This course is not an official course from TypeSafe AI.
- Actual model execution is based on Apple Silicon MacsOn other environments, you will practice in Mock mode and watch videos for the parts that specifically require the actual model (Section 3 and parts of Section 11). The videos were recorded on macOS.
- 2B is a small modelIt is weaker on Korean questions than on English questions. In Section 11, we will experiment to identify this issue and work through how to address it together.
Frequently Asked Questions
Frequently Asked Questions Before Taking the Course
- Do I need an API key or usage fees?
- No. Since you run the Open-Jev model directly on your own computer, there’s no API key or pay-as-you-go fee.
- When listening in Mock mode, is anything omitted?
- All the coding exercises are the same. The response format is identical to that of the actual model; only the probability values are mock values generated using simple rules. For situations that require the actual model, we check them in the videos.
- Does experience with Spring or MyBatis help?
- Yes. It explains mappers that separate SQL into files, transactions, and layered architecture by relating them to concepts from MyBatis and Spring.
- Can the code created in the course be used with other models?
- The part that calls the model is separated using the Strategy pattern, so even if the model changes, you can keep the rest of the design and code as-is by only creating a new implementation for that part.
Technology Stack and Course Materials
Technologies used and materials received
- AI model
- Open-Jev 2B (Qwen3.5-2B + LoRA adapter and decision head), PyTorch MPS
- Backend
- Python 3.12, FastAPI, Pydantic v2, pydantic-settings, httpx
- Data
- SQLite, SQLAlchemy Core (a MyBatis-style mapper that writes SQL directly)
- Frontend
- Next.js 16 (App Router), React 19, TypeScript, Tailwind CSS 4
- Tools
- uv, pnpm, pytest, Swagger UI
Practice codeComplete project (backend, frontend, model-server)
Windows User Guide PDFFrom WSL installation to running Mock mode
![[4-Week Completion] Clean Architecture with AI for Senior Developer AdvancementCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/339355/cover/01k8ags08xj5tpgyrpv77hkj21?w=420)
![[Chuseok Special] An LLM Evaluation Harness Engineering Guide from a Silicon Valley DeveloperCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/343194/cover/01m34cgavc7y9g7nwxe347vnqt?w=420)
![[New 2025] Welcome, is this your first time using Fast API?Course Thumbnail](https://cdn.inflearn.com/public/courses/332854/cover/1cf331e7-8fd0-4120-8d96-9a416ec32904/332854.png?w=420)
![[Lv.5] SwiftUI with AI - Building AI Apps with Apple IntelligenceCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/341905/cover/01krprhwat5ngfskp43xy1nsj3?w=420)