Running Open-source Models projects locally

Use this page to run either extracted Open-source Models project. One loads a Transformers.js model in your browser; the other runs an Express server that calls Ollama on your computer. Identify which project you have, then follow only that setup.

What you need first

Install a supported LTS version of Node.js. Node 24 is recommended and includes npm. If Node and npm are new to you, Running the code locally walks through installing and checking both.

The Transformers.js project needs a current browser, an internet connection for its first library and model download, and enough browser storage and memory for the model. It does not need an API key.

The Ollama project also needs Ollama, enough disk space and memory for the mistral model, and its local Ollama service running. It does not need a provider account or API key.

JunoWhat you need first Install Node.js LTS first, then choose one of the two setups: a current browser and an internet connection for Transformers.js, or the Ollama app with its service left running for the Ollama lesson. Neither setup needs an API key. The first time I set one up I doubted that, and it was correct: there is no key to create here.

JunoWhat you need first Both projects run the model on your own hardware, so there is no provider key to configure. Transformers.js downloads the model into the browser tab; the Ollama lesson needs the separate Ollama service installed and running before its server can reach it. Install Node LTS either way, because npm drives both setups.

JunoWhat you need first Two ways to compute locally, two resource budgets. The browser setup depends on remote library and model files plus browser cache, storage, and memory; the Ollama setup needs the native service, downloaded model weights, and enough free memory and processor capacity for inference. Check your hardware before the lesson, a habit I started after loading a model onto a laptop with too little memory to hold it.

Identify the project you extracted

Open a terminal in the extracted folder containing package.json:

$ cd path-to-your-downloaded-project

If the folder name does not tell you which lesson you extracted, open index.js. An express import means the Ollama lesson, which needs the package repair below; a Transformers.js import means the browser app, which runs without any changes.

JunoIdentify the project you extracted Open your terminal in the folder that contains package.json, the way you would stand in the kitchen before you start cooking. A browser-model project follows the Transformers.js section; the Express server follows the Ollama section. I once ran an entire setup from one directory above the project folder, so check where you are first.

JunoIdentify the project you extracted The two downloads look alike from the outside but run differently: the browser-model project starts with Vite, while the Ollama project is a Node server that also needs the separate Ollama service. Pick the section that matches yours and follow only that one, because the setup steps do not mix.

JunoIdentify the project you extracted Identify the project from evidence, not the folder name: open index.js. An express import means the Ollama lesson and the package repair below; a Transformers.js import means the Vite browser app runs without any changes. I skipped that check one time and spent the next hour applying Ollama fixes to a browser project.

Run the Transformers.js project

Use these instructions for AI Models In The Browser With Transformers.js. This project needs Node and npm for Vite.

Install and start it:

$ npm install
$ npm start

Open the Local URL Vite prints, usually http://localhost:5173/. The page first imports Transformers.js from jsDelivr and then downloads the Xenova/yolos-tiny object-detection model. Wait until its status changes from Loading model... to Ready before selecting Detect Objects.

The first load needs an internet connection and can take longer than an ordinary frontend page; later loads come from the browser cache. If the status never reaches Ready, open the DevTools Network tab: a blocked jsDelivr request points to a CDN or content-blocker problem, while a slowly growing model file means the weights download is still in progress. Stop Vite with Ctrl+C.

No provider credential is needed

The model executes in your browser rather than through a hosted inference API. There is no .env file or API key to configure for this lesson.

JunoRun the Transformers.js project Run npm install, then npm start, open the Local URL, and wait for the status to reach Ready before selecting anything. The first model download is slow one time only, and after that the browser keeps its own copy. I used to click early and assume I had broken something, so give it a moment.

JunoRun the Transformers.js project Three things load in order: Vite serves the page, jsDelivr supplies the library, and the model weights download into the browser to run there. That first load is limited by your download speed, so a slow status usually means a download still in progress rather than a bug. Wait for Ready, then detect.

