For .NET developers who need to add LLM features to ASP.NET Core and worker services with Microsoft.Extensions.AI, the official vendor SDKs, Microsoft Agent Framework and local ONNX models.
The curriculum is being prepared and reviewed. Enrollment is not open yet.
About this course
The .NET AI stack consolidated considerably during 2025 and 2026. Microsoft.Extensions.AI now provides a common IChatClient and IEmbeddingGenerator abstraction with middleware for caching, telemetry and function invocation; the official OpenAI, Anthropic and Google.GenAI SDKs all plug into it; Microsoft Agent Framework (GA since April 2026) has replaced Semantic Kernel as the recommended agent layer, with Semantic Kernel in maintenance mode; and local inference is available through ONNX Runtime GenAI, Foundry Local, LLamaSharp and Ollama.
This course teaches that stack the way production .NET code uses it. You will register chat clients through dependency injection, compose middleware pipelines, get strongly typed structured output into C# records, stream tokens with IAsyncEnumerable to ASP.NET Core endpoints and Blazor or SignalR clients, and handle concurrency with System.Threading.Channels and resilience with Microsoft.Extensions.Http.Resilience. You will build agents and tools with Microsoft Agent Framework and the ModelContextProtocol C# SDK, use Microsoft.Extensions.VectorData for retrieval, run models in-process, and test and evaluate with xUnit and Microsoft.Extensions.AI.Evaluation. The course closes with configuration, secrets, OpenTelemetry, Aspire orchestration, Native AOT considerations and container deployment. Versions are as of October 2026 (.NET 10 LTS, C# 14, Aspire 13).
What you will be able to do
Register and compose IChatClient and IEmbeddingGenerator implementations for OpenAI, Azure OpenAI, Anthropic, Gemini and Ollama through dependency injection
Produce strongly typed structured output into C# records and handle schema or deserialization failures
Stream responses with IAsyncEnumerable from ASP.NET Core to a client with cancellation and resilience policies applied
Build a tool-using agent with Microsoft Agent Framework and expose or consume tools through the ModelContextProtocol C# SDK
Run a local model in-process with ONNX Runtime GenAI or LLamaSharp, or via Foundry Local, and justify that choice against a hosted API
Test LLM-dependent code with fakes and recorded responses, and add quality evaluations with Microsoft.Extensions.AI.Evaluation
Plan a migration from Semantic Kernel to Microsoft Agent Framework and deploy an AI service with telemetry, secrets management and containers
Syllabus
6 modules · 19 lessons · about 14 hours
1
Module 1: The .NET AI Abstractions and Vendor SDKs
Microsoft.Extensions.AI as the common contract, and the official SDKs behind it.3 lessons
IChatClient and IEmbeddingGenerator: the Microsoft.Extensions.AI contract
The OpenAI, Anthropic and Google.GenAI SDKs, and reaching Azure OpenAI with the OpenAI client
Middleware pipelines: caching, logging, OpenTelemetry and automatic function invocation
2
Module 2: Structured Output, Streaming and Concurrency
Typed results and responsive services using idiomatic async C#.3 lessons
Structured output into C# records: JSON schema generation and validation
Streaming with IAsyncEnumerable to minimal APIs, SignalR and Blazor
Channels, bounded parallelism and Polly-based resilience with Microsoft.Extensions.Http.Resilience
3
Module 3: Agents, Tools and Retrieval
From single calls to tool-using agents and grounded answers.4 lessons
Microsoft Agent Framework: agents, tools, workflows and threads
Migrating from Semantic Kernel: what maps across and what changes
Model Context Protocol servers and clients with the ModelContextProtocol C# SDK
Retrieval with Microsoft.Extensions.VectorData connectors
4
Module 4: Local and On-premises Inference
Running models on your own hardware from .NET.3 lessons
ONNX Runtime GenAI and Foundry Local: small models on CPU, GPU and NPU
LLamaSharp and OllamaSharp: GGUF models in-process and over HTTP
Choosing local versus hosted: latency, cost, data residency and operations
5
Module 5: Testing and Evaluation
Keeping AI features correct as models and prompts change.3 lessons
Unit tests with fake IChatClient implementations and recorded responses
Quality and safety evaluations with Microsoft.Extensions.AI.Evaluation
Integration tests against local models in CI
6
Module 6: Packaging and Deployment
Production concerns for AI-enabled .NET services.3 lessons
Configuration, secrets and managed identity for model endpoints
Aspire orchestration and OpenTelemetry for AI calls
Containers, Native AOT trade-offs and cost controls in production
Exam and certificate
The exam unlocks once you have completed every lesson. It draws 20 questions from a larger bank, spread across the modules, with the answer options shuffled for each attempt. You have 40 minutes and need 80% to pass. After a failed attempt you can try again after 24 hours, up to 3 attempts in total. Feedback is given per module, never as the answer key.
Passing earns a certificate of completion and assessment from the Wirewalk Institute of AI with a unique ID that anyone can check at institute.wirewalk.com/verify. It is not an accredited qualification or a vendor certification. How certification works.
The Wirewalk Institute of AI is independent. This course teaches publicly documented products and is not affiliated with or endorsed by Microsoft (.NET, Microsoft.Extensions.AI, Agent Framework, Semantic Kernel, Foundry Local, ONNX Runtime, Aspire), OpenAI, Azure OpenAI, Anthropic, Google (Gemini), Ollama, LLamaSharp, or Model Context Protocol. Product and company names are trademarks of their respective owners.
A free, one-hour, hands-on start built on one realistic job: sorting a property manager's 1,150 monthly maintenance requests. You get an API key the safe way, make real calls with curl and an official Python SDK, run them over forty work orders, read stop reasons, usage and errors, estimate the monthly cost, and decide whether the script is ready. Exercises run on your own provider account for well under a dollar.
A code-first course on integrating LLMs into Python the way production code needs it: uv projects and secrets, the OpenAI, Anthropic and Google GenAI SDKs side by side, async concurrency and streaming, Pydantic structured outputs and tools, retries, local models, embeddings and RAG, FastAPI and pandas integration, testing and evals with pytest, observability, cost tracking and deployment.
Call OpenAI, Anthropic, Gemini and local Ollama models from Perl with real CPAN modules, add streaming, concurrency and validated JSON output to text pipelines, and use AI coding assistants to modernize legacy Perl behind characterization tests.