Scripting Local Language Models with Ollama and the Vercel AI SDK

Processing Dynamic User Input in Local AI Scripts

Providing File System Context to Local AI Scripts with Globby and Zod Enums

Generating Text with a Local AI Model Based on File Content

Handling Invalid Commands and AI Errors in Local Scripts

Creating Dynamic, File-Based Commands for Local AI Scripts

Dynamically Inferring File Types from User Prompts in Local AI Scripts

genai

From the creators of Next.js, the AI SDK is a free open-source library that gives you the tools you need to build AI-powered products.

ai-sdk

### **Build Powerful, Local AI-Driven Command-Line Scripts**

Go beyond simple AI chats and unlock the true potential of local language models by learning to script them. This course will guide you step-by-step through the process of building a flexible and intelligent command-line tool that can understand natural language, interact with your file system, and automate complex tasks—all running entirely on your local machine.

Starting with a blank TypeScript file, you'll learn how to combine the power of **Ollama**, the **Vercel AI SDK**, and **Zod** to create a script that's not just functional, but smart. We'll begin by teaching the AI to parse a simple command from a sentence. From there, we'll progressively add layers of sophistication: processing dynamic user input, making the script aware of your project's files, and generating meaningful text-based output.

You'll also learn critical patterns for building robust and extensible tools. We'll cover how to handle invalid commands and unexpected AI responses gracefully. Then, you'll refactor the script to use a modular, file-based system for its commands, allowing you to easily add new functionality without touching the core logic. Finally, we'll add a layer of intelligence that allows your script to infer exactly what you mean, right down to the type of file you want it to process.

By the end of this course, you will have built a powerful, personalized AI assistant and gained the foundational skills to create sophisticated local automations for any task you can imagine.

**What You'll Learn:**

* How to script local language models using Ollama and the Vercel AI SDK.
* To parse and process dynamic user input from the command line.
* To use Zod schemas, including `enums`, to validate and structure AI model output.
* Techniques for providing file-system context to your scripts with `globby`.
* How to generate context-aware text based on file content.
* Robust error handling for invalid user commands and unexpected AI responses.
* To build a modular and extensible tool by defining commands in separate files.
* To intelligently infer user intent, such as dynamically determining file types from a prompt.

While command-line chats with local AI models are useful, the real power comes from scripting. This lesson walks you through the initial setup for creating powerful, local AI-driven scripts by combining Ollama, the Vercel AI SDK, and Zod.

You'll learn how to take a natural language command, like "Concatenate all of the markdown files in my Downloads folder into a single file," and use the `generateObject` function to intelligently extract structured, actionable data from it.

**Workflow demonstrated in this lesson:**

* Install and set up the `ollama-ai-provider`, `ai`, and `zod` packages.
* Create a local AI model instance using Ollama and the Gemma 3 model.
* Define a Zod schema to specify the exact data structure you want to extract (e.g., `{ command: string }`).
* Use `generateObject` to pass a natural language prompt to the local model and receive a structured JSON object that matches your schema.
* Run the script using `bun` to see the local model successfully infer the "concatenate" command from a full sentence.

This foundational lesson unlocks the ability to build sophisticated, automated workflows by translating human language into machine-readable commands, all running entirely on your local machine.

cursor

Hardcoded prompts are great for testing, but a truly useful script needs to respond to dynamic user input. This lesson shows you how to make your local AI script interactive by capturing command-line arguments.

You'll learn how to use Node.js's built-in `parseArgs` utility to take a user's natural language command directly from the terminal and pass it to your local language model for processing.

**Workflow demonstrated in this lesson:**

* Import the `parseArgs` function from the `node:util` module.
* Configure `parseArgs` to accept positional arguments from the command line.
* Replace the static, hardcoded prompt with the dynamic input provided by the user.
* Run the script with different sentences (e.g., `"Download a file"` or `"I want to download a file"`) to demonstrate that the AI can correctly infer the core command regardless of the phrasing.

By the end of this short lesson, your script will be able to accept and process commands directly from the user, making it a flexible and reusable command-line tool.

vercel

A command is useless without knowing what to act upon. This lesson elevates your local AI script by giving it context from your project's file system. You'll learn how to find all relevant files and empower the AI to intelligently select the correct one based on your prompt.

