Episode 17 (Series Finale) – Deploy Your Full-Stack .NET AI App to Azure

🚀 Episode 17 (Series Finale) – Deploy Your Full-Stack .NET AI App to Azure

Complete .NET AI Developer Series – In the final episode we take the full app from localhost to Azure: React on Azure Static Web Apps, the ASP.NET Core API on Azure App Service, Azure OpenAI, and vectors on Qdrant Cloud.

🎯 What's Included

• CORS origins read from configuration (Cors:Origins), localhost fallback for development
• Forwarded headers so rate limiting sees the real client IP behind App Service
• Qdrant client with configurable TLS and API key (Qdrant:Https, Qdrant:ApiKey) in QdrantVectorService and DocumentService
• /health endpoint
• React .env.production with the live API URL
• Node version pinned in package.json (engines)
• GitHub Actions workflow for Azure Static Web Apps (app location /dotnetai-chat, output dist)
• Fixes: ./api/docApi import letter case for Linux builds, Static Web Apps output folder, CORS for the Static Web App URL, Qdrant host without https://

📺 Watch the Video

https://www.youtube.com/watch?v=RJBgIvuQdnE

📚 Playlist

https://www.youtube.com/playlist?list=PLF4drO8z96Rc

💻 Repository

https://github.com/sandeeppatil-newvision/Complete-DotNet-AI-API

---

⭐ If this episode helped you, please star the repository and subscribe to the channel.

Episode 16 – AI Red Teaming in .NET: Hack Your Own AI Agent, Then Fix It

🚀 Episode 16 – AI Red Teaming: Attack Your Own .NET AI Agent, Then Harden It

Complete .NET AI Developer Series – In this episode we attack the EP15 AI agent with five real attacks, then fix every hole with six guards and prove it with a final red-team run.

🎯 What's Included

• Dev-only red-team endpoint: POST api/AgentV1/redteam
• AttackCase record with MustNotContain and MustContainAny scoring
• Five attacks: system prompt leak, fake admin, forged assistant turn, poisoned PDF and tool spam
• Fix 1: AgentGuard request validation (messages, characters and roles)
• Fix 2: Hardened system prompt with SECURITY RULES
• Fix 3: ToolResultGuard to wrap and clean tool output
• Fix 4: Tool call budget (MaxToolCalls = 8)
• Fix 5: Safe errors with ILogger and input limits on search_documents and calculate
• Fix 6: Rate limiting with AddRateLimiter (10 requests per minute per IP, 429 response)
• Final red-team runs and live attack demos in the React agent tab

📺 Watch the Video

[Add EP16 YouTube URL]

📚 Playlist

https://www.youtube.com/playlist?list=PLF4drO8z96Rc

💻 Repository

https://github.com/sandeeppatil-newvision/Complete-DotNet-AI-API

---

⭐ If this episode helped you, please star the repository and subscribe to the channel.

episode15 - I Built an AI Agent in C# (Azure OpenAI + Qdrant)

EP15: AI Agent with Tool Calling (Phase 3, Episode 4)

Watch the episode: https://www.youtube.com/watch?v=p7XXdovsRAc&t
Builds on: ep14 (AI Document Analyzer). Download this release so your code matches the video.

WHAT'S NEW

Backend (DotNetAI.API)

• Services/AgentTools.cs
  • 3 tools: list_documents, search_documents, calculate
  • Tool definitions (name, description, JSON schema) sent to the model
  • ExecuteAsync runs the tool the model asks for
  • Calculate accepts only digits and + - * / ( ) . and spaces, then evaluates with DataTable.Compute
• Services/AgentService.cs
  • RunAsync: streaming agent loop, max 6 steps
  • System prompt: search before answering, cite file and page, use calculate for maths, say "I couldn't find that in your documents"
  • ToolCallAccumulator rebuilds streamed tool calls
  • Tool errors are sent back to the model so it can recover
  • AgentMessage and AgentEvent records (tool_call, tool_result, token)
• Services/DocumentService.cs
  • New SearchAllAsync: search all PDFs, or one by file name
  • New DocHit record: file name, page, text, score
• Controllers/AgentV1Controller.cs
  • POST api/AgentV1/stream (Server-Sent Events)
  • Streams tool calls, tool results and tokens, then [DONE]
• Program.cs: AgentTools and AgentService registered as singletons

Frontend (dotnetai-chat)

• src/api/agentStream.js: reads the SSE stream chunk by chunk
• AgentPage.jsx and Agent.css: chat with a live tool trace and a Stop button
• Root.jsx: new Agent tab (all tabs keep their state)

RUN IT

