Welcome: what running a model on your laptop means and how this workshop works

We're glad you're here. This workshop is built for a true first time: it assumes nothing about AI models or how they work inside. By the end you'll have a language model running on your own laptop, a Python script that talks to it, and above all you'll understand what's happening and when it makes sense to do it this way.

When and where

Wednesday, October 14, 2026, from 5:30 p.m. to 7:00 p.m., Mexico City time.
Live, over video call. The link to join is on the workshop page, on the platform, while you're signed in.
It's recorded. The recording is sent by email to everyone who saved a spot.

First things first: where the AI you use today lives

Almost all the AI you use (a chat, an assistant, an agent) works the same way: your computer sends text over the internet to a company's servers, where a language model reads it and produces an answer, and the answer comes back. The model was never on your computer.

That has advantages: cloud models are huge, fast, and very good. And it has three costs:

You pay for every call (or you have a limit if it's free).
A third party sees your data: everything you send travels to their servers.
You depend on the internet and on the service being up.

Today we'll do the opposite: bring the model to your laptop. You download it once, load it into your computer's memory, and talk to it without anything leaving your machine.

The workshop analogy: the restaurant and your home kitchen

We'll use a single analogy from start to finish, and every term in the workshop has its place in it. If you ever get lost, come back to this page.

Using a model in the cloud is eating at a restaurant. The cook is excellent and fast, but they charge you for every dish and the restaurant sees everything you order.
Running a local model is cooking at home. You hire a cook who comes to your kitchen. They don't charge per dish and nobody sees your ingredients, but they have to fit in your kitchen, and a cook who fits in a small kitchen knows less than the restaurant's chef.

Workshop vocabulary

You don't need to memorize it now: each term is explained again when it shows up. These tables are the map to come back to.

The model and what happens inside your laptop

Term	What it is	In the analogy
(Language) model	The AI: a program that takes text in and produces text	The cook
Prompt	The text you send the model: your question or your instruction	The order you give the cook
Token	A piece of a word: the unit the model reads and writes in	A bite
Speed (tokens per second)	How many pieces of words the model writes per second	How fast the cook serves
Parameters (4B, 8B...)	The numbers the model learned during training. 4B is 4 billion	The cook's experience: more experience, more they know, but it takes up more space
Model file	The model packaged in a file of several GB that you download	The cook, with everything they know in their head
Quantization	Storing the parameters with less precision so the file weighs less	The pocket recipe book: the same recipes in small print
Disk	Where your computer keeps everything, even when it's not using it	The storeroom: that's where the cook waits when they're not working
RAM	Where your computer puts whatever it's using right now. Fast, and smaller than the disk	Your kitchen: the cook and their worktable have to fit
Loading a model	Copying it from the disk into RAM so it can answer	Bringing the cook from the storeroom to the kitchen
Context	All the text the model has in front of it for one order: the instructions, your prompt, and what it has already answered	The cook's worktable, inside your kitchen
Temperature	How much the model is allowed to vary when it picks each token	How much the cook improvises on the recipe

How you talk to the model

Term	What it is	In the analogy
LM Studio	The app that downloads the model, loads it, and serves it	The person who runs your kitchen: brings the cook from the storeroom and works the order window
Local server	The part of LM Studio that takes orders from other programs	Your kitchen's order window
`localhost` and port	`localhost` is your own computer; the port (`1234`) is the number where the server takes orders	Your house, and the window number
API	The agreed format for placing an order between programs	The order ticket: the slip of paper with the order
Script	A Python file (`.py`) with instructions that you run	Your list of orders, in writing
`openai` library and client	Ready-made code that knows how to write the order ticket and send it; the client is the piece that sends it	The waiter who carries the ticket to the window
Cloud provider	A company with models on its servers (OpenRouter, for example)	The restaurant
Key (API key)	Your secret identifier with a provider	Your customer number at the restaurant. At home you don't need one

When the model uses tools

Term	What it is	In the analogy
Function	A named block of code that does a task and returns a result	A task you know how to do in the kitchen
Tool	A function in your code that the model can ask to run	The cook asks you "bring me this from the pantry" and you bring it
Your data (`expenses.csv`)	The file with the sample expenses	The pantry

The most important idea in the vocabulary is in the API row: your kitchen's order window accepts the same order ticket as the restaurant. LM Studio imitates the format of cloud providers. That's why the same Python code works for both: you only change which address you send the order to.

The workshop map

   YOUR LAPTOP                                     THE CLOUD (optional)
+-----------------------------------------+      +-------------------------+
|                                         |      |                         |
|   Your Python script                    |      |   OpenRouter            |
|   (chat.py, measure.py, agent.py)       |      |   (the restaurant)      |
|        |                    |           |      |          |              |
|        | local order        | cloud     |      |          v              |
|        v                    | order ------------->  Big model            |
|   LM Studio                 |           |      |   (on their servers)    |
|   (your order window)       |           |      |                         |
|        |                    |           |      +-------------------------+
|        v                                |
|   Small model                           |
|   (in your laptop's RAM)                |
|                                         |
+-----------------------------------------+

   THE LIVE SESSION, IN 5 PARTS
+------------+   +------------+   +------------+   +------------+   +------------+
| 1. Choose  |-->| 2. Your    |-->| 3. Measure:|-->| 4. Give    |-->| 5. When to |
|  a model   |   |  code talks|   |  laptop    |   |  tools to  |   |  go local  |
|  that fits |   |  to your   |   |  versus    |   |  a small   |   |  and when  |
|  your RAM  |   |  laptop    |   |  the cloud |   |  model     |   |  not to    |
|            |   |            |   |            |   |            |   |            |
+------------+   +------------+   +------------+   +------------+   +------------+

Notice two things. First: the local arrow never leaves your laptop. With the local model, your data doesn't travel anywhere. Second: the cloud shows up as optional. We use it to compare in part 3, and for that you need a free OpenRouter key. If you don't have one, you can do the whole workshop with just your laptop.

What we'll do live

Hands on the keyboard:

Understand what a model file is, why it has to fit in your RAM, and choose one.
Turn on the LM Studio server and send it orders from a Python script.
Measure: the same orders against your laptop and against a model in the cloud. Time, speed, and correct answers.
Give the small model tools and see what it can handle and where it breaks.
Build your judgment: when it makes sense to go local and when it doesn't.

What you'll understand at the end (not just do)

By the end you'll be able to explain in your own words:

What a model file is and why a 4B one fits on a laptop and a huge one doesn't.
What LM Studio does and why your code can't tell the difference between your laptop and the cloud.
What a token is and how a model's speed is measured.
Where a small model makes the most mistakes and on which tasks it performs as well as a big one.
When to go local: privacy, cost, volume, and quality, weighed on a scale.

How the three modules fit together

+-------------------+      +-------------------+      +-------------------+
|  1. BEFORE        |      |  2. LIVE          |      |  3. AFTER         |
|                   |      |                   |      |                   |
|  You set up       | ---> |  You talk to your | ---> |  You keep testing |
|  Python, install  |      |  model, measure   |      |  and see where    |
|  LM Studio, and   |      |  it, and give it  |      |  to go next       |
|  get the model    |      |  tools            |      |                   |
+-------------------+      +-------------------+      +-------------------+

Stage	What's there	Why it goes there	When
Before	Set up Python and the folder, install LM Studio, and download the model	The download is several GB and depends on your internet: live, it holds everyone up	Before Wednesday
Live	A single lesson with the five parts, with code and commands ready to copy	That's where it helps to have support if something fails	During the session
After	Where to go next and how to get your certificate	What you don't repeat, you forget	In the following days

During the session, keep this page open in another tab. That way you copy the code instead of retyping it from the shared screen: an extra space in Python is the most common first-time mistake.

The only thing we ask beforehand

Do the next two lessons:

Prepare your laptop: check how much RAM you have, have Python, create the practice folder, and install the library the code uses.
Install LM Studio and download the model: the app, the model (about 2.5 GB) and, if you want to compare with the cloud, your free OpenRouter key.

If you arrive without doing them, that's fine: the first minutes of the session are for getting everyone's setup ready. But the model download depends on your internet and there's no way to speed it up, so if you can only do one thing, make it that.

Check your understanding

1. If the model runs on your laptop, why don't you need a key?

Because a key is how a provider knows whom to charge and whom to let in. With the local model there's no provider: the order goes from your script to LM Studio, inside your own computer. In the analogy, at home you don't need a customer number.

2. Why can the same Python code talk to your laptop and to the cloud?

Because LM Studio imitates the order format (the API) of cloud providers. The code fills out the same order ticket; the only thing that changes is the address it sends it to.

3. Why is it worth downloading the model before the session?

Because it's several GB and the speed depends on your internet. Installing LM Studio and setting up Python takes little time, but a slow download during the live session leaves you behind the group.

Summary

The AI you use today lives in the cloud: fast and good, but it charges per call, sees your data, and depends on the internet. Today we bring a small model to your laptop with LM Studio.
The workshop analogy: the cloud is a restaurant; local is a cook in your kitchen. It has to fit in your RAM, doesn't charge per dish, and nobody sees your ingredients.
LM Studio accepts the same order ticket as the cloud, so the same code works for both.
The workshop is Wednesday, October 14, from 5:30 p.m. to 7:00 p.m. Mexico City time, and it's recorded. Before the session: prepare your laptop and download the model. Next lesson.