Intro to Mistral AI
Intro to Mistral AI is Scrimba's free, 84-minute course on building with Mistral's models in JavaScript, taught mainly by Per Borgen with Gil Hernandez and Mistral's Sophia Yang. In 25 scrims you build a RAG bot over an employee handbook and a function-calling agent, and it earns its short runtime.
Reviewed inside the course with a Pro account, September 2026.
A free RAG bot and function-calling agent, if you accept the card
It fits developers who already know JavaScript and want a free, hands-on build of a RAG bot and a function-calling agent. The catch is setup, not price: Mistral requires a card on file before it issues an API key, and the RAG section needs a free Supabase project too. From here, Learn RAG covers retrieval in more depth, and Learn AI Agents takes the agent loop further.
Intro to Mistral AI
FreeTaught by Per Borgen (opens in a new tab)
Chat completions, a handbook RAG bot on Supabase, a function-calling agent loop, and local inference with Ollama, all in JavaScript and all free.
Start free on Scrimba (opens in a new tab)Is a 2024 recording still worth 84 minutes?
Yes, if you can write JavaScript and want to see RAG and function calling built end to end without paying for a course. For 84 minutes it covers a lot of ground, and it does so with the two projects that matter most on the AI track. One is a question-answering bot grounded in your own documents. The other is an agent that turns a sentence into a function call. Both are the same patterns you meet later in the paid AI courses, here in their simplest form.
Per sets the tone in the first minute: "My goal with this course is to teach you how to build magical stuff and more specifically, how to do that using JavaScript and Mistral AI." He keeps it that direct throughout. The challenges are short and the solutions follow right after, so nobody gets stuck for long.
Two caveats. First, it is a 2024 recording. Per warns in the models scrim that "these are the models it offers at the time of recording," and the model names (mistral-tiny, mistral-medium-latest) and the 0.1 client library show their age.
Second, you cannot follow along with a free Scrimba account alone. Mistral asks for a card before it issues an API key, and Supabase needs its own project and two SQL snippets pasted into its editor.
Last, the limits that sit inside the recording. The Supabase scrims show leftover OpenAI code in the editor, and because the user input is hard-coded you never wire the bot to a page. What it does well is the opposite of those gaps: the challenges sit exactly where you would otherwise copy code, and Per explains the trade-offs as he goes, from chunk size to model cost to the five-iteration cap. Verdict: take it for the patterns, then read Mistral's docs for current syntax.
Five groups, and the 41-minute RAG build in the middle
The course is one flat list of scrims, so the grouping below is mine, in order.
Course structure
25 scrims in 5 editorial groups, plus 3 generic Scrimba pages
- Welcome, Mistral intro, and La Plateforme signup
- Chat completions, streaming, JSON, and choosing a model
- RAG: embeddings, chunking, Supabase, retrieval, generation
- Function calling: from a tool schema to an agent loop
- Running Mistral locally with Ollama, and the recap
Group durations are added up from the timer in each scrim's header and come to 82 minutes; Scrimba's header rounds the course to 84. Scrimba's About text says 25 lessons. The table of contents has 28 entries because it ends with three pointer pages (Scrimba Docs, the affiliate program, and how to use your certificate); my counts above are the 25 real lessons.
A handbook Q&A bot, then a tool-calling agent, scrim by scrim
1. Welcome, Mistral intro, and La Plateforme signup (6 min, 3 scrims)
Per's welcome explains what Mistral is (a company that "twice managed to stun the AI community by launching small open source foundational models") and lays out the plan. In order: API basics, models, embeddings and vector databases, RAG, function calling, then local models. He also says the course "has been created in partnership with the company itself."
Sophia Yang's two minutes are a company brief: founded in 2023, Mistral 7B and Mixtral 8x7B as open weights under Apache 2.0, and Small, Medium, and Large as the paid tier.
The third scrim is the signup walkthrough. It is the one to watch before deciding whether to take the course, because it tells you the cost model plainly: "you only pay for what you use. So this is not an ongoing fixed subscription." You add a card, create a key, and store it as a Scrimba environment variable.
2. Chat completions, streaming, JSON, and choosing a model (13 min, 3 scrims)
Gil Hernandez teaches the first request. The code is small: import MistralClient, call client.chat with a model and a messages array, and read chatResponse.choices[0].message.content. He then adds temperature and a system message, and pauses twice for you to change the prompt yourself. Gil also uses this scrim to point out where you are. "You are experiencing a fully interactive scrim that you can pause at any moment and jump right into the code and make changes to it."
Per takes over for part two, which adds two settings you will use in every app. Streaming means switching chat to chatStream and reading chunks with a for await loop, and Per shows why by typing a question into a Hugging Face chat page and watching the reply build "token by token." JSON output takes two changes: set response_format to json_object and ask for JSON in the prompt.
The models scrim compares Mistral's open and paid models on the MMLU benchmark (a standard test for language models) and then on cost. The advice is to pick the cheapest model that does the job. As Per puts it, "you probably don't want to hire a person that is overeducated or overqualified for the job because most likely their hourly rate will be higher." The course uses mistral-large-latest for RAG and the agent because those need reasoning.
3. RAG: embeddings, chunking, Supabase, retrieval, generation (41 min, 11 scrims)
This is half the course, and it is built as one project: a bot that answers questions about a fictional company's employee handbook (handbook.txt, about 600 lines). Per explains RAG (retrieval-augmented generation, meaning you look up relevant text first and hand it to the model as context) with a story about asking Notion's AI where Scrimba keeps its Coursera export notes. Gil then gives a six-minute primer on embeddings, the numeric form of text that lets you compare meaning. "You can think of embeddings as the language that AI understands," he says, and walks through the classic king minus man plus woman example.
The build starts with chunking. Per imports RecursiveCharacterTextSplitter from LangChain, sets a chunk size of 250 characters with an overlap of 40, and inspects the 280 chunks that come out. His rule: "you want your chunks to be as small as possible, but you don't want to lose context." A short challenge has you refactor splitDocument to take a path and return an array of strings. Then you create one embedding with client.embeddings and the mistral-embed model, and the first real challenge asks you to embed every chunk and shape the result for the database.
Gil returns for two Supabase scrims: what a vector database is, and a click-by-click setup of a free Supabase project with the pgvector extension, ending with two more environment variables. One quirk: the editor in those two scrims still shows OpenAI code from another course (text-embedding-ada-002), which is unrelated to the walkthrough. Per then creates the handbook_docs table with a SQL snippet (the embedding column is a 1024-dimension vector, matching mistral-embed) and uploads everything with a single supabase.from('handbook_docs').insert(data).
Retrieval uses a similarity function that Supabase supplies. Per is upfront that the math behind it stays in the box: "Luckily, we don't have to worry about any of that as Supabase provides us with a SQL function that we simply can copy paste." You call it with supabase.rpc. The first result for "December 25th is on a Sunday, do I get an extra day off?" comes back as a cut-off sentence about Christmas Day. The final two-part challenge fixes that: return five matches instead of one, then write the prompt that combines context and question and send it to mistral-large-latest.
4. Function calling: from a tool schema to an agent loop (17 min, 6 scrims)
The agent is a customer-service bot over a tiny array of transactions in tools.js. Per's opening point is the one people miss: the model never runs your code. "This is all our AI sees. It never sees the content of this function. It just looks at the description and tries to decide whether or not it should be invoked."
The first scrim sends the prompt "Is the transaction T1001 paid?" with a tools array, and the reply has an empty content and a tool_calls entry naming getPaymentStatus.
The next five scrims each add one piece, and each is a challenge:
- Describe a second function,
getPaymentDate, in the tool schema and change the prompt to trigger it. - Read the function name out of the response and
JSON.parseits arguments. - Call it through an
availableFunctionsobject with bracket notation. - Push a message with
role: 'tool'back into the messages array. - Wrap it all in a
forloop that runs at most five times and returns whenfinish_reasonisstop.
Per explains the cap: a while loop or recursion "could be better solutions, but they also open up for the possibility of infinite loops." The last run prints "The transaction T1001 was paid on October 5, 2021."
5. Running Mistral locally with Ollama, and the recap (5 min, 2 scrims)
The Ollama scrim is the only one that leaves the browser. You install Ollama, run ollama run mistral (a 4.1 GB download), chat with it in the terminal, then download the scrim as a zip, npm install, and start a 24-line Express server that passes a URL query to ollama.chat.
Per's sell is simple: "aside for the cost of the hardware and the electricity, these tokens are completely free," and the data stays on your machine. The recap is 77 seconds. After it come the three generic Scrimba pages, which have no video.
Challenges you pause for, and what 84 minutes costs in practice
Scrims run one to six minutes; the longest is Gil's embeddings explainer. Per and Gil talk over a slide for the concept, then switch to the editor and run the code, and you see the API response arrive in the console. Challenges are written into the file as a comment block, the narration says "go ahead and solve this," and the recording sits quiet for a few seconds before the solution starts. You are meant to pause there, write your version, and press play.
Captions and a timestamped transcript are on every scrim. The API calls are real, so running Per's code yourself spends a fraction of a cent on your Mistral account each time. Nothing in the course marks your work automatically; the check is whether your console shows what Per's shows.
The clock is three to five hours, not 84 minutes. The account setup alone (Mistral card and key, Supabase project, pgvector extension, three environment variables, two SQL snippets) is 30 to 60 minutes the first time. The RAG and function-calling challenges are short, but each one is worth writing yourself before watching the solution. The Ollama scrim adds a 4 GB download and a local npm install, so do it when you have time and disk space.
Nothing inside the course is gated. All 25 teaching scrims play in full without Pro, there is no Solo Project, and the challenges are plain comment blocks in the editor rather than Scrimba's AI-checked challenge format. The only item I did not test is the Certificate of Completion entry at the very end of the list; Scrimba's pricing page lists certificates as a Pro feature. Pro is a separate decision: it buys the full AI Engineer Path (this free course is not part of it), the Pro-only Discord channels, unlimited challenges, and certificates. Current plans (opens in a new tab) show the cost for your region.
Putting a card on file with Mistral: who it suits
It fits developers with working JavaScript who want to build a RAG bot and a tool-calling agent once, from scratch, before touching a framework. It is also a good way to try Mistral if you have only used OpenAI: the client, the messages array, and the tool schema all rhyme with what you know.
Skip it, for now, if you have never written async/await or called an API; start with Learn JavaScript or Learn to Code with AI. Also skip it if you will not put a card on file with Mistral, because the course cannot be followed past scrim three without a key. And if you want current SDK syntax rather than the concepts, read Mistral's docs alongside it.
Ready before scrim three, and where to go next
JavaScript with async/await, arrays and map, and a basic sense of what an API request is. No AI experience is assumed; embeddings and RAG are explained from zero. You will need a Mistral La Plateforme account with a card, a free Supabase account (GitHub login works), and, for the last scrim, a computer that can run Ollama and hold a 4 GB model.
It works as a compact, free preview of two paid courses on the AI Engineer Path, which does not include it. Learn RAG covers the retrieval pipeline in more depth, and Learn AI Agents takes the function-calling loop further. Intro to AI Engineering is the fundamentals course that most people take first; this one works either as a taster before it or a second provider after it.
- Learn to Code with AI, if scrim three's card-and-key setup is where you stopped
- Intro to AI Engineering, the fundamentals most people take before this
- Learn RAG, the retrieval pipeline behind the 11-scrim RAG build, in more depth
- Learn AI Agents, the agent loop after the five-iteration cap
- Learn Supabase, for the Supabase and pgvector side of the handbook bot
- Build Serverless AI Agents with Langbase, another free AI build that skips the Supabase setup
Yes. All 25 teaching scrims play without a subscription and there is no Pro-only project inside it. You do need your own Mistral API key, which requires a card on file at La Plateforme, and a free Supabase project for the RAG section.
Per Borgen, Scrimba's co-founder, teaches the welcome, the models, the RAG build, function calling, and Ollama. Gil Hernandez teaches the first chat completion, embeddings, and the Supabase setup. Sophia Yang from Mistral records the two-minute company intro.
A question-answering bot over a fictional employee handbook (chunked with LangChain, embedded with mistral-embed, stored and searched in Supabase), and a small customer-service agent that decides when to call getPaymentStatus or getPaymentDate and loops until it has an answer. The last scrim runs Mistral locally behind a tiny Express server.
No. It assumes async/await, array methods, and comfort with API calls, and it does not reteach them. Start with Learn JavaScript or Learn to Code with AI first.
The concepts are, the code is not fully. It was recorded in early 2024 with version 0.1 of Mistral's JavaScript client and model names like mistral-tiny and mistral-medium-latest. Expect to translate the calls when you read Mistral's current docs.
About 84 minutes of video. Plan for three to five hours with account setup and the challenges, plus a 4 GB download if you do the Ollama scrim.
Yes. Every scrim has captions, a timestamped transcript under the settings menu, subtitles in ten languages, and adjustable speed.
No. Challenges are comment blocks in the editor and the recording pauses for you; you compare your console output with Per's. The AI-checked challenge format used in some Scrimba courses is not used here.