It is assumed that the following installed on your computer:
.NET 10.0
Docker Desktop
‘dotnet-ef’ tool
Setting up MySQL docker container
To download a suitable MySQL image from Docker Hub and run it on your local computer, type the following command from within a terminal window:
docker run -d --name mysqldb -p 3333:3306 -e MYSQL_ROOT_PASSWORD=secret mysql:8.4
This starts a container named mysqldb that listens on port 3333 on your local computer. The root password is secret.
To ensure that the MySQL container is running, type the following from within a terminal window:
docker ps
You will see a message like the following:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4baa0ba99088 mysql:8.4 "docker-entrypoint.s…" 2 hours ago Up 48 minutes 0.0.0.0:3333->3306/tcp, [::]:3333->3306/tcp mysqldb
Creating our ASP.NET MVC App
Create an ASP.NET MVC app named AspMySQL with SQLite support by running the following terminal window commands:
dotnet new mvc --auth individual -o AspMySQL
cd AspMySQL
To run the web application and see what it looks like, enter the following command:
dotnet watch
The app starts in your default browser and looks like this:
We need a suitable MySQL Entity Framework driver. One such driver is the official MySQL driver from Oracle. Run this pair of commands to replace the SQLite driver with the Oracle MySQL driver:
Let us configure our web application so that the connection string can be constructed from environment variables. Open the Program.cs file in your favourite editor and comment out (or delete) the following statements around lines 8-10:
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection") ?? throw new InvalidOperationException("Connection string 'DefaultConnection' not found.");
var host = builder.Configuration["DBHOST"] ?? "localhost";
var port = builder.Configuration["DBPORT"] ?? "3333";
var password = builder.Configuration["DBPASSWORD"] ?? "secret";
var db = builder.Configuration["DBNAME"] ?? "aspnetDB";
var user = builder.Configuration["DBUSER"] ?? "root";
string connectionString = $"Server={host};Port={port};Database={db};User={user};Password={password};";
builder.Services.AddDbContext<ApplicationDbContext>(options =>
options.UseMySQL(connectionString));
Five environment variables are used in the database connection string. These are: DBHOST, DBPORT , DBPASSWORD, DBNAME and DBUSER. If these environment variables are not found then they will take on default values: localhost, 3333, secret, aspnetDB and root respectively.
Go ahead and delete the connection string from appsettings.json as it is not needed anymore:
We can instruct our application to automatically process any outstanding Entity Framework migrations. This is done by adding the following statement to Program.cs right before the last app.Run() statement:
using (var scope = app.Services.CreateScope()) {
var services = scope.ServiceProvider;
var context = services.GetRequiredService<ApplicationDbContext>();
context.Database.Migrate();
}
Since SQLite is different from MySQL, we must delete all migrations and re-create them. Therefore, follow these steps:
delete the Data/Migrations folder.
delete file: app.db
create new migrations with this terminal window command:
dotnet ef migrations add M1 -o Data/Migrations
Test app
Now, let's test our web app and see whether it can talk to the containerized MySQL database server. Run the web application with the following terminal command:
dotnet watch
Click on the Register link on the top right side.
I entered an Email, Password and Confirm password, then clicked on the Register button. The website then displays the following page that requires that you confirm the email address:
Click on the “Click here to confirm your account” link. This leads you to a confirmation page:
Login with the email address and password that you registered with.
The message on the top right side confirms that the user was saved and that communication between the ASP.NET app and MySQL is working as expected.
Dockeri-zing app
We will generate the release version of the application by executing the following command from a terminal window in the root directory of the web app:
dotnet publish -o distrib
The above command instructs dotnet to produce the release version of the application in the distrib directory. When you inspect the distrib directory, you will see files like the following:
The highlighted file in the above image is the main DLL file that is the entry point into the web application. Let us run the DLL. To do this, change to the distrib directory, then run your main DLL file with:
cd distrib
dotnet AspMySQL.dll
This displays the familiar messages from the web server that the app is ready to be accessed from a browser.
Hit CTRL C to stop the web server.
We now have a good idea about the ASP.NET artifacts that need to be copied into a container.
In a terminal window, stop and remove the MySQL container with:
docker rm -f mysqldb
Return to the root directory of your project by typing the following in a terminal window:
cd ..
Docker image for web app
We need to create a docker image that will contain the .NET runtime. At the time of writing this article, the current version of .NET is 10.0.
We can exclude files from being copied into the container image. Add a file named .dockerignore in the root of the web application with this content:
Create a text file named Dockerfile and add to it the following content:
# Build stage
FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
# Copy project file and restore dependencies
COPY *.csproj .
RUN dotnet restore
# Copy source code
COPY . .
# Publish application
RUN dotnet publish -c Release -o /app/publish
# Runtime stage
FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS runtime
WORKDIR /app
COPY --from=build /app/publish .
ENV ASPNETCORE_URLS=http://+:80
EXPOSE 80
EXPOSE 443
# Run the application
ENTRYPOINT ["dotnet", "AspMySQL.dll"]
docker-compose.yml
We will next create a docker .yml file that orchestrates the entire system involving two containers: a MySQL database server and our web app. In the root folder of your application, create a text file named docker-compose.yml and add to it the following content:
To find out if this all works, go to a terminal window at the root directory of the application and run the following command:
docker-compose up -d --build
Point your browser to http://localhost:7777/ and you should see the main web page. Register a user, confirm the email, and login. It should all work as expected.
Cleanup
Run the following command to shutdown docker-compose and cleanup:
docker-compose down -v
Conclusion
We have seen how straight forward and easy it is to containerize an application and its database with docker-compose.
GitHub Copilot is transforming how developers work by turning AI from a simple code generator into a practical development partner. In this article, we explore how to use GitHub Copilot CLI and Visual Studio Code together with the Awesome Copilot ecosystem to build better .NET applications, customize AI behavior, and bring domain-specific guidance directly into the development workflow. From designing models and applying best practices to installing reusable agents, instructions, and skills, this walkthrough shows how to make Copilot feel deeply integrated with the way you code.
Using GitHub Copilot CLI
Create a sample .NET Console app
From within a termnal window in a working directory, type the following commands:
dotnet new console -o AwesomeAthlete
cd AwesomeAthlete
Let's get the plugin to do something useful. For example, ask the plugin to help you design some domain models by entering this command:
@csharp-dotnet-development help me design a class model for Athlete
Thereafter, you can enter this command to add the required C# classes:
add the class models to my app and put code in Program.cs that calls those classes and prints sample data to the console
Among others, the plugin contains a command named /csharp-dotnet-development:dotnet-best-practices. We can use this command by entering this instruction:
/csharp-dotnet-development:dotnet-best-practices
Since we have a very simple C# application, the only suggestion made by AI is to add documentation to the domain classes.
Exit GitHub Copilot CLI by typing in the /exit command.
/exit
Using Visual Studio Code (VS Code)
If you do not already have VS Code installed on your computer, you can get it from https://code.visualstudio.com/. Make sure to install the GitHub Copilot Chat extension before proceeding.
Open the AwesomeAthlete folder in VS Code. You ca do that by simply typing in the following from a termninal window from inside the AwesomeAthlete folder:
code .
Customize or Extend the Plugin
You can modify plugin components to suit your needs.
In plugin folder: ~/.copilot/installed-plugins/awesome-copilot/<plugin-name>/
Edit com.github.copilot/agents/*.md to change agent behavior
Edit skills/*/SKILL.md to add new skills
Restart VS Code to reload changes
Installing Awesome Copilot artifacts
Point your browser to Awesome GitHub Copilot. Let's try installing the Caveman Mode instruction that optimizes token interaction with AI. Click on Instructions.
Find the Caveman Mode instruction. Click on VS Code Install.
Click Yes on this dialog.
Choose to install the instructions in the current workspace under folder .github, instead of globally.
Accept the default name caveman-mode for the instructions.
The caveman-mode-instructions.md file is saved in your workspace under .github.
Here is an example on how to use this instruction. Enter the following into the VS Code chat window:
caveman-mode how many years did it take to build the empire state building in new york
The prompt is distilled to the essential keywords: Empire State Building construction duration. The response stays concise and focused, avoiding unnecessary wording. This keeps token usage low and saves you money.
Awesome Copilot
The Awesome Copilot (By Tim Heuer) extension for VS Code allows you to browse and download instructions, prompts, chat modes, and agents from the Awesome Copilot community.
Install the above extension into your VS Code. You wiill find Awesome Copilot in your explorer.
You will find folders Instructions, Agents, and Skills.
For example, expand the Agents node, then select CSharpExpert.agent.md.
If you decide to download this agent, click on the download tool beside it.
You can change the name of the agent .md file. Simply hit Enter to accept the default name.
The agent gets installed in your local workspace under .github/agents.
You can also modify any of these AI artifacts after you install them locally.
💡 TIP: There are new AI artifacts being added regularly. Click on refresh to load the latest.
@agentPlugins
There are multiple ways of installing AI plugins into VS Code. In your VS Code Extensions tab enter the keywoord @agentPlugins.
There are many plugins that you can choose from. You can narrow down the list by adding a filter. For example, I entered the csharp filter and received a short list of the plugings that fit that keyword:
Click on the csharp-dotnet-development plugin. You will see more information about the plugin. In this example, the plugin consists of a number of slash (/) commands and one agent.
I you are in a C# application, you can use the /csharp-dotnet-development:csharp-xunit slash command to generate test cases with this prompt:
/csharp-dotnet-development:csharp-xunit generate test cases
Plugins consist of plugin.json file, skills, agents, hooks, and MCP. Below is an illustration of the plugin architecture:
Any agents that are installed in your environment can be invoked from the chat window. For example, in the below illustration, I installed the CSharpExpert.agent.md agent locally and it is appears in the chat window ready to be invoked:
You can, at any time, disable or uninstall any plugin by right-clicking on it in the extensions tab and choosing disable or uninstall.
Conclusion
GitHub Copilot plugins extend AI-assisted development beyond simple code generation. With GitHub Copilot CLI, VS Code, and the Awesome Copilot ecosystem, you can add specialized agents, instructions, skills, hooks, and commands to your C# workflow.
These tools help you design .NET applications, apply best practices, generate tests, and customize Copilot to match your development style. Explore the available artifacts, install the ones that fit your needs, and adapt them to make GitHub Copilot a more effective development partner.
In this tutorial we will use a very simple C# console application to reinforce some of the concepts pertaining to coding with AI in VS Code.
Pre-requisites
You will need .NET and VS Code in order to proceed with this walkthrough.
Getting Started
Create a new console app and open it in VS Code with the following terminal window commands:
dotnet new console -o Toons.Net
cd Toons.Net
code .
Replace contents of Program.cs with:
Toon[] toons = {
new() {
ID = 1,
First = "Barney",
Last = "Rubble",
Gender = Gender.Male,
Occupation = "Mining Assistant"
},
new() {
ID = 2,
First = "Betty",
Last = "Rubble",
Gender = Gender.Female,
Occupation = "Nurse" },
new() {
ID = 3,
First = "Fred",
Last = "Flintstone",
Gender = Gender.Male,
Occupation = "Mining Manager" },
new() {
ID = 4,
First = "Wilma",
Last = "Flintstone",
Gender = Gender.Female,
Occupation = "Teacher" },
new() {
ID = 5,
First = "Pebbles",
Last = "Flintstone",
Gender = Gender.Female,
Occupation = "Toddler" },
};
foreach (var item in toons) {
Console.Write($"ID: {item.ID}, ");
Console.Write($"First: {item.First}, ");
Console.Write($"Last: {item.Last}, ");
Console.Write($"Gender: {item.Gender}, ");
Console.WriteLine($"Occupation: {item.Occupation}");
}
public class Toon {
public int ID { get; set; }
public string? First { get; set; }
public string? Last { get; set; }
public Gender Gender { get; set; }
public string? Occupation { get; set; }
}
public enum Gender {
Male,
Female
}
To see what it does, run the application by entering the following command in a terminal window inside the Toons.Net folder:
dotnet run
Custom Instructions
Custom instructions enable you to define common guidelines and rules that automatically influence how AI generates code and handles other development tasks. Instead of manually including context in every chat prompt, specify custom instructions in a Markdown file to ensure consistent AI responses that align with your coding practices and project requirements.
In a ./.github folder, add a file named copilot-instructions.md with this text that provides some coding principles and the manner by which AI will refer to you as Sensei:
# Please call me Sensei and speak with the calm discipline of a samurai.
## Naming Conventions
- Use PascalCase for component names, interfaces, and type aliases
- Use camelCase for variables, functions, and methods
- Prefix private class members with underscore (_)
- Use ALL_CAPS for constants
# Project-specific guidelines
- Use async/await for asynchronous operations
- When creating sample Toon data, ensure names are diverse and culturally inclusive
- When creating sample Toon data, use Occupations that represent a wide range of disciplines and regions
You should put your team coding standards in the copilot-instructions.md file. You may also wish to put this file at a workspace level, rather than a project level.
Note this interaction when you prompt the AI chat with "Hello":
Skills
Agent skills are folders of instructions, scripts, and resources that GitHub Copilot can load when relevant to perform specialized tasks.
You can think of agents skills as the micro-services of AI.
Agent skills are an open standard that work across multiple AI agents, including GitHub Copilot and VS Code, Copilot CLI, and Copilot Cloud Agent.
In folder ./.github/skills/hello-world, add a file named SKILL.md with this text:
A good site to visit to get skills, instructions, plugins, and agents for VS Code is https://github.com/github/awesome-copilot. Point your browser to that site then navigate to /skills/dotnet-best-practices. Copy the content of the SKILL.md file from the code tab:
Visiting https://github.com/github/awesome-copilot is a good starting point for creating these .md files which will make you very efficient in your journey developing software with AI.
Create a folder ./.github/skills/dotnet-best-practices and add to it a file named SKILL.md with the content that you copied. You can edit it as you see fit.
Add this prompt to the chat window:
Apply /dotnet-best-practices to this project
This results in best practices getting applied to your project. I noticed extensive documentation being added to Program.cs:
Console.WriteLine("""
_ _ _ _ _ _ _
| | | | ___| | | ___ __ _____ _ __| | __| | |
| |_| |/ _ \ | |/ _ \ \ \ /\ / / _ \| '__| |/ _` | |
| _ | __/ | | (_) | \ V V / (_) | | | | (_| |_|
|_| |_|\___|_|_|\___( ) \_/\_/ \___/|_| |_|\__,_(_)
""");
Toon[] toons = {
new() {
ID = 1,
First = "Barney",
Last = "Rubble",
Gender = Gender.Male,
Occupation = "Mining Assistant"
},
new() {
ID = 2,
First = "Betty",
Last = "Rubble",
Gender = Gender.Female,
Occupation = "Nurse" },
new() {
ID = 3,
First = "Fred",
Last = "Flintstone",
Gender = Gender.Male,
Occupation = "Mining Manager" },
new() {
ID = 4,
First = "Wilma",
Last = "Flintstone",
Gender = Gender.Female,
Occupation = "Teacher" },
new() {
ID = 5,
First = "Pebbles",
Last = "Flintstone",
Gender = Gender.Female,
Occupation = "Toddler" },
};
foreach (var item in toons)
{
Console.Write($"ID: {item.ID}, ");
Console.Write($"First: {item.First}, ");
Console.Write($"Last: {item.Last}, ");
Console.Write($"Gender: {item.Gender}, ");
Console.WriteLine($"Occupation: {item.Occupation}");
}
/// <summary>
/// Represents a character in the sample toon collection.
/// </summary>
public class Toon
{
/// <summary>
/// Gets the unique identifier for the toon.
/// </summary>
public int ID { get; init; }
/// <summary>
/// Gets the toon's first name.
/// </summary>
public required string First { get; init; }
/// <summary>
/// Gets the toon's last name.
/// </summary>
public required string Last { get; init; }
/// <summary>
/// Gets the toon's gender classification.
/// </summary>
public required Gender Gender { get; init; }
/// <summary>
/// Gets the toon's occupation.
/// </summary>
public required string Occupation { get; init; }
}
/// <summary>
/// Defines the gender classifications used by the sample data.
/// </summary>
public enum Gender
{
/// <summary>
/// Identifies a male toon.
/// </summary>
Male,
/// <summary>
/// Identifies a female toon.
/// </summary>
Female
}
Built-in skills and agents in VS Code
Let's ask copilot chat to add a README.md file to our project with this prompt:
Add a README.md file with relevant information about the current project.
View the built-in skills in VS Code by clicking the gear icon in the chat window:
Find the create-skill under Built-in.
Click on create-skill to view details of the agent skill. This opens the relevant SKILL.md file.
Let’s use create-skill in our software project. In the chat window, enter this prompt:
/create-skill that will update the README.md file whenever a feature is added to the project.
A new SKILL.md file is added to your project under ./.github/skills folder:
⚠️ The added feature can be given a different name than "update-readme-on-feature".
Let us add a feature to test it out. Add this prompt in the chat window:
Add a new feature that allows the list of toons to be sorted by id, first, last, gender, or occupation.
After the feature is added, you will notice that the README.md file gets updated accordingly:
Prompt files
Prompt files, also known as slash commands, let you simplify prompting for common tasks by encoding them as standalone Markdown files that you can invoke directly in chat. Each prompt file includes task-specific context and guidelines about how the task should be performed.
In folder ./.github/prompts, add a file named code-review-analyzer.md with this text:
---
name: Researcher
description: Research codebase patterns and gather context
tools: ['read', 'search']
model: Claude Sonnet 4.5 (copilot)
user-invocable: true
---
Research the existing codebase for relevant files, functions, and patterns.
Return a concise summary of your findings, including links to relevant code sections.
Report on any insights that may help in implementing new features.
If you like, you can get AI to write these instructions for you.
Invoke the analyser instructions by entering the /Researcher prompt in the chat window.
Conclusion
In this tutorial, we have learned the significance of AI Instructions, Agent Skills and Prompt Files in VS Code. The sky is the limit as to how far you can go with these concepts to make your coding experience much more efficient.
In this article we will explore the Microsoft Foundry Local CLI application. We will then write a simple C#
program
that interacts with a local model that is served by Foundry Local.
Before you begin, ensure you have the following installed on your system:
.NET 10.0
Visual Studio Code
What is Microsoft Foundry Local?
Foundry Local is an AI solution that runs entirely on the user's device. It also provides an SDK (C#, JavaScript,
Rust, and Python) that helps you build apps that interact with Foundry Local.
Installation
To install Foundry Local, follow these steps:
Windows
winget install Microsoft.FoundryLocal
macOS (only on silicon chips)
brew tap microsoft/foundrylocal
brew trust microsoft/foundrylocal
brew install foundrylocal
Exporing CLI commands
Try the following Foundry Local CLI commands:
Detect the CLI version:
foundry --version
Expected output:
0.8.119
View the list of CLI commands:
foundry --help
Expected output:
Description:
Foundry Local CLI: Run AI models on your device.
🚀 Getting started:
1. To view available models: foundry model list
2. To run a model: foundry model run <model>
EXAMPLES:
foundry model run phi-3-mini-4k
Usage:
foundry [command] [options]
Options:
-?, -h, --help Show help and usage information
--version Show version information
--license Display foundry license information
Commands:
model Discover, run and manage models
cache Manage the local cache
service Manage the local model inference service
Download a model into local cache:
foundry model download qwen2.5-0.5b
Expected output:
Downloading qwen2.5-0.5b-instruct-generic-gpu:4...
. . . T R U N C A T E D . . .
[################################## ] 94.85 % [Time remaining: about 1s]
[################################## ] 95.22 % [Time remaining: about 1s]
[################################## ] 95.59 % [Time remaining: about 1s]
[################################## ] 95.96 % [Time remaining: about 1s]
[################################## ] 96.33 % [Time remaining: about 1s]
[################################## ] 96.69 % [Time remaining: about 1s]
[################################## ] 97.06 % [Time remaining: about 1s]
[################################### ] 97.43 % [Time remaining: about 1s]
[################################### ] 97.79 % [Time remaining: about 1s]
[################################### ] 98.16 % [Time remaining: about 1s]
[################################### ] 98.53 % [Time remaining: about 1s]
[################################### ] 98.90 % [Time remaining: about 1s]
[################################### ] 99.27 % [Time remaining: about 1s]
[################################### ] 99.63 % [Time remaining: about 1s]
[####################################] 100.00 % [Time remaining: about 0s]
💡 Tip:
- To find model cache location use: foundry cache location
- To find models already downloaded use: foundry cache ls
⚠️ This will delete model 'qwen2.5-0.5b (qwen2.5-0.5b-instruct-generic-gpu:4)' from cache.
⚠️ Are you sure you want to delete this model from the local cache? (y/n)
y
Deleted model qwen2.5-0.5b-instruct-generic-gpu:4 from the cache.
Download and run a model:
foundry run qwen2.5-0.5b
Expected output:
Downloading qwen2.5-0.5b-instruct-generic-gpu:4...
[####################################] 100.00 %
[Time remaining: about 0s] 105.2 MB/s
🕛 Loading model...
🟢 Model qwen2.5-0.5b-instruct-generic-gpu:4 loaded successfully
Interactive Chat. Enter /? or /help for help.
Press Ctrl+C to cancel generation. Type /exit to leave the chat.
Interactive mode, please enter your prompt
>
💡 TIP
If you get an error when running a model, it may mean that your hardware is
incompatible
with the specific model
that was downloaded. You can try looking ar variants of that model for different processor
configurations.
Enter /exit to exit Foundry CLI.
To view the
variants for a model (Example: qwen2.5-0.5b), type the following command:
You can then try one of the variants like qwen2.5-0.5b-instruct-generic-cpu with:
foundry run qwen2.5-0.5b-instruct-generic-cpu
The above puts the user in a CLI interactive mode. You can then send prompt to the model. Let's ask the model
to
create for us a C# program that does temperature conversion. Type in the following prompt:
Write a C# console app that converts temperature from C to F and also from F to C.
Expected output:
🧠Thinking...
🤖 Certainly!
Below is a simple console application written in C# that takes
user input for Celsius temperature and converts it to either
Fahrenheit or vice versa.
using System;
using System.Windows.Forms;
namespace TemperatureConverterApp
{
class Program
{
static void Main(string[] args)
{
try
{
Console.WriteLine("Enter the Temperature (in Celcius): ");
int celsius = Convert.ToInt32(Console.ReadLine());
bool convertToFahrenheit = false;
string result;
if (Convert.ToBoolean(calculateCtoF(celsius)) == true)
result = "Celsius to Fahrenheit: ";
else
result = "Temperature not converted";
result += $"Celsius {result}";
if (convertToFahrenheit)
{
Console.WriteLine($"Result: Fahrenheits");
return;
}
Console.WriteLine(result);
}
catch
{
Console.WriteLine("Invalid Input");
}
}
public static bool calculateCtoF(int celsius)
{
double fahrenheit = 9/5 * celsius + 32;
double result = Math.Round(fahrenheit, 1);
// Round down to the nearest integer since temperatures must be whole numbers
if (fahrenheit.ToString() != "0")
return true;
else
return false;
}
public static bool calculateFtoc(double fahrenheit)
{
double celsius = fahrenheit - 32 * 5 / 9;
double result = Math.Round(celsius, 1);
// Round down to the nearest integer since temperatures must be whole numbers
if (celsius.ToString() != "0")
return true;
else
return false;
}
}
}
Explanation:
1. Imports: The code starts with importing necessary namespaces
(System and
System.Windows.Forms). It's assumed you have this namespace available.
2. Program Class:
- This contains the main program logic.
3. calculateCtoF Function:
- Calculates the temperature in Fahrenheit given Celsius temperature.
- If successful, calculates the equivalent number of degrees Celsius based
on the provided value and rounds it to
the closest integer.
- Outputs the result along with any additional information like "Celsius"
or "Temperature not converted".
4. calculateFtoc Function:
- Calculates the equivalent temperature in Celcius given the equivalent
degrees Fahrenheit.
- Same as calculateCtoF, but used for converting degrees
Fahrenheit back to Celsius.
Example Usage:
If you run the program, pressing the keyboard will take an input to calculate the correct
conversion type and output results accordingly.
Example Input: 25
- If calculated using Celsius, it will print: "Celsius", then "25".
- If converted to Fahrenheit, it will print: "Temperature not converted",
then "25".
This example only demonstrates basic conversions between the two temperature scales and
inputs like non-numerical characters which would throw exceptions during parsing.
The Foundry Local SDK enables you to ship AI features in your applications that are capable of using local AI
models
through a simple and intuitive API. The SDK abstracts away the complexities of managing AI models and
provides a
seamless experience for integrating local AI capabilities into your applications.
In the terminal inside a suitable working directory on your computer, create a new console application and add the
necessary packages with the following commands:
dotnet new console -o FoundryLocalConsoleApp
cd FoundryLocalConsoleApp
dotnet add package Microsoft.AI.Foundry.Local
dotnet add package Microsoft.Extensions.Logging
Open the project in VS Code by typing this in the same terminal window:
code .
Add this to the .csproj file right above </PropertyGroup>:
Replace Program.cs with this code that asks the qwen2.5-0.5b local AI model the
question:
Where did coffee come from?:
1 - Import Namespaces
Purpose:These using statements bring the required libraries into scope.
using Microsoft.AI.Foundry.Local;
using Microsoft.Extensions.Logging;
2 - Create a Cancellation Token
Purpose: Allows long-running operations to be canceled.
CancellationToken ct = new();
3 - Configure Foundry Local
Purpose: Creates runtime settings for Foundry Local.
var config = new Configuration {
AppName = "foundry_local_samples",
LogLevel = Microsoft.AI.Foundry.Local.LogLevel.Information
};
4 - Create a Logger
Purpose: Creates an ILogger.
using var loggerFactory = LoggerFactory.Create(builder => {
// Intentionally no providers configured
});
ILogger logger = loggerFactory.CreateLogger("FoundryLocalConsoleApp");
5 - Initialize Foundry Local
Purpose: Starts the Foundry Local system.
await FoundryLocalManager.CreateAsync(config, logger);
var mgr = FoundryLocalManager.Instance;
6 - Discover Available Execution Providers
Find available hardware acceleration backends.
Examples might include:
CPU
DirectML
CUDA
ROCm
ONNX Runtime providers
var eps = mgr.DiscoverEps();
int maxNameLen = 30;
Console.WriteLine("Available execution providers:");
Console.WriteLine($" {"Name".PadRight(maxNameLen)} Registered");
Console.WriteLine($" {new string('─', maxNameLen)} {"──────────"}");
foreach (var ep in eps) {
Console.WriteLine($" {ep.Name.PadRight(maxNameLen)} {ep.IsRegistered}");
}
7 - Download and Register Execution Providers
Purpose: Download and register all execution providers with per-EP progress.
EP packages include dependencies and may be large.
Download is only required again if a new version of the EP is released.
For cross platform builds there is no dynamic EP download and this will return immediately.
Purpose: Load the model into memory for inference.
Console.Write($"Loading model {model.Id}...");
await model.LoadAsync();
Console.WriteLine("done.");
12 - Sends a streamed chat request and print final answer.
Purpose: Aski the local AI model a factual question, telling it to answer conservatively if unsure, wait for the
full generated response, and then print only the text content of that response to the console.
using (var chatSession = new ChatSession(model)) {
// Enable token streaming so request can produce incremental output.
chatSession.SetStreaming(true);
// Request contains user message and is processed by loaded model.
using var request = new Request();
request.AddItem(MessageItem.User("Where did coffee come from?"));
request.AddItem(MessageItem.System("Say 'I do not know' if you do not know the answer."));
Console.WriteLine("Chat completion response:");
await using var streamingResponse
= chatSession.ProcessStreamingRequestAsync(request, ct);
// Drain stream before reading FinalResponse.
await foreach (var item in streamingResponse) {
Console.Out.Flush();
}
// Dispose final response before session and model are disposed.
using var finalResponse = await streamingResponse.FinalResponse;
foreach (var item in finalResponse) {
if (item is MessageItem message && message.IsSimpleText()) {
Console.Write(message.GetSimpleText());
}
}
}
Console.WriteLine();
13- Clean Up Resources
Purpose: Remove the model from memory.
await model.UnloadAsync();
ℹ️ NOTE - Notice model qwen2.5-0.5b in the above code (around line 59). Change this to any
other
model or
variant of your choice.
To run the application, type: dotnet run
Expected output:
Available execution providers:
Name Registered
────────────────────────────── ──────────
WebGpuExecutionProvider False
Downloading execution providers:
WebGpuExecutionProvider 100.0%
Loading model qwen2.5-0.5b-instruct-generic-gpu:4...done.
Chat completion response:
Coffee originated in the Ethiopian Highlands and later spread to other regions
due to various factors such as trade, migration, and disease. It''s believed that
people first brought coffee from Ethiopia with them when they migrated to other
parts of the world. The earliest known records suggest that the first drink made
from coffee was consumed by the Shas people in West Africa. As the demand for coffee grew,
more people began to experiment with making their own beverages. By 1750, coffee had
been developed into its current form in the Middle East and Asia. It wasn''t until 1826
that an American named Robert Brown invented espresso, which has since become one of the
most popular beverages worldwide. The history of coffee is a story of innovation, trade,
and cultural exchange over centuries. Coffee has played a significant role in many societies
around the world and continues to be enjoyed today through different methods and traditions.
foundry model list
foundry model list --device gpu
foundry model list --search deep
foundry model list --cached
foundry model list --cached --output json
foundry model list --cached --variants
Conclusion
In conclusion, Microsoft Foundry Local offers a powerful and cost-effective solution for developers looking
to
run and
experiment with small language models directly on their own devices. By bypassing the token expenses and
network
dependencies associated with cloud-hosted platforms like Azure, the platform's intuitive CLI empowers users
to
efficiently manage model caches, download hardware-tailored model variants, and engage in fast interactive
AI
prompting
entirely offline. Whether you are using it to spin up quick terminal chats or leverage its versatile
multi-language SDKs
for seamless application integration, Foundry Local effectively removes cloud-based complexities, proving
itself
to be
an invaluable asset for building private, local, and modern AI-driven features.
Squad is a team of agents that work on your behalf to conduct specializations like: DevOps, Testing, DB
optimization,
etc. Squad works with GitHub Copilot CLI. In this article, we will explore Squad by getting it to create ASP.NET Blazor application, then enhance it with more features.
ⓘ NOTE:
This is an experimental project and may change over time.
Using Squad can result in the consumption of a sizable amount of AI tokens.
Pre-requisites
In order to proceed with this tutorial, you will need to have the following software installed on your computer:
You need to have Node.js and npm (version 5.2.0 or higher)
installed on
your computer in order to setup Squad.
Using Squad can result in the consumption of a sizable amount of AI tokens.
Connect to a SQLite Database
Let's use GitHub Copilot CLI to connect to and explore the
Chinook
database (a sample database that represents a digital music store).
What is the Chinook Database?
The Chinook database models a digital media store, similar to an old iTunes store. It contains real music
data and
includes 11 tables:
Table
Description
Artist
Music artists
Album
Albums released by artists
Track
Individual songs, including price and duration
Genre
Music genres (Rock, Jazz, Pop, etc.)
MediaType
Format of the track (MP3, AAC, etc.)
Playlist
Named playlists
PlaylistTrack
Tracks belonging to each playlist
Customer
Store customers
Employee
Store employees and their reporting structure
Invoice
Customer purchases
InvoiceLine
Individual line items on each invoice
Connecting to the Database
Download the Chinook.sqlite database file here 👉Click
to download
Create a folder named Chinook and place the downloaded Chinook.sqlite file
inside
it.
Open your terminal, navigate to the Chinook folder, and launch
GitHub Copilot CLI,
by typing in:
copilot
Wait for the Copilot CLI interface to load. You should see the prompt ready for input.
Once inside Copilot CLI, type the following prompt and press ENTER to establish a
connection to
the Chinook database. This tells Copilot which database file to use and how to access it.
Connect to the Chinook.sqlite database using the connection string DataSource=Chinook.sqlite;Cache=Shared;
You should see Copilot confirm the connection. If you are asked to trust files in the current folder
or asked
to run commands, press ENTER to confirm Yes.
Exploring the Database
Once connected, try the following prompts one at a time. After each one, take a moment to look at the results
before
moving on.
List all tables in the database:
List all the tables in a table format
See what is inside a table:
Display data in the Genre table.
Ask for insights:
Analyse the data in the database and provide me with some interesting insights.
Use SQLite database with ASP.NET app
Let's use GitHub Copilot CLI to build a simple ASP.NET Razor Pages web application that reads and manages data from the Chinook database. You will do this step by step, one prompt at a time.
💡TIP: If you want GitHub Copilot to run commands without always asking for confirmation, enter the command /yolo, which stands for "You Only Live Once".1
Prompt 1 — Create the Project
Type the following prompt inside Copilot CLI and press ENTER:
Create a simple ASP.NET Razor Pages web application using .NET 10 in a folder named Chinook.Web. Do not add any database or authentication yet.
💡TIP: Wait for Copilot to finish completely before moving on to the next prompt. Rushing to the next step before Copilot is done is the most common cause of errors in this tutorial.
Prompt 2 — Connect the Database
⚠️WARNING: The following prompt connects to your existing Chinook.sqlite database. Do not modify or delete the database file while Copilot is running, as this may cause your data to be lost.
Add Entity Framework Core SQLite to Chinook.Web. Connect it to the existing Chinook.sqlite in the parent folder using connection string "DataSource=../Chinook.sqlite;Cache=Shared;" in appsettings.Development.json. Do not overwrite or delete any existing data.
💡TIP: To verify the app is running correctly, open a new terminal window, navigate to the Chinook.Web folder, and run:
dotnet watch
Your browser should open automatically.
Prompt 3 — Scaffold CRUD Pages
Create a Genre model that matches the existing Genre table in Chinook.sqlite. The SQLite database uses singular table names (e.g. Genre, not Genres), so the model must include a [Table("Genre")] attribute from System.ComponentModel.DataAnnotations.Schema to prevent Entity Framework Core from pluralizing the table name. Scaffold full CRUD Razor Pages for Genre. Add a Genre link to the main navigation menu.
💡TIP: Go back to the terminal running dotnet watch. Your app should reload automatically. Navigate to the /Genres page in your browser. You should see a list of genres loaded from the Chinook database.
Prompt 4 — Apply the Theme
Replace the default Bootstrap CSS in _Layout.cshtml with the Bootswatch Sketchy theme CDN link from https://bootswatch.com/sketchy/
Your app should now look noticeably different (hand-drawn style buttons and a unique font). Refresh http://localhost:5000/Genres to see the new theme applied.
Prompt 5 — Run the app
Run the app
If everything is OK, you should see the Genre list page populated with data from the Chinook database. Try adding, editing, and deleting a genre to confirm that full CRUD functionality is working.
Let's use Squad
Install Squad globally on your computer by typing the follwoing terminal window command:
npm install -g @bradygaster/squad-cli
In the Chinook.Web folder created in tutorial number 2 (CRUD App), initialize Squad with:
squad init
Start a GitHub Copilot CLI session by typing the following terminal window command:
copilot
You must be logged into GitHub in order to use Squad. Type the following command in the input field to login
into
GitHub:
Select GitHub.com by hitting ENTER on 1.
A message is displayed that a code will be placed in the clipboard and your browser will be used for
authentication
once you press any key.
Your default browser will open to the Device Activation page.
Choose your preferred GitHub account then click on Continue.
Enter the one-time code that was given to you in the GitHub Copilot CLI, then click on Continue.
Note that
it will be different from the code in the image above.
Click on Authorize github.
You might be required to go through the multi-function authentication process. Once you are fully
authenticated, you
should received the below message in your browser:
We will choose the Squad agent to help us improve the Chinook.Web app. In the input field, type
the
following command to select an agent:
Choose the Squad agent.
It would be exhausing for the developer to approve every action that agents will be attempting to make.
Autopilot
mode is a behavioral state where Copilot executes multi-step tasks autonomously until completion. We will
set the
CLI to work in autopilot mode. Cycle through all the various modes with SHIFT TAB and
select
autopilot.
Enter this prompt:
I like the disney universe of cartoon characters and would like to assign a squad to work on the Chinook.Web project.
Review the current state, propose new features, and discuss next steps.
Accept the request for elevated permissions.
💡TIP: If you enter command /tasks, you can observe the individual agents at work.
A long process of autonomous work will commence. Sit back, relax, and watch what is happening. Once
everything
settles down, you will receive a message that looks like this:
Next steps you requested:
- Review current state: Try "Mickey, review the current project
architecture"
- Propose features: Try "Team, what should we build next?" or "Mickey,
propose features for the Chinook database"
- Discuss next steps: Ask "What features would make the most impact?" or
have Mickey analyze the Chinook schema and suggest CRUD pages for other
entities (Artists, Albums, Tracks, etc.)
Quick commands to try:
- "Mickey, review the project" — architecture analysis
- "Team, add CRUD pages for Artists" — parallel fan-out to build a feature
- "What's in the Chinook database?" — I can answer directly (no spawn
needed)
- "Ralph, status" — check for any work in progress
The team is fully configured, state files are in place, and .gitattributes
is set up for clean cross-branch merges. Ready to work!
Look at the source code, you will notice that much has happened.
A number of skills were added to the .copilot/skills folder:
Workflows were added to the .github/workflows folder:
Under the .squad folder, in addition to other folders and files, there is an
agents
folder with our Disney workers:
Read the charter for each of these workers. For example, Mickey's charter in the charter.md file
is:
# Mickey — Lead
> Architecture, scope, and quality — the one who sees the whole picture
## Identity
- **Name:** Mickey
- **Role:** Lead & Architect
- **Expertise:** System design, code review, architectural patterns, .NET best practices
- **Style:** Direct and decisive. Thinks big picture first, details second.
## What I Own
- Overall project architecture and design decisions
- Code review and quality gates
- Technical scope definition and feature planning
- Cross-module integration and consistency
## How I Work
- Start with the why, then the what, then the how
- Push back on scope creep and unnecessary complexity
- Review others' work with an architectural lens
- Document key decisions in the team knowledge base
## Boundaries
**I handle:** Architecture, design reviews, scope decisions, technical leadership
**I don't handle:** Deep implementation details (that's for the specialists), day-to-day bug fixes
**When I'm unsure:** I consult with the appropriate specialist (Donald for backend, Minnie for frontend, Goofy for testing strategy)
**If I review others' work:** On rejection, I may require a different agent to revise (not the original author) or request a new specialist be spawned. The Coordinator enforces this.
## Model
- **Preferred:** auto
- **Rationale:** Coordinator selects the best model based on task type — cost first unless writing code
- **Fallback:** Standard chain — the coordinator handles fallback automatically
## Collaboration
Before starting work, use the `TEAM ROOT` provided in the spawn prompt. All `.squad/` paths must be resolved relative to this root.
Before starting work, read `.squad/decisions.md` for team decisions that affect me.
After making a decision others should know, write it to `.squad/decisions/inbox/mickey-{brief-slug}.md` — the Scribe will merge it.
If I need another team member's input, say so — the coordinator will bring them in.
## Voice
Opinionated about clean architecture. Will push back on technical debt. Prefers simplicity over cleverness. Thinks in systems, not just features. Not afraid to say "we shouldn't build that."
Go ahead and ask for more features. I asked for the following enhancements:
add CRUD pages for Artists
add Sales Dashboard & Reporting
recruit a GitHub DevOps engineer to configure some github actions for CI
add web designer to help make the UI of the entire web app more colorful and compelling
ⓘ NOTE that agents get to choose different models for theie assigned tasks. For example: Mickey is using
claude-sonnet-4.6, and Daisy is using claude-opus-4.5, etc.
There are instances when one agent waits for other agents to complete their assigned tasks.
The end result is that we now have a web app that is colorful, has artists crud, and a dashboard.
Here's what the dashboard looks like:
To find out token usage, you can type the /usage command. I used 7.5 million tokens. Most were
used in
understanding the entireity of the code base.
Squad is a very interesting tool and provides us with an insight into the future world of software
development.