The core technique involves using the `globby` package to scan for files and then feeding that list into a Zod `enum`. This constrains the AI's choices to a valid set of files, allowing it to accurately determine which file you're referring to in a natural language command.

**Workflow demonstrated in this lesson:**

* Install and import the `globby` library to find files based on a pattern (e.g., all `.json` files).
* Add a `filePath` field to your Zod schema.
* Define the `filePath` as `z.enum(files)`, where `files` is the array of file paths returned by `globby`.
* Pass a natural language prompt like "Summarize our typescript config" to the script.
* Observe how the AI correctly identifies `tsconfig.json` from the list of available JSON files and returns it as structured data.

This lesson is a crucial step toward building powerful, context-aware tools that can intelligently interact with your project's files based on simple, human-readable commands.

Once your script can understand a user's command and identify a target file, the next step is to perform an action. This lesson shows you how to use the Vercel AI SDK's `generateText` function to process a file's content and produce a relevant, AI-generated response.

You'll learn how to read the content from the file path you've already identified, combine it with the inferred command into a new, more detailed prompt, and then pass it back to your local AI model to generate a final text output, such as a summary or a review.

**Workflow demonstrated in this lesson:**

* Import the `generateText` function from the `ai` SDK.
* Read the file content from the `filePath` returned by `generateObject`.
* Construct a new, structured prompt that includes the original command (e.g., "summarize") and the full content of the file.
* Pass this new prompt to the `generateText` function.
* Log the resulting AI-generated text to the console.
* Run the script with commands like "Summarize our TypeScript config" or "Review my package file" to see the full, context-aware output.

This lesson completes the core cycle of your AI script: understanding a command, reading the relevant context, and generating a useful, text-based result, all on your local machine.

AI models won't always give you the answer you expect; sometimes they'll return invalid data or "hallucinate" a response that doesn't fit your schema. This lesson teaches you how to make your local AI script more robust by implementing essential error handling for user commands.

You'll learn how to validate the AI's output against a predefined list of valid commands and gracefully catch errors when the model generates an unexpected response, ensuring your script fails predictably and provides helpful feedback to the user.

**Workflow demonstrated in this lesson:**

* Define a list of `validCommands` (e.g., `summarize`, `translate`, `review`) to constrain the AI's choices.
* Wrap the `generateObject` call in a `try...catch` block to handle cases where the AI's output doesn't match the Zod schema.
* Implement a type guard function (`isValidCommand`) to check if the command returned by the AI is in your list of valid commands.
* Provide clear error messages to the user, indicating what went wrong and what the valid commands are.
* Test the script with invalid commands (like "taco" or "delete") to confirm that the error handling works as expected.

By adding these checks, you make your script significantly more reliable and user-friendly, preventing it from crashing on bad input and guiding the user toward correct usage.

Hardcoding command logic and prompts directly into your script makes it rigid and difficult to extend. This lesson demonstrates a more flexible and powerful pattern: defining your script's commands as individual Markdown files in a dedicated directory.

This approach allows you to easily add, remove, or modify commands without touching the core script logic. You'll learn how to dynamically load these command files, present them as options to the AI, and inject the corresponding instructions into your prompt, creating a truly modular and extensible tool.

**Workflow demonstrated in this lesson:**

* Create a `commands` directory to house your command definitions (e.g., `summarize.md`, `translate.md`).
* In each file, write the specific prompt or instructions for that command.
* Use `globby` to discover all available command files at runtime.
* Create a `commandMap` that maps the filename (e.g., "summarize") to its file content.
* Update the Zod schema to use an `enum` of the dynamically discovered command names.
* Dynamically construct the final text generation prompt by injecting the instructions from the user-selected command file.
* Add a `profile.md` file to demonstrate how the script can act on user-created content with the new file-based commands.

By the end of this lesson, your script will be architected for easy expansion, allowing you to build a robust library of custom commands simply by adding new text files.

Hardcoding your script to search for only one type of file (like `.md`) is a major limitation. This lesson shows you how to make your script smarter by teaching it to infer the desired file type directly from the user's natural language prompt.