1. Start Qdrant in Docker (ports 6333 and 6334)
2. Run DotNetAI.API (https://localhost:7036)
3. In dotnetai-chat: npm install, then npm run dev
4. Open http://localhost:5173, upload a PDF in the Documents tab
5. Ask in the Agent tab, for example:
   "I travel for 5 nights. What's the most I can spend on hotel plus 5 days of meals?"

REQUIREMENTS

• .NET 10 SDK, Node.js
• Azure OpenAI deployments: gpt-4.1 (chat) and text-embedding-ada-002 (embeddings)
• Qdrant (Docker)
• ep14 code (DocumentService, Documents tab)

NOTES

• The agent can only use read-only tools. EP16 attacks this agent and hardens it.
• Always check an AI answer against the source PDF. The agent cites the file and page.
• The route is api/AgentV1/stream. Using api/Agent/stream returns 404.

NEXT: EP16 AI Red Teaming

Episode 14 – AI Document Analyzer: Chat with Your PDFs (RAG + Qdrant + React)

📄 Episode 14 – AI Document Analyzer: Chat with Your PDFs

Upload any PDF, ask questions about it, and get streamed answers with page citations — built with .NET, Azure OpenAI, Qdrant and React.
If the answer isn't in the document, the AI says so: "I couldn't find that in this document."

🎥 Watch the episode:
📺 Full series playlist:

---

🚀 What's New in This Release

Backend — DotNetAI.API

• PdfPig added — reads PDF text page by page in pure .NET
• Services/DocumentService.cs (new)
  • ExtractPages — PDF → text, keeping each page number
  • ChunkPages — ~1000-character chunks with 200-character overlap, ending on a sentence where possible
  • IngestPdfAsync — batch embeddings (16 chunks per call) → upsert into Qdrant
  • EnsureCollectionAsync — creates the pdf-documents collection (1536 dims, cosine) + documentId payload index
  • SearchAsync — vector search filtered to one document (MatchKeyword("documentId", id))
  • StreamAnswerAsync — grounded prompt: answer only from sources, cite [p. n], refuse when not found
  • DeleteAsync — removes the document and all its vectors
• Controllers/DocumentsController.cs (new)

Method	Route	Purpose
POST	/api/Documents	Upload a PDF (multipart/form-data, max 20 MB)
GET	/api/Documents	List uploaded documents
DELETE	/api/Documents/{id}	Delete a document and its vectors
POST	/api/Documents/{id}/ask/stream	Ask a question — SSE stream: sources event, then token events, then [DONE]

• Program.cs — registers DocumentService as a singleton
• appsettings.json — new setting Qdrant:PdfCollectionName = pdf-documents

Frontend — dotnetai-chat (React + Vite)

• src/api/docApi.js (new) — upload, list, delete and a stream reader for { type, ... } events
• src/DocumentsPage.jsx + src/Documents.css (new) — upload panel, document list, per-document chat, page-citation chips, Stop button
• src/Root.jsx + src/Root.css (new) — 💬 Chat / 📄 Documents tabs (each tab keeps its state)
• src/main.jsx — now renders <Root /> instead of <App />

---

🧠 How It Works

---

⚙️ Prerequisites

• .NET 10 SDK, Node.js (for the React app)
• Azure OpenAI deployments: gpt-4.1 (chat) and text-embedding-ada-002 (embeddings)
• Qdrant running locally:

  docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant

The .NET client uses gRPC on 6334; the dashboard is at http://localhost:6333/dashboard

• Keys set with user-secrets (never commit them):

  dotnet user-secrets set "AzureOpenAI:ApiKey" "<your-key>"

▶️ Run It

# API
cd DotNetAI.API
dotnet run            # https://localhost:7036/scalar

# React app
cd dotnetai-chat
npm install
npm run dev           # http://localhost:5173 → Documents tab

🧪 Try These Questions (sample handbook PDF)

• "How many days of annual leave do I get?" → 24 days [p. 3]
• "What's the hotel limit when I travel?" → ₹6,000 per night [p. 4]
• "What is the CEO's salary?" → "I couldn't find that in this document."

---

📝 Notes

• The document list is kept in memory and resets when the API restarts; the vectors stay in Qdrant. Saving to a database comes in Phase 4.
• Scanned (image-only) PDFs have no text layer and return a clear 400 error — OCR is out of scope for this episode.
• If MatchKeyword isn't found, add using static Qdrant.Client.Grpc.Conditions;

⏭️ Next Episode

AI Red Teaming — attacking this app with prompt injection hidden inside a PDF, and defending against it.

---

⭐ If this helped, star the repo and subscribe to Sandeep | AI Solutions (@Aiwithsandeep) for the rest of the series.

Episode 13 – I Built a ChatGPT Clone with React & .NET 🤯 | Full-Stack AI Chat App | EP13

🚀 EP03 is LIVE! Build a Full-Stack AI Application with .NET and Angular

Ready to take your AI development skills to the next level? In Episode 13 of the Complete .NET AI Developer Series (2026), we bring the backend and frontend together to build a full-stack AI application.

💻 Learn how to connect your .NET Web API with a frontend and build an end-to-end AI application.

🎯 What you'll learn:

• Build a full-stack application using .NET and React
• Connect the frontend with the backend API
• Integrate AI capabilities into the application
• Understand the end-to-end flow of a full-stack AI solution

🔥 Watch EP03 now and continue your journey toward becoming a .NET AI Developer!

👉 Watch here: https://www.youtube.com/watch?v=Kw7JrsYaqtc

📌 Subscribe to AI With Sandeep for practical tutorials on .NET, Azure OpenAI, Semantic Kernel, and AI engineering.

#DotNet #FullStackDevelopment #AI #AzureOpenAI #Angular #DotNetAI #AITutorial

Episode 12 – Model Context Protocol (MCP) with .NET

🚀 Episode 12 – Model Context Protocol (MCP) with .NET

Welcome to Episode 12 of the Complete .NET AI Developer Series (2026)!

In this episode, we introduce the Model Context Protocol (MCP) and explore how AI applications can connect with external tools and services.

Instead of building custom integrations for every AI application, MCP provides a standardized way for AI systems to discover and interact with tools.

📌 What's Included

• Introduction to Model Context Protocol (MCP)
• Why MCP matters for AI applications
• MCP Client vs MCP Server
• Understanding MCP tools
• Building an MCP Server with .NET
• Creating MCP tools
• Connecting AI applications to MCP
• Tool discovery and execution
• Working with multiple MCP tools
• Understanding the MCP architecture
• Practical MCP implementation with .NET

🛠 Technologies Used

• .NET
• C#
• ASP.NET Core
• Model Context Protocol (MCP)
• MCP Server
• MCP Client
• MCP Tools
• Azure OpenAI
• Semantic Kernel
• AI Agents
• Tool Calling
• Generative AI

🎥 Watch the Episode

[Add YouTube Video Link]

📺 Complete .NET AI Developer Series

https://www.youtube.com/playlist?list=PLF4drO8z96Rc

📂 Repository

https://github.com/sandeeppatil-newvision/Complete-DotNet-AI-API

🚀 What's Next?

Continue the Complete .NET AI Developer Series to learn how to build production-ready AI applications using .NET, Azure OpenAI, AI Agents, RAG, Vector Databases, MCP and more.

📌 Release Information

Episode: 12
Topic: Model Context Protocol (MCP)
Framework: .NET
Language: C#

---

⭐ If this episode helped you, consider starring the repository and sharing the series with other .NET developers learning AI.

Episode 11 – Function Calling with Azure OpenAI SDK

🚀 Episode 11 – Function Calling with Azure OpenAI SDK

Welcome to Episode 11 of the Complete .NET AI Developer Series (2026).

In this episode, we'll learn how to implement Function Calling with the Azure OpenAI SDK and understand how an AI model can decide when it needs to call a function to complete a user's request.

🎯 What's Included

• What is Function Calling?
• How Function Calling works
• Azure OpenAI SDK setup
• Define functions/tools for the AI model
• Send tool definitions to Azure OpenAI
• Detect tool calls from the model
• Execute functions in .NET
• Send tool results back to the model
• Generate the final AI response
• Build a complete Function Calling workflow

📺 Watch the Video

[Add EP11 YouTube URL]

📚 Playlist

https://www.youtube.com/playlist?list=PLF4drO8z96Rc

💻 Repository

https://github.com/sandeeppatil-newvision/Complete-DotNet-AI-API

---

⭐ If this project helps you, please Star the repository and Subscribe to the YouTube channel.

Episode 10 – Vector Databases with .NET — Qdrant VS Azure AI Search

🚀 Episode 10 – Vector Databases with .NET — Qdrant VS Azure AI Search

In this episode of the Complete .NET AI Developer Series (2026), we explore vector databases, embeddings, and vector search using Qdrant and Azure AI Search.

🎯 What's Included

• What are Vector Databases?
• Understanding Embedding Models
• Document-to-Embedding workflow
• Qdrant vector ingestion
• Qdrant vector search
• Azure AI Search ingestion
• Azure AI Search vector search
• Qdrant VS Azure AI Search
• When to use Qdrant vs Azure AI Search

📺 Watch the Video

[Add EP10 YouTube URL]

📚 Playlist

https://www.youtube.com/playlist?list=PLF4drO8z96Rc

💻 Repository

https://github.com/sandeeppatil-newvision/Complete-DotNet-AI-API

---

⭐ If this project helps you, please Star the repository and Subscribe to the YouTube channel.

Episode 09 – Build Your First AI Agent with Multi-Tool Orchestration

🤖 Episode 09 – Build Your First AI Agent with Multi-Tool Orchestration

Welcome to the ninth official release of the Complete .NET AI Developer Series (2026).

In this episode, we're moving beyond traditional AI chatbots and building our first AI Agent using .NET and Semantic Kernel.

A traditional chatbot primarily generates responses.

An AI Agent can go further.

It can understand a user's request, determine what actions are required, select the appropriate tools, execute multiple functions, and combine the results into an intelligent response.

In this release, we'll explore how Semantic Kernel enables AI Agents to orchestrate multiple tools dynamically using plugins and function calling.

---

🚀 What You'll Build

A multi-tool AI Agent capable of:

🧠 Understanding user intent

🔧 Selecting the appropriate tool

⚡ Executing multiple functions

🔄 Orchestrating tool responses

🤖 Generating an intelligent final answer

---

📌 What's Included

✅ Introduction to AI Agents

✅ AI Chatbot vs AI Agent

✅ Understanding Agentic AI

✅ Create your first AI Agent using .NET

✅ Configure Semantic Kernel

✅ Create Semantic Kernel Plugins

✅ Register multiple tools

✅ Enable AI-driven tool selection

✅ Automatic Function Calling

✅ Multi-Tool Orchestration

✅ Build an intelligent task execution workflow

---

🏗️ AI Agent Architecture

                USER REQUEST
                     │
                     ▼
                🤖 AI AGENT
                     │
          Understand User Intent
                     │
                     ▼
             Decide Required Tools
                     │
          ┌──────────┼──────────┐
          ▼          ▼          ▼
       🔧 Tool 1   🔧 Tool 2   🔧 Tool 3
          │          │          │
          └──────────┼──────────┘
                     ▼
                Tool Results
                     │
                     ▼
                🤖 AI AGENT
                     │
                     ▼
          Intelligent Final Response

Episode 08 – Streaming AI Responses in .NET

🚀 Episode 08 – Streaming AI Responses in .NET

Welcome to the eighth official release of the Complete .NET AI Developer Series (2026).

In this episode, we implement AI response streaming to create a faster and more interactive chat experience.

Instead of waiting for the AI model to generate the complete response, streaming allows the application to receive and display response chunks as they become available.

This approach creates a ChatGPT-style user experience and improves the perceived performance of AI applications.

This release builds upon the conversation history and AI memory implementation from Episode 07.

---

📌 What's Included

✅ Introduction to AI Streaming

✅ Traditional Responses vs Streaming Responses

✅ Configure Azure OpenAI streaming

✅ Implement streaming responses in .NET

✅ Use asynchronous streams

✅ Process response chunks in real time

✅ Build a ChatGPT-style AI experience

✅ Handle streaming in ASP.NET Core

✅ Improve AI application responsiveness

---

🎯 Technologies Used

• .NET
• C#
• ASP.NET Core
• Azure OpenAI
• OpenAI
• AI Streaming
• Async Streams
• Server-Sent Events (SSE)
• Real-Time Applications

---

📺 Watch Episode 08

Streaming AI Responses in .NET (2026) | Build Real-Time Chat Like ChatGPT | EP08

👉 https://www.youtube.com/watch?v=JzhCOm07sYM

---

📚 Complete .NET AI Developer Series

https://www.youtube.com/playlist?list=PLF4drO8z96Rc

---

💻 Repository

https://github.com/sandeeppatil-newvision/Complete-DotNet-AI-API

---

🚀 What's Next?

In Episode 09, we'll explore Vector Databases, Embeddings, and Vector Search.

You'll learn:

• What embeddings are
• How text is converted into vectors
• How vector similarity works
• Semantic Search vs Keyword Search
• How vector databases support RAG applications

---

📦 Release Information

Release Version: v1.7.0

Series: Complete .NET AI Developer Series (2026)

Episode: 08

---

⭐ If this repository helped you, please consider giving it a Star.

If you enjoyed the tutorial, don't forget to Like, Subscribe, and Share the Complete .NET AI Developer Series (2026).

Happy Coding! 🚀