JunoRun the Transformers.js project The first load is limited by your download speed; every load after that comes from the browser cache. When Ready never arrives, the DevTools Network tab shows you which request is at fault: a blocked jsDelivr request points to a CDN or content blocker, while a model file whose size grows very slowly points to a slow weights download. I check that tab before blaming the model, a lesson that once cost me an hour.

Repair and run the Ollama project

Use these instructions for Download and Run AI Models on Your Computer with Ollama. The exported ZIP contains the lesson's Node code, but its generated package.json still describes a Vite project. It cannot run locally without a small package repair.

After installing Ollama, make sure its local service is running. Download the model named by the lesson code:

$ ollama pull mistral
$ ollama ls

The second command should list mistral. Depending on your operating system, opening the Ollama application starts the service automatically. If it does not, run ollama serve in a separate terminal and leave it running.

In the extracted project, add "type": "module" as a top-level property of package.json, a sibling of "scripts":

{
  "type": "module",
  "scripts": {
    "start": "vite"
  }
}

Then change the start script from:

"start": "vite"

to:

"start": "node index.js"

Install the two dependencies imported by index.js:

$ npm install express ollama
$ npm start

The server prints:

Server is running on port 3000

Test the route without invoking a model:

http://localhost:3000/

It should ask you to supply a question parameter. Then try a real local model request:

http://localhost:3000/?question=Why%20is%20the%20sky%20blue%3F

The Express server waits while Ollama loads the model and generates its reply. The first response can be noticeably slower. Stop Express with Ctrl+C. Stop a separately launched ollama serve process with Ctrl+C when you no longer need it.

You need no provider API key or .env file for either project; the model weights and inference stay on the machine running Ollama. The course's hosted-model projects work differently: Running Agents locally shows the key and .env setup they need.

JunoRepair and run the Ollama project Download the mistral model, keep Ollama running, then fix package.json: add the module type and point the start script at node index.js. Install express and ollama, start the server, and ask it a question on port 3000. A slow first answer means the model is loading, not that anything broke, which I wish someone had told me the first time.

JunoRepair and run the Ollama project Two processes cooperate here: Ollama serves the model and Express exposes the lesson route. The ZIP contains package metadata written for a Vite project, so add the module type and change the start script to the Node entry point, then install the two imported packages. If a request hangs, check which of the two processes stopped.

JunoRepair and run the Ollama project The export describes the wrong kind of app, so the two package edits are required for the project to run rather than optional improvements: ESM module type plus a Node start script. Even after that repair, Express only answers if Ollama runs separately with mistral already downloaded; the server never starts the model service for you. Expect the first inference to be the slow one while the weights load.

Troubleshooting

The Transformers.js page stays on Loading model...: Check the browser console and network connection. Content blockers or a restricted network may block jsDelivr or the model download. Try a current browser with enough free storage and memory.

The Ollama project says Cannot find package 'express' or 'ollama': Run npm install express ollama in the folder containing package.json.

Node says Cannot use import statement outside a module: Add "type": "module" to package.json.

npm start launches Vite or complains about a missing index.html: Change the start script to node index.js. The Ollama lesson is a Node server, not a Vite page.

The route cannot connect to Ollama: Confirm the Ollama application or ollama serve is running, then use ollama ls to confirm the mistral model is installed.

Port 3000 is already in use: Stop the other process or change the port constant in index.js, restart Express, and open the matching URL.

JunoTroubleshooting Match the fix to the project: for Transformers.js look at the browser's network activity and Console, and for Ollama check the package repair, the installed model, the running service, and the port. Most errors here come from one missing step, not a broken computer. I say that as someone who once reinstalled Node because of a typo.

JunoTroubleshooting Work out which runtime failed before changing anything: Vite and browser assets belong to the Transformers.js project, while Node, Express, and the Ollama service belong to the other. Read the error to see which of those two sets it names, then run that project's checklist. A fix applied to the wrong project usually creates new errors.

JunoTroubleshooting For Transformers.js, the failure lives in downloads or browser memory. For Ollama, check the chain in order: Node accepts the module syntax, Express holds port 3000, the service is running, and mistral appears in ollama ls. A symptom that appears later is often the same earlier failure showing up in a different form.