You'll implement a two-stage AI process. The first stage analyzes the user's request to determine the file extension they're interested in (e.g., `md`, `txt`). The second stage then uses that file type to dynamically search the file system, find the relevant files, and execute the command.

**Workflow demonstrated in this lesson:**

* Add a preliminary `generateObject` call to extract a `fileType` from the user's initial prompt.
* Define a list of supported `fileTypes` (e.g., `['md', 'txt']`) and use a detailed prompt to guide the AI, instructing it to choose from the list or use a default.
* Dynamically construct the `globby` pattern using the inferred `fileType` (e.g., `*.$[fileType]`).
* Implement error handling to inform the user if they request an unsupported file type or if no files of the specified type are found.
* Demonstrate how the script defaults to searching for Markdown files but can correctly search for other types when specified (e.g., "summarize my profile from my pdf").

This technique adds a significant layer of intelligence to your script, allowing it to adapt its behavior based on the user's intent and making it a far more flexible and intuitive command-line tool.

[00:00] Head over to olama.com. We're going to use Gemma 3 for our demo. So after you install olama, if you just grab this command and drop it in any terminal, it will download and install that model. Since I already had it installed, I can just type any message, like hello, hit enter, and have a chat with a local AI model at my terminal. Now while terminal chats are great, what's way more useful is scripting.

[00:23] So I'll clear this out, and we're going to install a couple of packages. We'll install the Ollama AI provider, we'll install AI, the Versel AI SDK, and we'll install Zod to help us define what the AI should do. So let this run and now with everything installed in my index file, I'll just keep this at the root of my project and close this out. I can import Olama, I can import AI, and I can import Zod. So from Ollama we'll need the Ollama function which we'll create our model with.

[00:55] We're going to use generate object from AI and just Z from Zod. And we'll combine these pieces together by creating a model where olama is going to wrap around gemma3 and we're just grabbing the latest tag and then we can use generate object and pass in the model meaning that this gemma model will be used when we generate an object, with a schema of zObject and then a prompt which we're going to hard code above. So our prompt for right now is just going to be concatenate all of the markdown files in my downloads folder into a single file. Since we're not using any variables yet I'll hit command period, replace with the string literal just to make that red squiggly go away, and then in our schema we're going to extract the command from the prompt. I'll just hit tab to autocomplete this entire thing, then all we have to do is let this run and get the object out.

[01:49] Then if we just console.log the object, we'll be able to run this script in our terminal. I'm gonna run this with bun. It's just the easiest way to run a TypeScript script. Hit enter, and you'll see that the resulting object is an object with command of concatenate. So we were able to locally infer that from this sentence that concatenate is the command of this prompt.



https://app.egghead.io/api/v1/lessons/scripting-local-language-models-with-ollama-and-the-vercel-ai-sdk~88mk5/transcript

[00:00] Now let's take user input by importing from nodeutil, parseArgs, and we can use parseArgs and pass in allowPositionals true, then grab the positionals. So now the prompt, instead of being hardcoded, can be positionals in the first position. So when I run this, if I type on index and then type a string like download a file, then this is the positional at index 0. I'll hit enter and you'll see the command is download. Now just to prove that this isn't just finding the first word in here, we can type index.

[00:36] I want to download a file. Hit enter and it still finds the word download.



https://app.egghead.io/api/v1/lessons/processing-dynamic-user-input-in-local-ai-scripts~pmjzp/transcript

[00:00] Now we're going to install a library called globby. There are plenty of libraries for globbing files. This is just the one I'm most familiar with. So import globby and grab the globby function. So then from my current directory I'm going to tell globby to find all JSON files.

[00:17] And if I just run this right now and allow this to exit, so I'll say bun index, you'll see this found all JSON files all the way from package JSON all the way into all the node modules. And if we pass in some options we'll pass in git ignore true, and this time once we run it you'll see we get our two JSON files here. And these are the full paths to the files right now they're just at the project root. So I'll remove this so this can continue And then I'm going to add to our schema a file path and we'll say this is a string and I'll just tab autocomplete a file to process. And we're going to add a feature here right after Z called enum and pass in the array of files.

