
Meet Sia, a Microsoft certified trainer and Azure certified engineer, and learn to build a real rack system in C# with .NET 10 using enterprise backend patterns and code.
Builds a local iChatBuddy system with an offline ingestion pipeline. Reads incident documents, creates vector embeddings, stores them in a vector store, and powers a chat API tested by Swagger.
Explore the practical rag repo on GitHub, organized by sections that align with Udemy. Code along, compare to the completed section folders, and jump to any section to catch up.
Install Visual Studio 2026, .NET 10, and Docker Desktop to set up local AI runtime, then create a Spire solution and use Ollama and WebUI for a simple chat system.
Install Visual Studio 2026 community edition with the ASP.NET and web development workload; .NET 10 installs automatically by default, change installation location or uncheck download cache to save space, launch.
Integrate Olama for local llm deployment in a .NET Aspire project by installing host packages, configuring the builder, and testing with Open Web UI using Llama 3.2.
Explore the Aspire framework and build a simple chat API. Call a local LLM using Ullama and learn how prompts act as application logic in your code.
Learn how the Aspire framework wires an API, a background ingestion service, and infrastructure like Olama and a vector database into a distributed application using a builder, dashboards, and Swagger.
Learn to integrate swagger with NSwag into a .NET API, generate an OpenAPI JSON document, expose endpoints and parameters, and use an interactive UI to test calls.
Define a chat controller under controllers with route api/chat. Implement a post endpoint that receives a user message, sends it to the chat model, and returns the response.
Create chat request and response models in a models folder, wire the controller to accept a chat request with a query and return a chat response with message and status.
Introduce the IChatClient abstraction by wiring a chat client to the Olama chat model in a web API, enabling calls to get chat responses.
Learn how retrieval augmented generation (RAC) works in practical C# with .NET 10 and Azure by retrieving data and adding it to prompts so the model reads it before answering.
Implement a dedicated ingestion and rag workflow that processes new ICS events via a worker service, enabling context-aware model answers independent of user questions.
Create an ingestion worker service in .NET 10 and run it in the background with Aspire orchestration, looping every second to log information and to retrieve ICM data.
Upgrade all NuGet packages, including pre-release. Then load 25 sample ICMs about network issues and simulate reading ICM files from disk for a mock ingestion service.
Compare chunking strategies to enable effective retrieval over large documents, detailing header chunker, section chunker, and semantic chunker, and outlining embedding models, vectors, and similarity thresholds for cohesive chunks.
Learn to save 384-d vectors from all mini LM embeddings to a SQL lite vector store via a vector store writer, using collection data-icm-chunks and cosine distance with incremental ingestion.
Explore vector search and grounded chat in ICM Buddy, retrieving data from a vector store with semantic search and grounding responses to real incidents through an end-to-end query flow.
Run the app, test the chat API with Swagger, and query the orders latency spike; reveal the model cannot retrieve vector data and needs vector DB integration.
Implement the IcmChunk model by defining key, content, context, and document ID with required constraints, map SQL data to the model, and connect it to the chat search flow.
Configure chat options and the AI function factory to enable function invocation in a chat model, wire tools with metadata, and debug with swagger to fetch data.
Learn to add a redis distributed cache to a chat api, register iDistributedCache, and configure caching with a connection name, then explore ttl and cache hit behavior.
Assess latency, cost, and failure modes in a retrieval-augmented generation flow using C# with .NET 10, emphasizing observability, vector search, prompts, and refactoring for Azure integration.
Map your local setup to Azure by cleaning the project, swapping SQLite with Azure AI Search, and replacing the Olamo model with Azure AI Foundry GPT to run ICM body.
Clean up the code for Azure resources, convert embedding to float, and update the chat endpoint to return an action result with handling for operational cancel (499) and other errors.
Create and configure azure search ai resources in the portal, add them to Aspire as existing, and manage environment parameters with user secrets while distinguishing run and publish modes.
Integrate Azure search as the chat API data source by configuring the Azure search client, adding a custom Azure search collection extension, and securing access with RBAC.
Configure the chat API to use Azure search AI by aligning storage names and JSON property names, define vector embeddings, and route between Azure search and SQL lite per environment.
Deploy a GPT 5.2 chat model on azure foundry, an enterprise ai platform for hosting and governance, via the azure portal or ai.azure.com.
Integrate Foundry with the chat API in a .NET app by installing Aspire Foundry, wiring the hosting and chat client, and swapping in a Foundry GPT deployment for testing.
Trace the end-to-end build from a blank Aspire solution to a working system. Implement local AI runtime, chat API, ingestion pipeline, ICM integration, observability, and Azure deployment.
Complete the course and gain a real working rack system built for production, ready to use what you learned in your real work; share feedback and keep building real systems.
Built and taught by a Microsoft engineer (Microsoft Certified Trainer) with 15+ years of software engineering experience: this course shows you how to build a real Retrieval-Augmented Generation (RAG) application in C# with .NET 10 and Azure — not Python.
You'll go from a blank Aspire solution to a working enterprise-style RAG application. Along the way you'll learn the full pipeline — ingestion, chunking, embeddings, vector storage, retrieval, tool calling, grounded responses — and you'll see the same code run locally against Ollama and a SQLite vector store, then swap to Azure AI Search and Azure AI Foundry with a single configuration flag.
Most RAG tutorials today are written for Python. This one isn't. It's for C# and .NET developers who want to understand RAG by building it, in idiomatic .NET, with the modern stack.
What you'll build
A working incident-management AI assistant ("IcM Buddy") — answers incident questions grounded in real on-call/SRE incident documents, returns structured Diagnosis / Recommended Actions / Related Incidents, and refuses to answer when the data isn't there (no hallucinations).
What makes this course different
C# and .NET, not Python — built around Microsoft Extensions AI, IChatClient, and the new Microsoft.Extensions.DataIngestion pipeline
Modern stack — .NET 10, C# 13, Aspire 13, Visual Studio 2026
Local-first — run everything on your laptop with Ollama (no cloud bill while you learn)
Real production patterns — resilience handlers, retries, timeouts, OpenTelemetry, distributed caching with Redis
One-flag Azure parity — the same application code runs against Azure AI Search and Azure AI Foundry (GPT models) by toggling a useAzure flag — no rewrite
Real domain, not toy examples — ICM (incident management) with 25 realistic enterprise incident documents, not "ask about Shakespeare"
API-first, Swagger-only — no UI to maintain or distract from the AI architecture
Topics covered
The Aspire 13 framework: AppHost, ServiceDefaults, container orchestration
Ollama integration in C# (chat models + embedding models)
The Chat API: contract design, IChatClient abstraction, prompts as application logic
Resilience: custom retry/circuit-breaker handlers tuned for AI workloads
The full RAG pipeline: ingestion worker, markdown reader, semantic chunking, embeddings, vector storage
Tool calling and function invocation for grounded retrieval
System prompts that enforce grounding rules
Observability: OpenTelemetry tracing for AI requests and vector searches
Distributed caching with Redis
Azure parity: Azure AI Search and Azure AI Foundry with the same application code
Who this course is for
C# and .NET developers who want to learn RAG and AI without learning Python
Backend engineers building AI-powered APIs in .NET 10
Architects and senior devs evaluating how to integrate AI into existing .NET systems
Microsoft-shop developers who need an Azure-aligned AI architecture they can actually take to production
What this course is NOT
To be honest about scope so you can decide before enrolling:
Not a deep machine-learning or model-training course — we use models, we don't train them
Not an Azure deployment course — we configure Azure resources but don't cover IaC, CI/CD pipelines, or production hardening
Not a UI/frontend course — everything is API-first, tested via Swagger
Not a Python or LangChain course
Requirements
Basic C# and .NET (you've built APIs or services before)
Familiarity with REST and JSON
A machine that can run Docker Desktop (Windows or Mac)
No prior AI, RAG, or machine-learning experience needed