[01:00] And since these types don't match because enum is expecting an array with at least one string, I'm going to go ahead and copy and paste in a type guard right after here where isNoneEmpty will check if this array has a length. Then it will be cast to this. If not, the process will exit and that will fix our little TypeScript issue. So now if I run this and say summarize our TypeScript config, hit enter, you'll see it logged out all of our files And the command is summarize and the file path is this tsconfig because it was able to select from each of these files based on the sentence.



https://app.egghead.io/api/v1/lessons/providing-file-system-context-to-local-ai-scripts-with-globby-and-zod-enums~3uff2/transcript

[00:00] So now we can grab generate text from the AI SDK and with our command we'll scroll down and we'll say await generate text. We'll pass in our model again and then our prompt we'll assign to a text prompt up here and while we're at it I'm going to rename this to object prompt and tab complete both of those just to avoid confusion and tab down here and assign this one to text prompt. So for our text prompt we're going to build out a command with object command and then the content and then close off the content and then we'll read in the content of the selected file. So off of file path I'm going to hit tab to automatically import read file. UTF-8 will convert it to text and then we can drop the content inside of our prompt.

[00:50] So with all of that in place we can grab the text off of the results and then log out our text. So if we run this again we'll type bun index and summarize our TypeScript config, hit enter, and then we get a full summary of everything within our TypeScript config. It explains it defines a set of compiler options for TypeScript. So let's try another prompt here with index review my package file, hit enter, and then it gives a basic review of everything defined in the package file.



https://app.egghead.io/api/v1/lessons/generating-text-with-a-local-ai-model-based-on-file-content~im73p/transcript

[00:00] Now we're definitely going to want some examples that we can provide in here. So we'll toss in example, and that means we're going to have to limit the types of commands that can be passed in. So if we write a list of valid commands, for now, we'll have summarize, translate, and review, and we'll toss these into an enum. And to fix the type error this time, we'll just say as const, meaning that valid commands will always have this length, so it meets this criteria, and we can remove this. Now you might think that this would prevent generate object from accepting bad commands, but if you look at the result, if we log out the object at exit and I just type bun index taco, you'll see that it still tries to aggressively pick something, essentially hallucinating an answer, because it's trying its best based on the word taco.

[00:52] So when using LLMs, if you have a limited amount of options like valid commands, sometimes you have to take this out from here. We'll make this just a string again so that I'm going to paste in another type guard for isValidCommand and if this isn't a valid command we'll go ahead and exit. So now if we run this you might expect if we pass in taco that it would hit that conditional but we're actually going to get an invalid response error here, meaning that the response from our model did not match the schema of our command and our file path. So now we can come up here, we can catch this error, and then customize it to something like model generated an invalid response for object prompt. So we can run this again, bun index taco, and you'll see model generated invalid response.

[01:41] We'll run this again with delete the package, hit enter, And now we run into our invalid command. To make that message a bit stronger, let's say valid commands are, and then join those together. So run this again, invalid command, valid commands are summarize, translate, and review.



https://app.egghead.io/api/v1/lessons/handling-invalid-commands-and-ai-errors-in-local-scripts~pa4jd/transcript

[00:00] To make our commands more flexible and more powerful let's take out summarize and translate from here. And I'm going to create a new file in a commands directory called summarize.md. And we'll just put in please summarize the following content to a single sentence. Then we can also create a translate command. We'll call it translate.

[00:21] Please translate the following content into French. And then back in our index file we can load in our commands directory, and since we're already using globby we'll just go ahead and use that. I'm going to rename commands to command file paths since this is an array of the relative path to the files. Then we'll create a command map where we can just map the command name to the file path. And I love writing comments like this because code suggestions can usually infer what you want to do next.

[00:51] So I'll hit tab. I actually don't necessarily like this way of grabbing the command name from a path since there are path tools where if we import path we can parse this and just get the .name and .name returns the file name without the extension, which is exactly what we need. So then down in our command string, tab is suggesting an enum. We still don't want to do an enum, but we do want to do this command map keys and then join them with a comma. So it'll just look like summarize comma translate.

[01:21] And then based on the selected command, we're gonna go ahead and drop in instructions and let the command map get the instructions based on the command that was inferred from the AI. So now in my terminal, if I run bun index, create a summary of my package file, then I'll let this run. It was able to find the package.json. It was able to infer that create a summary meant to summarize, which then pulled in my summary instructions and injected them into my text prompt. So the final action was to generate this text.

[01:55] So let's also try translate while we're here. Please translate my TypeScript file. We'll just see what happens when it tries to translate a TS config to French. So if we expand this it looks like it just gave up on the task because it was JSON and no translation was needed. Let's add in some more demo files based on our blobby pattern here.

[02:13] So instead of JSON files let's add some just markdown files in the root of the project and we can create another markdown file in the workspace root. We'll call this my profile. My name is John Lindquist and I'm a software developer. So we'll drop down here, find index, Please translate my profile, and then it gives me my profile in French.



https://app.egghead.io/api/v1/lessons/creating-dynamic-file-based-commands-for-local-ai-scripts~5dpa2/transcript

[00:00] So let's refactor the file type out of here. We're going to move all of this beneath the object prompt so that we can pull the file type out of there. Meaning we're going to use generate object to pull out the file type. And this will look something just like this using the same model. And this already added in a default.

[00:21] We're going to do just MD and actually make a list of file types. This looks fine. Let's just do md and text so that in our enums we can have file types here and that our default can be file types, the first one in the list. And I'm actually going to cast this as const so that it matches the type here. Otherwise this expects that the first value in this array is always available so saying as const will force that to be true.

[00:53] And then I'm going to rename this to file type object just so that once we get the file type as suggested here I'll hit tab and now we'll have asterisk and then our file type. And this is still working in the current directory. And kind of while we're here, speaking of enums, so this is restricted to markdown and txt. I'm going to come down to our commands and use an enum here as well so that we are forced to only use the available commands. And we can remove this and use string literals to get rid of the red squigglies.

[01:25] And I'm going to pull this out and give it a name of const valid commands and then just drop that in there. We can't use as const this time because it's possible that our command map doesn't have a key. So now our keys of summarize and translate are in there. And because we're using the default up here, and the default is MD, If I invoke this, we'll clear out the previous run, say bun index, and then just run a please summarize my profile. Once I hit enter this will error out because I totally forgot to pass in my object prompt.

[02:02] And then just run this again. And now this error is out. We are back into prompt engineering land to tell this prompt to extract a file type. So I'm going to wrap this prompt in something like this, where it's essentially saying determine the most relevant file type in the description. I'm going to also add in that only these file types are allowed.

[02:24] So now when you run this it's going to default to Markdown and use Markdown as the file type. Let's actually add to our logs the file type object just so we can see this again. And you'll see it found a file type of MD based on the default and based on the fact that we used enum. Now the enum is definitely forcing this to find a file type. So if we change this back to just a string and then run this, this will default to markdown.

[02:56] But this allows us to pass in like please summarize my profile from my PDF, hit enter, and the file type it found was PDF and no files are found. Again this enum, if we use it here, is going to force, even if we say PDF in here, it's going to force it into either Markdown or TXT. So you have to determine the behavior you want. Whether you want it to always give you one of these, whether you want it to fall back if this is just a string and the file type isn't found, and it even looks like an optional snuck in through autocomplete where I can attempt to say if this is a string. So we remove the file types, remove this language to try not to use the default, then run it again without a file type.

[03:40] In this scenario it still fell back to markdown, but we can remove default here, run it again, and now it's finding profile. And this is where I would say my available file types are our current file types in the description itself, and this time it shouldn't find profile. And it still found markdown. I'm going to say please return an empty string. And hopefully this combination of string, not enums, passing the file types into the description with optional on asking it to please return an empty string, hopefully this time we'll finally get an empty object with no files found.

[04:18] So as you can see it is quite the juggling act based on the specific behavior that you want. For this tool I'm just going to land on this for now so that if a user requests in here a PDF file we can tell them if there's not a file type I can say no file type found, only one of the following file types is allowed. So we give the user good messaging with MD and text. So now I can say profile markdown, hit enter, it finds the profile markdown file and summarizes it.



https://app.egghead.io/api/v1/lessons/dynamically-inferring-file-types-from-user-prompts-in-local-ai-scripts~wljfl/transcript

Course Content