Forem: CodeStreet

Why DevUI Is a Game Changer for .NET Developers? Microsoft Agent Framework DevUI Demo.

CodeStreet — Fri, 06 Feb 2026 14:51:24 +0000

Introduction

Building and testing AI agents shouldn't require building a complex user interface from scratch. That's where DevUI comes in - a powerful development tool that's part of the Microsoft Agent Framework for .NET 10.

In this comprehensive guide, you'll learn how to set up, configure, and test multiple AI agents with different personas using a simple web interface.

Whether you're building chatbots, AI assistants, or conversational applications, DevUI provides an intuitive playground similar to Swagger UI but designed specifically for AI agents.

Watch the video tutorial above for a complete walkthrough, or continue reading for the step-by-step guide.

What is DevUI?

DevUI is a development interface included with the Microsoft Agent Framework that enables developers to:

Test AI agents in real-time during development
Manage conversations with multiple agents simultaneously
Debug agent responses without building a production UI
Prototype quickly before implementing custom interfaces
Validate system prompts and agent behavior instantly

Think of DevUI as your AI agent playground - a tool that accelerates development by providing immediate visual feedback on your agents' behavior and responses.

Key Benefits

Zero UI Code Required: Test agents immediately without building React, Angular, or Blazor interfaces
Multi-Agent Support: Switch between different agents in the same session
Conversation History: Built-in conversation management and history tracking
Development-Only: Easily disable for production deployments
OpenAI Compatible: Works with any OpenAI-compatible endpoint including Azure OpenAI, GitHub Models, and more

Prerequisites

Before we begin, ensure you have:

.NET 10 SDK installed (Download here)
Visual Studio 2026 or VS Code with C# extensions
Basic knowledge of ASP.NET Core
API access to an OpenAI-compatible service (OpenAI, Azure OpenAI, GitHub Models, etc.)
API Key for your chosen AI service (you can use GitHub Copilot)

Required NuGet Packages

For this tutorial, you'll need the following packages:

dotnet add package Microsoft.Agents.AI.DevUI
dotnet add package Microsoft.Agents.AI.Hosting
dotnet add package Microsoft.Extensions.AI
dotnet add package OpenAI

Package Overview

Package	Purpose
`Microsoft.Agents.AI.DevUI`	Provides the DevUI web interface
`Microsoft.Agents.AI.Hosting`	Agent hosting infrastructure and registration
`Microsoft.Extensions.AI`	Core AI abstractions and interfaces
`OpenAI`	OpenAI SDK for connecting to AI models

Project Setup

Let's create a new ASP.NET Core application:

dotnet new web -n DevUIDemo
cd DevUIDemo

Add the required packages as shown above, and we're ready to start coding!

Implementation Guide

Step 1: Configure the ChatClient

Open Program.cs and set up your application builder and chat client:

using Microsoft.Agents.AI.DevUI;
using Microsoft.Agents.AI.Hosting;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

// Configure ChatClient with your AI service
IChatClient chatClient = new ChatClient(
    "gpt-4o",  // Model name
    new ApiKeyCredential(Environment.GetEnvironmentVariable("OPENAI_API_KEY")!), 
    new OpenAIClientOptions() { 
        Endpoint = new Uri("https://models.github.ai/inference") 
    }
).AsIChatClient();

?? Security Best Practice: Always use environment variables or secure configuration for API keys. Never hardcode credentials in your source code!

Step 2: Register Required Services

Add the necessary services to your dependency injection container:

// Register the chat client for agent use
builder.Services.AddChatClient(chatClient);

// Register OpenAI response handling
builder.Services.AddOpenAIResponses();

// Register conversation state management
builder.Services.AddOpenAIConversations();

These services provide:

AddChatClient: Registers the chat client for dependency injection
AddOpenAIResponses: Handles OpenAI API response processing
AddOpenAIConversations: Manages conversation state and history

Step 3: Create AI Agents

Now comes the fun part - creating your AI agents! The framework makes this incredibly simple:

// Create a Comic Book Guy agent from The Simpsons
builder.AddAIAgent(
    "Comic Book Guy", 
    "You are Comic Book Guy from The Simpsons. Respond with his characteristic " +
    "condescending tone, vast knowledge of pop culture, and frequent use of phrases " +
    "like 'Worst [blank] ever!' Be pedantic and superior in your responses."
);

// Create a YouTube channel advisor agent
builder.AddAIAgent(
    "CodeStreet Agent", 
    "You are an experienced YouTube content strategist specializing in tech channels. " +
    "Provide actionable advice on content ideas, SEO, thumbnails, audience engagement, " +
    "and growth strategies for programming and technology channels."
);

** Pro Tip**: Your system prompt is crucial! Be specific about the agent's personality, knowledge domain, and response style for best results.

Step 4: Configure Endpoints and Run

Finally, build the app and register the DevUI endpoints:

WebApplication app = builder.Build();

// Register OpenAI API endpoints (required for DevUI)
app.MapOpenAIResponses();
app.MapOpenAIConversations();

// Register DevUI endpoint
app.MapDevUI();

app.Run();

Complete Code Example

Here's the complete Program.cs:

using Microsoft.Agents.AI.DevUI;
using Microsoft.Agents.AI.Hosting;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

IChatClient chatClient = new ChatClient(
    "gpt-4o", 
    new ApiKeyCredential(Environment.GetEnvironmentVariable("OPENAI_API_KEY")!), 
    new OpenAIClientOptions() { 
        Endpoint = new Uri("https://models.github.ai/inference") 
    }
).AsIChatClient();

builder.Services.AddChatClient(chatClient);
builder.Services.AddOpenAIResponses();
builder.Services.AddOpenAIConversations();

builder.AddAIAgent("Comic Book Guy", 
    "You are comic-book guy from The Simpsons");

builder.AddAIAgent("CodeStreet Agent", 
    "You are an agent who gives suggestions for youtube channels");

WebApplication app = builder.Build();
app.MapOpenAIResponses();
app.MapOpenAIConversations();
app.MapDevUI();
app.Run();

Running Your Application

Start the Application

Run your application using:

dotnet run

Or press F5 in Visual Studio.

Access DevUI

Once the application starts, navigate to:

http://localhost:[PORT]/devui

Replace [PORT] with the port number shown in your console output (typically 5000 or 5173).

Testing Your Agents

Select an Agent: On the left sidebar, you'll see both agents listed
Start a Conversation: Click on an agent to begin chatting
Send Messages: Type your message in the input box
View Responses: Watch your agent respond in character
Switch Agents: Click another agent to test different personas
View History: All conversation history is maintained automatically

Resources and Next Steps

Official Documentation

Further Learning

Advanced Agent Patterns: Explore multi-agent conversations and orchestration
Function Calling: Enable agents to interact with external systems
Custom UI Development: Build production interfaces using React or Blazor
Azure Deployment: Deploy agents to Azure App Service or Container Apps

Sample Code Repository

Find the complete source code for this tutorial: Source Code

Conclusion

DevUI provides a powerful, efficient way to develop and test AI agents in .NET 10 without the overhead of building custom interfaces. By following this guide, you've learned:

How to set up the Microsoft Agent Framework
Configure OpenAI-compatible chat clients
Create multiple AI agents with distinct personas
Use DevUI for rapid testing and iteration
Implement best practices for security and deployment
Troubleshoot common issues

The Microsoft Agent Framework, combined with DevUI, dramatically reduces the time from concept to functional AI agents. Whether you're building chatbots, virtual assistants, or complex multi-agent systems, these tools provide the foundation for rapid, efficient development.

Support me!

If you found this guide helpful, make sure to check out the accompanying YouTube video tutorial where I walk you through the process visually. Don’t forget to subscribe to my channel for more amazing tutorials!

I would appreciate it if you could buy me a coffee.

Feel free to leave your questions, comments, or suggestions below. Happy coding!

Run Large Language Models Locally in Docker | How to Use Qwen 3 with .NET Semantic Kernel?

CodeStreet — Fri, 19 Sep 2025 17:41:39 +0000

AI development is moving fast — but one thing that still slows developers down is relying on cloud APIs.

What if you could run powerful LLMs (Large Language Models) locally, just like spinning up a Docker container?

In this blog, I’ll show you how to:

Run LLMs locally using Docker’s Model Runner
Pull and run the Qwen 3 model
Connect it to a .NET console app with Semantic Kernel

Let’s get started! 🚀

For a more in-depth walk-through, be sure to watch my YouTube video, where I demonstrate everything step by step!

🔹 Why Run LLMs Inside Docker?

Docker is already the standard for packaging and running applications. Now, with Docker Model Runner, you can:

Pull AI models just like Docker images
Run models locally without cloud APIs
Expose OpenAI-compatible APIs to integrate seamlessly into apps

This means you can test, prototype, and even deploy AI workloads locally — cost-free and private.

🔹 Step 1: Enable Docker Model Runner

Open Docker Desktop → Settings → AI Features and enable:

✅ Docker Model Runner
✅ Host-side TCP support (on port 12434)

This allows models to expose REST APIs you can call from your apps.

🔹 Step 2: Pull and Run Qwen 3 Model

Open your terminal and run:

# Pull the model
docker model pull qwen/qwen-3b

# Run the model
docker model run qwen/qwen-3b

You’ll see an interactive chat session where you can ask questions.

Example:

> Hello
< Hi! How can I assist you today?

🔹 Step 3: Use REST API

The model exposes endpoints on:

http://localhost:12434/v1

For example, to list available models:

curl http://localhost:12434/models

You’ll see details of Qwen 3 and any other models you’ve pulled.

🔹 Step 4: Connect with Semantic Kernel (.NET)

The best part is — you don’t need to rewrite your app.

Semantic Kernel already works with OpenAI APIs, and since Docker exposes the same structure, all you do is change the base URL.

Install packages

dotnet add package Microsoft.SemanticKernel

Create a Console App

using Microsoft.SemanticKernel;

var builder = Kernel.CreateBuilder();
builder.AddOpenAIChatCompletion(
    modelId: "qwen/qwen-3b",
    apiKey: "dummy", // not required for local
    endpoint: new Uri("http://localhost:12434/v1") // Docker endpoint
);

var kernel = builder.Build();

var result = await kernel.InvokePromptAsync("Explain Docker in simple terms.");
Console.WriteLine(result);

That’s it! Your .NET app is now talking to Qwen 3 inside Docker, through Semantic Kernel.

🔹 Why This Matters

🖥️ Local-first AI → Run LLMs without internet or billing
🔒 Privacy → Your data never leaves your machine
⚡ Developer-friendly → Same SDKs, same APIs, just a different base URL
🔗 Drop-in replacement → Move between local and cloud seamlessly

✅ Final Thoughts

Running AI models is now as easy as running containers.

With Docker Model Runner, you can:

Pull Qwen 3
Run it locally
Connect it to .NET apps with Semantic Kernel

This opens up endless possibilities for building intelligent apps without cloud dependencies.

👉 What model are you planning to run first with Docker?

Drop a comment — I’d love to know!

How to Build Your First AI Agent with Semantic Kernel & DeepSeek R1 Locally with Ollama

CodeStreet — Sat, 16 Aug 2025 02:40:49 +0000

In this post, we will create our first AI Agent using the Microsoft Agentic Framework of Semantic Kernel and DeepSeek R1, running locally on Ollama.

We’ll walk step by step through setting up a Semantic Kernel agent that leverages DeepSeek R1 via Ollama, showing you how to install the tools, configure the model locally, and connect everything together. By the end, you’ll have a working AI YouTube Title Generator agent running entirely on your machine locally—no cloud subscription required.

What You Will Learn

How to Get Started with DeepSeek R1
How to Use Ollama for running local models
How to install and start running the DeepSeek R1 model
How to Use Semantic Kernel in C#

1. Prerequisites

Visual Studio 2022+ (with .NET 9 SDK installed) .NET 9 is still in preview, so ensure that you have the preview SDK installed.
Ollama (for managing and running local models)
DeepSeek1.5b Model

2. Installing Ollama

Ollama is a platform or tool (specific details may vary depending on the context) that allows users to interact with large language models (LLMs) locally. It simplifies the process of deploying and running LLMs like LLaMA, Phi, DeepSeek R1, or other open-source models.

To install Ollama, visit its official website https://ollama.com/download and install it on your machine.

3. Installing DeepSeek R1

DeepSeek's first-generation reasoning models have comparable performance to OpenAI-o1, including six dense models distilled from DeepSeek-R1 based on Llama and Qwen.

On the Ollama website click on Models and click on deepseek-r1 and choose 1.5b parameter option

Open Command Prompt and run the command below.

ollama run deepseek-r1:1.5b

It will download the model and start running automatically.

Once done, verify that the model is available

ollama list

That’s it! We’re ready to integrate DeepSeek locally.

4. Creating .NET Console Application

Launch Visual Studio
Make sure .NET 9 is installed.
Create a New Project
File → New → Project…
Pick Console App with .NET 9.
Name Your Project
e.g., DeepSeekDemoApp or any name you prefer.
Target Framework Check
Right-click on your project → Properties.
Set Target Framework to .NET 9.

5. Integrating DeepSeek R1 with Semantic Kernel

While you could call DeepSeek via direct HTTP requests to Ollama, using Semantic Kernel offers a powerful abstraction for prompt engineering, orchestration, and more.

Add Necessary NuGet Packages

<ItemGroup>
  <PackageReference Include="Microsoft.SemanticKernel" Version="1.61.0" />
  <PackageReference Include="Microsoft.SemanticKernel.Agents.Core" Version="1.61.0" />
  <PackageReference Include="Microsoft.SemanticKernel.Connectors.Ollama" Version="1.61.0-alpha" />
</ItemGroup>

6. Complete code

Program.cs:

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;

var builder = Kernel.CreateBuilder().AddOllamaChatCompletion("deepseek-r1:1.5b",
    new HttpClient
    {
        BaseAddress = new Uri("http://localhost:11434"),

    });

Kernel kernel = builder.Build();

Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Welcome to TheCodeStreet - AI YouTube Title Generator!");
Console.WriteLine("------------------------------------------------------");
Console.ResetColor();
Console.WriteLine("Provide the keyword to generate title:");
string keyword = Console.ReadLine()?? "";


string instructions = """
You are a professional YouTube content strategist and SEO expert.

🎯 Keyword or Topic: {{keyword}}

Your job is to generate 5 click-worthy and SEO-friendly YouTube video titles based on a given topic or keyword.

📌 Guidelines for Generating Titles:

-- Keep them under 70 characters if possible.
-- Include emotional triggers, power words, or numbers (e.g., “Top 5”, “You Won’t Believe…”).
-- Use strong action verbs (e.g., “Boost”, “Master”, “Avoid”, “Unlock”).
-- Make titles engaging and curiosity-driven (clickbait style but still relevant).
-- Include the keyword or topic for SEO.
-- Avoid duplicate or overly similar titles.

💡 Return only the titles in a numbered list format like:
1. Title one...
2. Title two...
3. ...
""";

 instructions = instructions
    .Replace("{{keyword}}", keyword);

ChatCompletionAgent agent =
    new()
    {
        Name = "TitleGeneratorAgent",
        Instructions = instructions,
        Kernel = kernel,
    };

Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Generating titles...");
Console.WriteLine("------------------------------------------------------");
await foreach (AgentResponseItem<StreamingChatMessageContent> response
    in agent.InvokeStreamingAsync())
{
    Console.Write(response.Message.Content.Replace("**",""));
}
Console.ResetColor();
Console.ReadKey();

7. Running & Testing

Ensure Ollama is Running

-Some systems auto-run Ollama; otherwise, start it

ollama run

Run Your .NET App

-Hit F5 (or Ctrl+F5) in Visual Studio.

-Watch for console output—

Support me!

I would appreciate it if you could buy me a coffee.

Feel free to leave your questions, comments, or suggestions below. Happy coding!

How to Create RAG using DeepSeek R1, Ollama & Semantic Kernel .NET

CodeStreet — Tue, 04 Mar 2025 06:20:59 +0000

Have you ever wanted to combine your own data with AI to get instant insights? In this blog post, we’ll explore exactly how to do that by building a Retriever-Augmented Generation (RAG) application using DeepSeek R1, Ollama, and Semantic Kernel. Our example scenario is a simple expense manager that tracks daily spending and lets AI answer natural-language questions like:

"How much did I spend on coffee?"
"Which day did I spend the most money overall?"
"Which day did I spend the least money overall?"

By the end of this post, you’ll see how you can load your own data (e.g., a text file, PDF documents, or others) and perform natural language Q&A over it using these tools.

For a more in-depth walk-through, be sure to watch my YouTube video, where I demonstrate everything step by step!

What is RAG (Retriever-Augmented Generation)?

Retriever-Augmented Generation (RAG) is an approach that combines:

A Retriever: A system/component to fetch relevant documents or pieces of data from a larger collection (e.g., your expense records).
A Language Model: A large language model (LLM) that can generate natural language responses based on prompts and retrieved context.

When you ask a question, RAG retrieves relevant snippets or documents from your dataset and uses them to ground the LLM’s response. This helps the AI give more accurate and context-aware answers by focusing on information you’ve provided. Essentially, you augment the AI’s knowledge by feeding it the specific data you care about.

Use Cases of RAG

Customer Support: Quickly retrieve knowledge base articles and feed them to an LLM for on-demand issue resolution.
Content Search: Search large text corpuses and summarize or answer queries about them.
Personal Knowledge Management: Organize personal notes or expense records, and use AI to query them or generate insights.
Finance and Expense Tracking: Like in our example, store transaction history, then ask AI to identify spending patterns, daily totals, or anomalies.

1. Prerequisites

Visual Studio 2022+ (with .NET 9 SDK installed) .NET 9 is still in preview, so ensure that you have the preview SDK installed.
Ollama (for managing and running local models)
DeepSeek1.5b Model

2. Installing Ollama

To install Ollama visit its official website https://ollama.com/download and install it on your machine.

3. Installing DeepSeek R1

DeepSeek's first-generation reasoning models with comparable performance to OpenAI-o1, including six dense models distilled from DeepSeek-R1 based on Llama and Qwen.

On the Ollama website click on Models and click on deepseek-r1 and choose 1.5b parameter option

Open Command Prompt and run the below command.

ollama run deepseek-r1:1.5b

It will download the model and start running automatically.

Once done, verify the model is available

ollama list

That’s it! We’re ready to integrate DeepSeek locally.

4. Creating .NET Console Application

Launch Visual Studio
Make sure .NET 9 is installed.
Create a New Project
File → New → Project…
Pick Console App with .NET 9.
Name Your Project
e.g., DeepSeekDemoApp or any name you prefer.
Target Framework Check
Right-click on your project → Properties.
Set Target Framework to .NET 9.

5. Integrating DeepSeek R1 with Semantic Kernel

While you could call DeepSeek via direct HTTP requests to Ollama, using Semantic Kernel offers a powerful abstraction for prompt engineering, orchestration, and more.

Add Necessary NuGet Packages

<ItemGroup>
  <PackageReference Include="Microsoft.KernelMemory.AI.Ollama" Version="0.97.250211.1" />
<PackageReference Include="Microsoft.KernelMemory.Core" Version="0.97.250211.1" />
  <PackageReference Include="Microsoft.SemanticKernel" Version="1.35.0" />
</ItemGroup>

Download Complete Project

6. Source Code

using Microsoft.KernelMemory;
using Microsoft.KernelMemory.AI.Ollama;

var config = new OllamaConfig
{
    Endpoint = "http://localhost:11434",
    TextModel = new OllamaModelConfig("deepseek-r1:1.5b", 131072),
    EmbeddingModel = new OllamaModelConfig("deepseek-r1:1.5b", 2048)
};

var memory = new KernelMemoryBuilder()
    .WithOllamaTextGeneration(config)
    .WithOllamaTextEmbeddingGeneration(config)
    .Build<MemoryServerless>();

Console.WriteLine("Processing document, please wait...");

await memory.ImportDocumentAsync("expenses.txt", documentId: "DOC001");

Console.WriteLine("Model is ready to take questions\n");

while(await memory.IsDocumentReadyAsync("DOC002"))
{

    Console.WriteLine("Ask your questions\n");

    var question = Console.ReadLine();

    var answer = await memory.AskAsync(question);

    Console.WriteLine(answer.Result);

    Console.WriteLine("\n Sources:");

    foreach(var x in answer.RelevantSources)
    {
        Console.WriteLine($" {x.SourceName} - {x.SourceUrl} - {x.Link}");
    }

}

Daily expense data

Date        | Category       | Amount
------------|----------------|-------
2025-02-13  | Groceries      | 45.30
2025-02-13  | Transport      | 12.00
2025-02-14  | Coffee         | 4.50
2025-02-14  | Rent           | 800.00
2025-02-15  | Groceries      | 54.20
2025-02-16  | Entertainment  | 30.00
2025-02-16  | Transport      | 10.00
2025-02-17  | Bills          | 120.00
2025-02-17  | Coffee         | 3.75
2025-02-18  | Groceries      | 62.40

Save this info as expenses.txt, put it into the bin directory, and run the application.

Now you are good for asking some questions like:

“How much did I spend on coffee?”
“Which day did I spend the most money overall?”
“Which day did I spend the least money overall?”

The AI will use the embedded expense data to calculate or deduce answers. It should also list the sources (e.g., the document ID containing relevant info)

Support me

If you found this guide helpful, make sure to check out the accompanying YouTube video tutorial, in which I walk you through the process visually. Don’t forget to subscribe to my channel for more amazing tutorials!

I would appreciate it if you could buy me a coffee.

How to Build Blog Generator AI App Using Deep Seek R1 and Semantic Kernel in .NET9

CodeStreet — Thu, 06 Feb 2025 10:46:19 +0000

In this post, I’m excited to share the journey behind our latest project: building a blog generator AI app that harnesses the power of Deep Seek R1, Semantic Kernel, and .NET9. This blog serves as a companion to my YouTube video where I walk through the entire process step-by-step.

Introduction

Have you ever found yourself staring at a blank screen, struggling to come up with blog content? What if you could let AI do the heavy lifting and generate blog posts for you? In this tutorial, I'll show you how to build an AI-powered blog generator that not only speeds up content creation but also produces quality posts automatically.

What You'll Learn

Integrating Deep Seek R1: Learn how to leverage advanced search capabilities to gather relevant content and ideas.
Using Semantic Kernel: Discover how to orchestrate AI tasks for natural language processing and content generation.
Building with .NET9: See how .NET9 provides a robust framework for developing and deploying your AI application.
Step-by-Step Guidance: Follow a clear, concise guide that breaks down the process into manageable steps.

Why Build an AI-Powered Blog Generator?

Automating blog creation saves you time and effort, allowing you to focus on other aspects of your business or creative pursuits. This project not only demonstrates cutting-edge technology integration but also provides a scalable solution for content creators and developers alike.

Technologies at a Glance

Deep Seek R1: This tool helps in deep searching, ensuring your content is backed by extensive and relevant data.
Semantic Kernel: Acts as the brain behind content generation by processing natural language and orchestrating AI tasks.
.NET9: The latest iteration of .NET offers improved performance, modern features, and a great development experience for building robust applications.

1. Prerequisites

Visual Studio 2022+ (with .NET 9 SDK installed) .NET 9 is still in preview, so ensure that you have the preview SDK installed.
Ollama (for managing and running local models)
DeepSeek1.5b Model

2. Installing Ollama

To install Ollama visit its official website https://ollama.com/download and install it on your machine.

3. Installing DeepSeek R1

DeepSeek's first-generation reasoning models with comparable performance to OpenAI-o1, including six dense models distilled from DeepSeek-R1 based on Llama and Qwen.

On the Ollama website click on Models and click on deepseek-r1 and choose 1.5b parameter option

Open Command Prompt and run the below command.

ollama run deepseek-r1:1.5b

It will download the model and start running automatically.

Once done, verify the model is available

ollama list

That’s it! We’re ready to integrate DeepSeek locally.

4. Creating .NET Console Application

Launch Visual Studio
Make sure .NET 9 is installed.
Create a New Project
File → New → Project…
Pick Console App with .NET 9.
Name Your Project
e.g., DeepSeekDemoApp or any name you prefer.
Target Framework Check
Right-click on your project → Properties.
Set Target Framework to .NET 9.

5. Integrating DeepSeek R1 with Semantic Kernel

While you could call DeepSeek via direct HTTP requests to Ollama, using Semantic Kernel offers a powerful abstraction for prompt engineering, orchestration, and more.

Add Necessary NuGet Packages

<ItemGroup>
  <PackageReference Include="Codeblaze.SemanticKernel.Connectors.Ollama" Version="1.3.1" />
  <PackageReference Include="Microsoft.SemanticKernel" Version="1.35.0" />
</ItemGroup>

6. Code

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using Codeblaze.SemanticKernel.Connectors.Ollama;
using Microsoft.Extensions.DependencyInjection;

var builder = Kernel.CreateBuilder().AddOllamaChatCompletion("deepseek-r1:1.5b", "http://localhost:11434");

builder.Services.AddScoped<HttpClient>();

Kernel kernel = builder.Build();
var chatCompletionService = kernel.GetRequiredService<IChatCompletionService>();

string GetUserInput(string prompt)
{
    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine(prompt);
    Console.ForegroundColor = ConsoleColor.White;
    return Console.ReadLine();
}

string topic = GetUserInput("Tell me the topic for the blog");
string tone = GetUserInput("Provide blog tone");
int length = Convert.ToInt32(GetUserInput("Provide total blog length"));
string keywords = GetUserInput("Provide some keywords to target");

string prompt = $@"
Your_prompt
";

var blogResponse = await kernel.InvokePromptAsync(prompt);

Console.ForegroundColor = ConsoleColor.DarkCyan;

Console.WriteLine(blogResponse.ToString());

Console.WriteLine("Press enter to exit...");
Console.ReadLine();

Downlaod Complete Project

Generated Blog

It generates the blog into markdown format, which Dev.to and Github support, you can also easily convert it into WordPress formats.

# The Future of Social Media Marketing: Why It’s Revolutionizing Modern Business Strategies  

## The Rise of Social Media in the Modern World  

In an era where social media has taken center stage as a key tool for business growth, social media marketing has emerged as a transformative force. From connecting with customers and driving sales to engaging the public on every level, this platform is reshaping how businesses approach their communication strategies.  

## The Key Benefits of Social Media Marketing  

### 1. **Sustainable Social Media Strategy**  
One of the most significant advantages of social media marketing is its ability to break free from traditional marketing boundaries. By leveraging platforms like Instagram and Facebook, businesses can consistently build relationships with customers who may not be reachable through other channels. This strategy ensures that the brand remains relevant and effective in the face of ever-changing market conditions.  

### 2. **Increased Visibility & Reach**  
Social media is renowned for its global reach. Through consistent posting and interactive content, brands gain visibility beyond their local markets. For example, a small business might see its product appear on billions of Instagram stories or Facebook posts every day, creating a loyal audience that would be difficult to compete with in a traditional marketing campaign.  

### 3. **Targeted Audience Engagement**  
One of the most powerful tools of social media marketing is its ability to target specific audiences. By analyzing data from platforms like Instagram and Facebook, businesses can identify demographics and interests where they can create more effective campaigns. This targeted approach ensures that marketing efforts align with customer needs, leading to higher engagement and conversions.  

### 4. **Building a Social Following**  
Social media is not just about sharing content; it’s also about building a community around the brand. By engaging with followers regularly and responding to comments, businesses can establish trust and credibility. This follows can lead to long-term relationships with customers who are drawn to brands that value their connection and want to share their own.  

### 5. **Improved Customer Relationships**  
Social media marketing is about more than just selling a product. It’s also about fostering meaningful connections. By sharing personal stories, tips, and updates, businesses can connect deeply with their audience and strengthen long-term relationships. This creates loyalty and trust that can translate into repeat business.  

## Examples of Social Media Marketing in Action  

### Instagram Marketing: A Global Reach  
A small tech startup, *TechGenius*, used Instagram to launch its latest product line. They created content that highlighted the benefits of their innovation, connecting with customers across countries through consistent posting and interactive posts. This strategy not only brought their product to a global audience but also built a loyal following.  

### Facebook Marketing: Building a Community  
A retail store, *FashionFlix*, used Facebook to create a community around its products. By sharing behind-the-scenes content, engaging with customers, and participating in influencer collaborations, the brand established itself as knowledgeable and trustworthy. This not only helped sell their clothing but also fostered connections that could lead to word-of-mouth referrals.  

### A/B Testing on Social Media: Measuring Success  
Social media marketing often involves testing different strategies to determine what works best for a business. By running A/B tests on platforms like Instagram or Facebook, companies can see which content types resonate with their audience and adjust their marketing efforts accordingly. This data-driven approach ensures that marketing initiatives are effective and aligned with customer needs.  

## Tools & Platforms for Social Media Marketing  

From content creation tools to analytics platforms, there’s no shortage of resources available to businesses looking to improve their social media strategy. Platforms like Instagram, Facebook, and YouTube have built into them powerful tools for creating engaging posts, tracking engagement, and measuring performance. By utilizing these features effectively, businesses can maximize the impact of their social media marketing efforts.  

## The Ultimate Guide: Tips on Social Media Marketing  

### 1. **Content Creation**  
The foundation of any successful social media strategy is well-crafted content. Businesses should focus on creating engaging, relevant, and timely posts that resonate with their audience. Whether it’s showcasing a product, sharing tips for a task or discussing recent events, the right content can catch people’s attention and encourage action.  

### 2. **Engagement**  
Social media is not just about posting; it’s also about interacting with your audience. Regular updates and timely responses to comments and questions create a sense of connection and trust. This engagement not only helps build relationships but also reinforces the brand’s message, making customers more likely to return for future purchases.  

### 3. **Analytics**  
To maximize the effectiveness of social media marketing, businesses should track their performance through analytics tools. These tools allow them to measure the impact of their content, identify trends in their audience, and adjust their strategies accordingly. By staying data-driven, they can ensure that their efforts are aligned with customer needs and driving results.  

### 4. **Leverage Influencer Marketing**  
Influencers are a powerful tool in social media marketing. Businesses should engage with influencers to gain credibility and reach a wider audience. Collaborating with influencers or following them on platforms like Instagram can help establish authority and trust, leading to more engagement from their followers.  

### 5. **Stay Updated with Trends**  
Social media is a dynamic platform that evolves quickly. To stay ahead of the curve, businesses should be aware of new trends and tools available on platforms like Instagram, Facebook, and Twitter. Keeping their strategy updated ensures they remain relevant in a competitive market and can adapt to changing customer preferences.

Support me

I would appreciate it if you could buy me a coffee.

Conclusion

Building a blog generator AI app is not only an exciting project but also a practical solution for anyone looking to enhance their content creation process. I hope this guide inspires you to explore the possibilities of AI in your projects. If you have any questions or ideas, feel free to leave a comment below!

Feel free to leave your questions, comments, or suggestions below. Happy coding!

How To Use DeepSeek With .NET 9 | Hands-On With DeepSeek R1, Semantic Kernel & C#

CodeStreet — Sat, 01 Feb 2025 07:40:23 +0000

In this post, we will integrate DeepSeek R1 into a .NET 9 using Semantic Kernel. If you’re looking to get started with DeepSeek models locally, this hands-on guide is for you.

What You Will Learn

How to Get Started with DeepSeek R1
How to Use Ollama for running local models
How to install and start running the DeepSeek R1 model
How to Use Semantic Kernel in C#

1. Prerequisites

Visual Studio 2022+ (with .NET 9 SDK installed) .NET 9 is still in preview, so ensure that you have the preview SDK installed.
Ollama (for managing and running local models)
DeepSeek1.5b Model

2. Installing Ollama

To install Ollama visit its official website https://ollama.com/download and install it on your machine.

3. Installing DeepSeek R1

DeepSeek's first-generation reasoning models with comparable performance to OpenAI-o1, including six dense models distilled from DeepSeek-R1 based on Llama and Qwen.

On the Ollama website click on Models and click on deepseek-r1 and choose 1.5b parameter option

Open Command Prompt and run the below command.

ollama run deepseek-r1:1.5b

It will download the model and start running automatically.

Once done, verify the model is available

ollama list

That’s it! We’re ready to integrate DeepSeek locally.

4. Creating .NET Console Application

Launch Visual Studio
Make sure .NET 9 is installed.
Create a New Project
File → New → Project…
Pick Console App with .NET 9.
Name Your Project
e.g., DeepSeekDemoApp or any name you prefer.
Target Framework Check
Right-click on your project → Properties.
Set Target Framework to .NET 9.

5. Integrating DeepSeek R1 with Semantic Kernel

While you could call DeepSeek via direct HTTP requests to Ollama, using Semantic Kernel offers a powerful abstraction for prompt engineering, orchestration, and more.

Add Necessary NuGet Packages

<ItemGroup>
  <PackageReference Include="Codeblaze.SemanticKernel.Connectors.Ollama" Version="1.3.1" />
  <PackageReference Include="Microsoft.SemanticKernel" Version="1.35.0" />
</ItemGroup>

6. Complete code

The Semantic Kernel can use a custom connector to talk to local endpoints. For simplicity, we’ll outline a sample approach:

Program.cs:

using Codeblaze.SemanticKernel.Connectors.Ollama;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.SemanticKernel;

var builder = Kernel.CreateBuilder().AddOllamaChatCompletion("deepseek-r1:1.5b", "http://localhost:11434");

builder.Services.AddScoped<HttpClient>();
var kernel = builder.Build();

while (true)
{
    string input = "";
    Console.WriteLine("Ask anything to Deepseek");
    input = Console.ReadLine();
    var response = await kernel.InvokePromptAsync(input);
    Console.WriteLine($"\nDeepseek: {response}\n");
}

7. Running & Testing

Ensure Ollama is Running

-Some systems auto-run Ollama; otherwise, start it

ollama run

Run Your .NET App

-Hit F5 (or Ctrl+F5) in Visual Studio.

-Watch for console output—

Support me!

I would appreciate it if you could buy me a coffee.

Feel free to leave your questions, comments, or suggestions below. Happy coding!

Create Your First AI-Powered C# App with Semantic Kernel: A Step-by-Step Guide

CodeStreet — Tue, 10 Dec 2024 16:53:47 +0000

Welcome to the exciting world of artificial intelligence (AI) development with C#! In this comprehensive guide, you'll learn how to build your first AI-powered application using Semantic Kernel, a powerful toolkit that seamlessly integrates advanced AI models with popular programming languages like C#.

Whether you're a seasoned developer looking to dive into AI or a beginner eager to enhance your C# skills, this tutorial is designed to help you get started quickly and efficiently.

What is Semantic Kernel?
Prerequisites
Setting Up Your Development Environment
Building Your First AI-Powered C# Application
- Step 1: Create a New C# Console Application
- Step 2: Install Semantic Kernel
- Step 3: Integrate Semantic Kernel into Your Project
- Step 4: Implementing the Chatbot Logic
- Step 5: Running and Testing Your Application
Enhancements and Next Steps
Conclusion

What is Semantic Kernel?

Semantic Kernel is a robust toolkit (SDK) developed to bridge the gap between advanced AI models and conventional programming languages like C#, Python, and Java.

By leveraging Semantic Kernel, developers can seamlessly integrate powerful AI capabilities from platforms such as OpenAI, Azure OpenAI, and Hugging Face into their applications with minimal effort.

Key Features:

Easy Integration: Connects AI models with C#, Python, Java, and more.
Plugin System: Allows developers to create and link small functionalities called plugins with just a few lines of code.
AI-Powered Automation: Utilizes AI to automatically organize and manage these plugins, enabling the creation and execution of plans to achieve specific goals.

Why Choose Semantic Kernel?

Streamlined Development: Quickly build complex AI applications by chaining plugins effortlessly.
Intelligent Planning: Let AI handle the orchestration of tasks, making your development process smarter and more efficient.
Versatility: Supports multiple AI models and programming languages, providing flexibility for various projects.

Prerequisites

Before diving into building your AI-powered C# application, ensure you have the following:

Basic Knowledge of C#: Familiarity with C# programming and the .NET framework.
Development Environment:
- Visual Studio 2022 or later installed on your machine.
- .NET SDK 9.0 installed.
Internet Connection: Required for downloading dependencies and accessing AI services.
API Keys: Access to AI services like OpenAI or Azure OpenAI (optional but recommended for enhanced functionalities).

Setting Up Your Development Environment

Step 1: Install Visual Studio

If you haven't already, download and install Visual Studio (preferably the latest version) to get started with C# development.

Step 2: Install .NET SDK 9.0

Download and install the .NET SDK 9.0 to ensure compatibility with Semantic Kernel and to leverage the latest features of C#.

Step 3: Create a New C# Console Application

Open Visual Studio:
- Launch Visual Studio and select "Create a new project".
Choose Project Template:
- Select "Console App" and click "Next".
Configure Your Project:
- Project Name: AIPoweredApp
- Location: Choose a suitable directory.
- Framework: Ensure .NET 9.0 is selected.
- Click "Create".

Step 4: Install Semantic Kernel via NuGet

Open NuGet Package Manager:
- Right-click on your project in the Solution Explorer.
- Select "Manage NuGet Packages...".
Browse and Install Semantic Kernel:
- In the Browse tab, search for "SemanticKernel".
- Select the package and click "Install".
- Accept any license agreements if prompted.

Building Your First AI-Powered C# Application

In this section, we'll build a simple AI-powered chatbot that interacts with users through the console. The chatbot leverages Semantic Kernel to process user input and generate intelligent responses.

Step 1: Create a New C# Console Application

Assuming you've already created a new C# Console Application named AIPoweredApp, let's proceed to set up the project.

Step 2: Install Semantic Kernel

As covered in the setup, ensure Semantic Kernel is installed via NuGet. This provides the necessary libraries to integrate AI functionalities into your application.

Step 3: Integrate Semantic Kernel into Your Project

Open the Program.cs file and set up the necessary namespaces and services.

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;

var builder = Kernel.CreateBuilder();

builder.AddOpenAIChatCompletion("gpt-4o", "<<YOUR API KEY>>");

Kernel kernel = builder.Build();

var chatService = kernel.GetRequiredService<IChatCompletionService>();

ChatHistory chatHistory = new ChatHistory();

while (true)
{
    Console.ForegroundColor = ConsoleColor.Yellow;
    Console.Write("User>> ");

    var userMessage = Console.ReadLine();

    chatHistory.AddUserMessage(userMessage);

    var response = chatService.GetStreamingChatMessageContentsAsync(chatHistory, kernel: kernel);

    Console.ForegroundColor = ConsoleColor.Green;
    Console.Write("AI>> ");

    string fullMessage = "";

    await foreach(var chat in response)
    {
        Console.Write(chat);
        fullMessage += chat;
    }

    Console.WriteLine();

    chatHistory.AddAssistantMessage(fullMessage);
}

Enhancements and Next Steps

Congratulations on building your first AI-powered C# application! To take your project further, consider the following enhancements:

Add More AI Features:

Implement natural language understanding (NLU) for better context handling.
Integrate sentiment analysis to tailor responses based on user emotions.

Improve User Interface:

Develop a graphical user interface (GUI) using WPF or Windows Forms for a more interactive experience.
Create a web-based interface using ASP.NET Core.

Persist Chat History:

Save conversation history to a database or file for future reference.
Implement user authentication to manage personalized chats.

Deploy Your Application:

Host your application on cloud platforms like Azure or AWS.
Make it accessible as a web service or mobile app.

Explore Advanced Semantic Kernel Features:

Utilize Semantic Kernel's planners for complex task automation.
Integrate multiple AI models to enhance chatbot capabilities.

Conclusion

Embarking on AI development with C# and Semantic Kernel opens up a world of possibilities for creating intelligent and responsive applications. In this tutorial, you built a foundational AI-powered chatbot, setting the stage for more advanced projects and integrations.

As you continue to explore and enhance your skills, Semantic Kernel will serve as a valuable tool in your AI development toolkit, enabling you to build sophisticated applications easily.

Stay tuned for more tutorials in our AI C# Series, where we'll delve into advanced features, real-world projects, and optimization techniques to help you master AI integration in your C# applications.

How to Create Timer Trigger Azure Functions with .NET 9: Step-by-Step Guide for Beginners

CodeStreet — Fri, 06 Dec 2024 03:42:57 +0000

Welcome to this comprehensive guide on Mastering Timer Trigger Azure Functions with .NET 9 using Visual Studio! If you're venturing into serverless computing or aiming to enhance your Azure skillset, you've come to the right place.

This tutorial will walk you through creating your first Timer Trigger Azure Function with .NET 9 using Visual Studio. We'll explore practical use cases, provide a step-by-step implementation, and discuss some potential drawbacks to help you make informed decisions.

👉 Watch the accompanying video tutorial here.

What is Azure Functions and Timer Triggers

Azure Functions is a serverless computing service offered by Microsoft Azure that allows you to run event-driven code without the need to manage infrastructure. Whether responding to HTTP requests, processing data from queues, or handling file uploads, Azure Functions provides a flexible and scalable platform for executing code based on various triggers.

One such trigger is the Timer Trigger, which enables your function to run on a predefined schedule, much like a traditional cron job. Timer Triggers are perfect for tasks that need to be executed at regular intervals, such as:

Data Backups: Automate the backup process of databases or file systems.
Scheduled Notifications: Send out periodic email summaries or alerts.
System Maintenance: Perform routine maintenance tasks like cleaning up temporary files or optimizing databases.
Report Generation: Generate and distribute reports on a daily, weekly, or monthly basis.

This guide will focus on creating a Timer Trigger Azure Function using .NET 9 within Visual Studio, covering everything from setup to deployment.

Use Cases for Timer Trigger Azure Functions

Timer Triggers are incredibly versatile and can be applied to a wide array of scenarios. Here are some common use cases:

Scheduled Data Processing: Automate tasks like aggregating data, generating reports, or processing logs at specific intervals.
System Maintenance: Perform routine maintenance tasks such as cleaning up temporary files, optimizing databases, or updating system configurations.
Notifications and Alerts: Send out regular email summaries, system health checks, or alert notifications to the users or system.
Automated Backups: Schedule regular backups of databases, file systems, or application data to ensure data integrity and availability.

Prerequisites

Before diving into the tutorial, ensure you have the following tools and accounts set up:

Azure Account: If you don't have one, you can sign up for a free trial on the Azure website.
Visual Studio 2022 or Later: Ensure you have Visual Studio installed.
Azure Functions Tools: During the Visual Studio installation, ensure that the Azure development workload is selected. If already installed, you can modify your installation to include it.
.NET 9 SDK: Ensure you have the latest .NET 9 SDK installed. Download here.
Azure CLI (Optional): Useful for managing Azure resources from the command line.

With these prerequisites in place, you're ready to create your first Timer Trigger Azure Function using Visual Studio.

Creating Your First Timer Trigger Azure Function in Visual Studio

Let's embark on the journey of creating a Timer Trigger Azure Function using .NET 9 within Visual Studio. We'll follow a structured, step-by-step approach to ensure clarity and ease of understanding.

Creating Your First Timer Trigger Azure Function

Let’s dive into creating a Timer Trigger Azure Function using .NET 9. We’ll follow a step-by-step approach to ensure clarity and ease of understanding.

Step 1: Open Visual Studio 2022

Step 2: Create New Project

Step 3: Search for “Azure Function” (Make sure you have installed Azure Payload on your Visual Studio)

Step 4: Choose Trigger Type and DotNet Version

Step 5: Click on Create

After completing these steps, Visual Studio will scaffold your new Timer Trigger Azure Function with the necessary files and configurations.

Understanding the Function Code

Let’s examine the generated code to understand how Timer Triggers work.

using System;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;

public static class ScheduledBackupFunction
{
    [FunctionName("ScheduledBackupFunction")]
    public static void Run([TimerTrigger("0*5 */5 * * * *")] TimerInfo myTimer, ILogger log)
    {
        log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
        // Add your backup logic here
    }
}

Key Components:

[FunctionName("ScheduledBackupFunction")]: This attribute defines the name of the function.
[TimerTrigger("0 */5 * * * *")]: This attribute sets the schedule using a CRON expression. In this case, the function runs every 5 minutes.
Run Method : Contains the code that executes when the function is triggered. Currently, it logs the execution time.

Before deploying to Azure, it’s essential to test your function locally.

For that change the CRON expression to TimerTrigger */5 * * * * * so it will run in every 5 second.

Press F5 to run and observe the log:

[2024-04-27T12:00:00.000Z] C# Timer trigger function executed at: 4/27/2024 12:00:00 PM
[2024-04-27T12:00:00.000Z] C# Timer trigger function executed at: 4/27/2024 12:00:05 PM

Something similar you will get.

Deploying the Function to Azure

There are various ways to deploy the Azure functions you can follow along with the video for smooth deployment.

Drawbacks of Timer Trigger Azure Functions

While Timer Trigger Azure Functions are powerful, they come with certain limitations and potential drawbacks:

Dependency on Accurate Time Settings: Timer Triggers rely on CRON expressions, making them sensitive to time zone settings and daylight-saving changes. Incorrect configurations can lead to missed or duplicate executions.
Limited Precision: The CRON schedule in Azure Functions doesn't support sub-minute precision. If you need tasks to run more frequently than once a minute, Timer Triggers might not be suitable.
Cold Start Delays: Especially on the Consumption Plan, functions might experience cold starts, leading to delays in execution when the function hasn't been invoked recently.
Complexity in Error Handling: Handling errors in scheduled tasks can be more complex compared to event-driven triggers. Ensuring retries and managing failures requires careful planning.
Monitoring and Logging Challenges: While Azure provides monitoring tools, tracking and debugging scheduled executions can be less straightforward compared to interactive triggers like HTTP requests.
Potential for Overlapping Executions: If a function takes longer to execute than the interval defined in the Timer Trigger, it might lead to overlapping executions, causing conflicts or resource contention.

Conclusion and Next Steps

Congratulations! You've successfully created and deployed your first Timer Trigger Azure Function using .NET 9 in Visual Studio. This serverless approach allows you to automate routine tasks efficiently, ensuring reliability and scalability without the overhead of managing infrastructure.

Key Takeaways:

Azure Functions provide a scalable, serverless platform for executing code in response to various triggers. -- Timer Triggers are ideal for scheduled tasks, automating processes like backups, notifications, and maintenance. .NET 9 offers robust support for building Azure Functions, enabling developers to leverage modern language features.
Security Best Practices: Always store sensitive information securely using environment variables or Azure Key Vault.
Be Aware of Limitations: Understand the potential drawbacks of Timer Triggers and implement strategies to mitigate them.

Feel free to leave your questions, comments, or suggestions below. Happy coding!

Building Scalable Applications with Azure Functions: Best Practices and Tips

CodeStreet — Sat, 09 Nov 2024 14:11:58 +0000

In today’s fast-paced digital landscape, building scalable applications is essential to accommodate growing user bases, handle increased workloads, and ensure seamless performance. Azure Functions, a serverless computing service provided by Microsoft Azure, offers a robust platform for developing scalable applications without the overhead of managing infrastructure.

Whether you’re an experienced developer or a newbie, understanding how to leverage Azure Functions effectively can significantly enhance your application's scalability and performance. In this blog post, we’ll delve into the best practices and tips for building scalable applications with Azure Functions.

Introduction to Azure Functions

Azure Functions is a serverless compute service that enables you to run event-driven code without having to explicitly provision or manage infrastructure.

With Azure Functions, you can execute code in response to various triggers, such as HTTP requests, timers, or messages from other Azure services like Azure Blob Storage and Azure Service Bus.

This serverless approach allows developers to focus on writing code while Azure handles the scaling, patching, and maintenance of the underlying infrastructure.

Benefits of Using Azure Functions for Scalability

Before diving into best practices, it’s essential to understand why Azure Functions is an excellent choice for building scalable applications:

Automatic Scaling: Azure Functions can automatically scale out based on demand. Whether you have one request or thousands per second, Azure Functions can handle the load seamlessly.
Cost-Effective: You pay only for the compute resources you consume, making it a cost-efficient solution, especially for applications with variable or unpredictable workloads.
Flexibility: Supports multiple programming languages, including C#, JavaScript, Python, and more, allowing developers to work in their preferred language.
Rapid Development: The serverless model accelerates development cycles by reducing the time spent on infrastructure management.

With these advantages in mind, let’s explore how to harness Azure Functions to build scalable applications effectively.

Best Practices for Building Scalable Applications

1. Choose the Right Trigger

Azure Functions can be triggered by various events, such as HTTP requests, timers, queues, and more. Selecting the appropriate trigger based on your application's requirements is crucial for scalability.

HTTP Triggers: Ideal for APIs or webhooks. They can handle a high volume of requests and are suitable for front-end applications.
Timer Triggers: Useful for scheduled tasks like batch processing or cleanup jobs.
Queue Triggers: Perfect for decoupling components and handling background processing, ensuring tasks are processed asynchronously.
Event Grid Triggers: Suitable for event-driven architectures, allowing functions to respond to events from Azure services or custom sources.

Tip: Assess the nature of the tasks your application performs and choose triggers that align with those tasks to optimize performance and scalability.

2. Optimize Function Code

Efficient code is the backbone of scalable applications. Optimizing your function code ensures that each execution consumes minimal resources and completes quickly.

Keep Functions Lightweight: Functions should perform a single, focused task. Avoid adding unnecessary logic that can slow down execution.
Asynchronous Programming: Utilize asynchronous programming models to handle I/O-bound operations efficiently, allowing functions to process multiple tasks concurrently.
Minimize External Calls: Reduce dependencies on external services or APIs, which can introduce latency. If necessary, implement retries and exponential backoff strategies.
Efficient Data Processing: Handle data processing in-memory when possible and avoid excessive data transformations or manipulations.

Example:

[FunctionName("ProcessQueueMessage")]
public async Task Run([QueueTrigger("myqueue-items")] string myQueueItem, ILogger log)
{
    log.LogInformation($"Processing message: {myQueueItem}");
    // Perform asynchronous operations
    await SomeAsyncOperation(myQueueItem);
}

3. Manage Dependencies Wisely

Dependencies, such as libraries and external packages, can impact the startup time and performance of your functions.

Minimize Dependencies: Only include necessary libraries to reduce the function’s footprint and improve cold start times.
Use Managed Dependencies: Leverage Azure’s managed dependencies and extensions where possible to avoid adding unnecessary packages.
Optimize Package Sizes: Choose lightweight libraries and avoid bloated packages that can increase the deployment size and slow down function execution.

Tip: Regularly review and update your dependencies to benefit from performance improvements and security patches.

4. Implement Proper Scaling Strategies

Azure Functions provide built-in scaling capabilities, but implementing additional strategies can enhance scalability further.

Understand Scaling Limits: Be aware of Azure’s scaling limits and plan your application architecture accordingly. For example, the Consumption Plan has certain limits on execution time and resources.
Use Premium or Dedicated Plans for High Demands: If your application requires higher performance or needs to run continuously, consider using Premium or Dedicated (App Service) plans which offer better scaling options.
Partition Workloads: Distribute workloads across multiple functions or queues to prevent bottlenecks and ensure even load distribution.

Tip: Monitor your application’s performance and adjust your scaling strategy as needed to accommodate changing demands.

5. Use Durable Functions for Orchestration

Durable Functions extend Azure Functions by enabling stateful orchestrations. They are ideal for managing complex workflows and long-running processes.

Chaining Functions: Execute functions sequentially, passing data from one to the next.
Fan-Out/Fan-In: Run multiple functions in parallel and aggregate the results.
Human Interaction: Incorporate manual approvals or user inputs into automated workflows.
Error Handling and Retries: Implement robust error handling and retry mechanisms to ensure reliability.

Example:

[FunctionName("OrchestratorFunction")]
public async Task OrchestratorFunction([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var tasks = new List<Task<string>>();
    for (int i = 0; i < 5; i++)
    {
        tasks.Add(context.CallActivityAsync<string>("ActivityFunction", i));
    }
    await Task.WhenAll(tasks);
    var results = tasks.Select(t => t.Result).ToList();
    // Process results
}

6. Monitor and Analyze Performance

Continuous monitoring is essential to maintain and improve the scalability of your applications.

Azure Monitor: Utilize Azure Monitor to track performance metrics, such as execution times, memory usage, and request rates.
Application Insights: Integrate Application Insights for detailed telemetry, including request traces, dependency tracking, and exception logging.
Logging Best Practices: Implement structured and meaningful logging to facilitate troubleshooting and performance analysis.

Tip: Set up alerts for critical metrics to proactively address performance issues before they impact users.

7. Secure Your Functions

Security is paramount, especially when scaling applications that handle sensitive data or critical operations.

Authentication and Authorization: Implement proper authentication mechanisms, such as Azure Active Directory (AAD) or OAuth, to control access to your functions.
Secure Secrets: Store sensitive information, like connection strings and API keys, in Azure Key Vault or Azure App Configuration instead of hardcoding them.
Network Security: Use Virtual Networks (VNet) and service endpoints to restrict access to your functions and related resources.
Input Validation: Validate and sanitize all inputs to prevent common vulnerabilities like SQL injection and cross-site scripting (XSS).

Example:

[FunctionName("SecureHttpTrigger")]
public async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
    ILogger log)
{
    // Validate inputs and authenticate user
    // Perform secure operations
}

8. Use Appropriate Storage Solutions

Choosing the right storage solution is critical for the performance and scalability of your application.

Azure Blob Storage: Ideal for storing large amounts of unstructured data, such as images, videos, and backups.
Azure Cosmos DB: A globally distributed, multi-model database service that provides low latency and high availability for mission-critical applications.
Azure SQL Database: A fully managed relational database service suitable for applications requiring structured data storage and complex queries.
Azure Table Storage: A NoSQL key-value store for rapid development using massive semi-structured datasets.

Tip: Evaluate your data access patterns and choose a storage solution that aligns with your scalability and performance requirements.

9. Manage Costs Effectively

While Azure Functions can be cost-effective, unmanaged scaling can lead to unexpected expenses. Implement strategies to monitor and control costs.

Set Budget Alerts: Use Azure Cost Management to set budgets and receive alerts when spending approaches thresholds.
Optimize Resource Usage: Ensure functions are optimized to complete tasks quickly, reducing the compute time and associated costs.
Choose the Right Plan: Select the appropriate hosting plan (Consumption, Premium, or Dedicated) based on your application's workload and budget constraints.

Tip: Regularly review your usage patterns and adjust your scaling and resource allocation strategies to optimize costs.

10. Avoid Cold Starts

Cold starts occur when a function is invoked after being idle, leading to increased latency as the runtime initializes. Minimizing cold starts is crucial for maintaining responsiveness.

Use Premium Plans: Premium plans offer pre-warmed instances that are always ready to handle requests, reducing cold start occurrences.
**Keep Functions Warm: **Implement warm-up triggers or scheduled functions to periodically invoke functions and keep them active.
Optimize Initialization Code: Reduce the complexity and size of the initialization code to speed up startup times.

Tip: Analyze cold start patterns using monitoring tools and adjust your deployment strategy accordingly.

Conclusion

Building scalable applications is a critical aspect of modern software development, ensuring that your applications can handle growth, adapt to changing demands, and provide a seamless user experience. Azure Functions offers a powerful, serverless platform that simplifies the process of developing scalable, event-driven applications.

By following the best practices and tips outlined in this blog post—ranging from optimizing function code and managing dependencies to implementing robust monitoring and security measures—you can harness the full potential of Azure Functions to build resilient and scalable applications.

Enjoyed the insights? 👉 Follow me for more tech wisdom and don't forget to subscribe to my YouTube channel! 🎥🚀

Happy coding!

Azure Storage Accounts Explained: The Ultimate Guide to Real-World Applications

CodeStreet — Thu, 22 Aug 2024 06:20:31 +0000

An Azure Storage Account is essentially a container that holds all your Azure Storage services, such as blobs, files, queues, tables, and disks. It provides a unique namespace for your data that can be accessed from anywhere in the world via HTTP or HTTPS.

Azure Storage is a scalable and secure cloud storage solution from Microsoft Azure that offers various storage services for different types of data.

Types of Storage in Azure Storage Accounts

1. Blob Storage: Used to store unstructured data like images, videos, and documents. It's perfect for applications that need to handle large amounts of binary or text data.

2. File Storage: Offers fully managed file shares in the cloud that can be accessed via the SMB protocol. Ideal for scenarios where applications require shared access to files.

3. Queue Storage: Provides a messaging queue that can be used to build distributed and decoupled applications. Useful in scenarios where different components of an application need to communicate asynchronously.

4. Table Storage: A NoSQL key-value store that is optimized for fast data access. It's highly scalable and is often used for storing large amounts of structured data.

5. Disk Storage: Provides persistent, highly durable, and scalable disk storage for use with Azure Virtual Machines. Ideal for storing VM operating systems and data disks.

Real-Life Applications of Azure Storage Accounts

1. Data Backup and Recovery

Azure Storage is widely used for data backup and disaster recovery. Companies can back up their on-premises data to Azure Blob Storage using tools like Azure Backup or third-party software. The data is stored securely and can be retrieved whenever necessary, ensuring business continuity.

Example: A financial institution backs up its daily transaction logs to Azure Blob Storage. In the event of a system failure, the data can be quickly restored, minimizing downtime and data loss.

2. Hosting Static Websites

Azure Blob Storage can host static websites, which include HTML, CSS, JavaScript, and other client-side assets. It's a cost-effective and scalable solution for hosting websites that do not require server-side processing.

Example: A small business hosts its product catalog website on Azure Blob Storage. The website is accessed globally with minimal latency and no need for server management.

3. Media Content Delivery

Azure Blob Storage is an excellent solution for storing and delivering large media files like videos, audio, and images. It can be integrated with Azure CDN (Content Delivery Network) to distribute content efficiently across the globe.

Example: A streaming service stores its video library in Azure Blob Storage. The videos are streamed to users worldwide with the help of Azure CDN, providing a seamless viewing experience.

4. Big Data Analytics

Azure Storage, combined with Azure Data Lake, allows organizations to store massive amounts of unstructured data and perform analytics using tools like Azure Databricks, HDInsight, or Synapse Analytics.

Example: A retail company collects transaction data from its stores and online channels. The data is stored in Azure Data Lake and processed using Azure Synapse Analytics to gain insights into customer behavior.

5. IoT Data Storage

Azure Storage is used in IoT (Internet of Things) solutions to store large volumes of sensor data. The data can be stored in Blob Storage or Table Storage and then processed or analyzed as needed.

Example: A manufacturing company uses IoT sensors to monitor its production lines. The sensor data is stored in Azure Table Storage, where it is analyzed to predict equipment failures and optimize maintenance schedules.

6. Enterprise File Sharing

Azure File Storage provides cloud-based file shares that can be accessed from anywhere. This is particularly useful for enterprises that need to provide shared access to files across different locations.

Example: A global law firm uses Azure File Storage to share case files between its offices in different countries. The files are securely accessed and updated by legal teams working in different time zones.

7. Messaging and Workflow Management

Azure Queue Storage is often used in scenarios where different components of an application need to communicate asynchronously. It helps in managing workflows and ensuring reliable message delivery between services.

Example: An e-commerce platform uses Azure Queue Storage to manage order processing. When an order is placed, a message is added to the queue, and the order processing service picks up the message to fulfill the order.

8. Persistent Storage for Virtual Machines

Azure Disk Storage is used to provide persistent storage for Azure Virtual Machines (VMs). This storage is essential for running VMs that require reliable and high-performance storage for operating systems, applications, and data.

Example: A healthcare organization runs a database server on an Azure VM with Azure Disk Storage. The disk provides the necessary performance and durability to handle sensitive patient data.

Setting Up and Managing Azure Storage Accounts

1. Creating a Storage Account

Creating an Azure Storage Account is a straightforward process through the Azure Portal, Azure CLI, or Azure PowerShell. Here’s how you can do it via the Azure Portal:

Navigate to the Azure Portal.
Click on "Create a resource" and search for "Storage account."
Click "Create" and fill in the necessary details like subscription,
resource group, storage account name, region, and performance tier.
Review and create the storage account.

2. Configuring Access and Security

Azure Storage Accounts provide several options for securing access to your data:

Shared Access Signatures (SAS): Allow limited access to resources in your storage account without exposing your account key.
Azure Active Directory (AAD): Use AAD to authenticate access to blob and queue data.
Network Security: Use Virtual Network (VNet) rules and firewall rules to restrict access to your storage account.

3. Monitoring and Diagnostics

Azure provides robust monitoring and diagnostics for storage accounts:

Azure Monitor: Use Azure Monitor to track metrics like availability, capacity, transactions, and latency.
Azure Storage Analytics: Provides detailed logs and metrics for monitoring requests to your storage account.

Conclusion

Azure Storage Accounts offers versatile and scalable storage solutions for a wide range of applications, from simple data backup to complex big data analytics and IoT scenarios. By understanding the different types of storage available and how to use them effectively, you can build robust and efficient applications that leverage the full power of the cloud.

Enjoyed the insights? 👉 Follow me for more tech wisdom and don't forget to subscribe to my YouTube channel! 🎥🚀

GitHub
YouTube

Azure Functions Hosting Models: In-Process vs. Isolated Process - What's Best for Your Project?

CodeStreet — Mon, 19 Aug 2024 01:58:57 +0000

In this blog post, we'll explore the differences between the In-Process and Isolated Process hosting models in Azure Functions, along with their benefits and drawbacks. By the end, you'll have a clear understanding of which model to choose for your specific use case.

Azure Functions is a popular serverless computing service that allows developers to run small pieces of code, known as functions, in the cloud.

One of the key decisions you'll face when working with Azure Functions in .NET is choosing between the In-Process and Isolated Process hosting models. Both models have their own advantages and trade-offs, making it crucial to understand when to use each one.

Understanding the Hosting Models

In-Process Hosting Model

The In-Process hosting model is the traditional hosting model for Azure Functions. In this model, your function code runs in the same process as the Azure Functions runtime. This allows for direct access to the runtime's features, such as logging, configuration, and binding, with minimal overhead.

Isolated Process Hosting Model

The Isolated Process hosting model, introduced with .NET 5 and beyond, separates the function code from the Azure Functions runtime. Your code runs in a separate process, isolated from the runtime, allowing for greater flexibility and customization, especially for .NET applications that require specific .NET version support or advanced dependency management.

Benefits and Drawbacks

In-Process Hosting Model

Benefits

1. Performance: Running in the same process as the runtime results in lower latency and faster execution times.

2. Simplicity: The In-Process model offers easier access to built-in features like logging, dependency injection, and triggers without additional configuration.

3. Mature Ecosystem: Since this is the original hosting model, it has a more mature ecosystem with extensive documentation and community support.

4. Compatibility: Direct access to Azure Functions runtime features like bindings, configuration, and triggers.

Drawbacks

1. Tight Coupling: Your function code is tightly coupled to the Azure Functions runtime, making it harder to upgrade or use different versions of .NET.

2. Limited Flexibility: You have less control over the runtime environment, which might be restrictive if you have specific version or configuration needs.

3. Limited .NET Versions: Only supports .NET versions that are compatible with the runtime, which can be a limitation for some advanced applications.

Isolated Process Hosting Model

Benefits:

1. Flexibility: The Isolated Process model allows you to run your function code in a separate process, giving you full control over the environment and the ability to use any version of .NET.

2. Custom Middleware: You can create and use custom middleware, allowing for advanced scenarios like custom authentication, logging, and error handling.

3. Modular Design: The isolated nature of the process means your function code is less dependent on the Azure Functions runtime, making it easier to upgrade or change runtime versions.

4. Future-Proofing: As Azure Functions evolves, the Isolated Process model is more likely to receive new features and updates, making it a more future-proof choice.

Drawbacks:

1. Performance Overhead: Running in a separate process introduces some latency due to inter-process communication, which can result in slightly slower execution times.

2. Complexity: The Isolated Process model requires more configuration and setup, including managing your own dependency injection, logging, and bindings.

3. Learning Curve: For developers accustomed to the In-Process model, the Isolated Process model may have a steeper learning curve, especially when working with custom middleware and dependency injection.

4. Limited Ecosystem: While growing, the ecosystem and community support for the Isolated Process model are not as extensive as for the In-Process model.

When to Use In-Process vs. Isolated Process

When to Use In-Process:

Performance-Critical Applications: If your application requires the lowest possible latency and the highest performance, the In-Process model is often the better choice.
Simple, Rapid Development: For small to medium-sized applications where simplicity and ease of access to runtime features are key, the In-Process model is ideal.
Legacy Applications: If you’re working with existing Azure Functions that were built using the In-Process model, and there’s no pressing need to switch, sticking with In-Process can save time and effort.

When to Use Isolated Process:

Advanced Customization: If your application requires advanced customization, such as using custom middleware, or if you need to work with specific versions of .NET that the runtime doesn’t support, the Isolated Process model is the way to go.
Modern, Modular Applications: For new projects that aim to be future-proof, modular, and maintainable, the Isolated Process model offers greater flexibility and control.
Complex Enterprise Applications: In scenarios where different teams or services need to run different versions of .NET, or where there are strict requirements for isolation and security, the Isolated Process model provides the necessary separation and customization.

Conclusion

Choosing between the In-Process and Isolated Process hosting models in Azure Functions depends on your specific application needs. The In-Process model offers simplicity, performance, and ease of use, making it suitable for many scenarios.

However, as applications grow in complexity, or if you require specific .NET version support and advanced customization, the Isolated Process model provides the flexibility and future-proofing needed for modern development.

How to Create Custom Middleware in Azure Functions: A Step-by-Step Guide with .NET 8

CodeStreet — Sun, 18 Aug 2024 08:59:49 +0000

This blog post will walk us through creating custom middleware in Azure Functions using .NET 8. We’ll build a custom exception handler middleware that catches unhandled exceptions, logs them, and returns a standardized error response.

By the end of this guide, you'll clearly understand how to create and use middleware in your Azure Functions projects.

Azure Functions has become a go-to solution for building serverless applications. One of the powerful features of Azure Functions in .NET 8 is the ability to use middleware in isolated process mode.

Middleware allows you to inject logic into the request-processing pipeline, making it an essential tool for handling cross-cutting concerns like logging, authentication, and error handling.

What is Middleware?

Middleware is a component that processes incoming requests before they reach your core application logic. Think of it as a filter or gatekeeper that can modify requests, enforce security policies, or handle errors.

In the context of Azure Functions, middleware can be used to perform tasks like logging, validation, and exception handling across multiple functions without repeating code.

Step 1: Setting Up Your Azure Functions Project

Before we dive into the middleware, let’s set up a basic Azure Functions project in .NET 8.

Step 1: Setting Up Your Azure Functions Project

Create a New Project:

Open Visual Studio 2022 and create a new Azure Functions project.
Choose the “ .NET 8 Isolated Process ” template.
Name your project and click “ Create.”

Install Required Packages:

Ensure that you have the necessary NuGet packages installed for Azure Functions and middleware. The Microsoft.Azure.Functions.Worker package should already be included in your project.

Step 2: Creating Custom Exception Handling Middleware

Now that your project is set up, let’s create a custom middleware class that will handle exceptions globally.

using Microsoft.Azure.Functions.Worker;
using System.Text.Json;

public class CustomExceptionHandler : IFunctionsWorkerMiddleware
{
    public async Task Invoke(FunctionContext context, FunctionExecutionDelegate next)
    {
        try
        {
            await next(context);
            Console.WriteLine("No exception occurred");
        }
        catch (Exception ex)
        {
            var request = await context.GetHttpRequestDataAsync();
            var response = request!.CreateResponse();
            response.StatusCode = System.Net.HttpStatusCode.InternalServerError;

            var errorMessage = new { Message = "An unhandled exception occurred. Please try again later", Exception = ex.Message };
            string responseBody = JsonSerializer.Serialize(errorMessage);

            await response.WriteStringAsync(responseBody);

            Console.WriteLine("Exception occurred");
            context.GetInvocationResult().Value = response;
        }
    }
}

Explanation:

Try-Catch Block: The Invoke method wraps the next middleware or function execution in a try-catch block. If an exception occurs, it is caught and handled.
Custom Error Response: When an exception is caught, the middleware creates an HTTP response with a 500 status code. It also serializes a custom error message, which includes a generic message and the exception details.
Logging: The middleware logs whether an exception occurred or not, making it easier to track issues during development.

Step 3: Registering the Middleware in the Function App

With the middleware created, the next step is to register it in your Azure Functions app.

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Hosting;

var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults(worker =>
    {
        worker.UseMiddleware<CustomExceptionHandler>();
    })
    .Build();

host.Run();

Explanation:

UseMiddleware: The UseMiddleware method registers your custom middleware in the function app’s pipeline. This ensures that the middleware is invoked for every incoming request, before any function logic is executed.

Step 4: Modify/Create Azure Function to Test the Middleware

Let’s create a simple Azure Function that will deliberately cause an exception, allowing us to test our middleware.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker.Http;

[Function("Custom-Middleware")]
public IActionResult Run([HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequest req)
{
    _logger.LogInformation("C# HTTP trigger function processed a request.");

    int.TryParse(req.Query["number"], out int number);
    int res = 10 / number; // This will throw a DivideByZeroException if 'number' is 0

    return new OkObjectResult(new { result = res });
}

Explanation:

DivideByZeroException: This function parses a number from the query string and divides 10 by that number. If the number is 0, a DivideByZeroException will be thrown, which our middleware will catch and handle.

Step 5: Running and Testing the Function

Now that everything is set up, let’s run the function app and test it by triggering the function with different inputs.

Valid Input: If you pass a non-zero number, the function will return the result of the division.
Invalid Input (Zero): If you pass 0, the function will throw an exception. The middleware will catch this exception, log it, and return a standardized error message to the client.

Here’s what the error response might look like:

{
    "Message": "An unhandled exception occurred. Please try again later",
    "Exception": "Attempted to divide by zero."
}

Conclusion

In this post, we’ve explored how to create and use custom middleware in Azure Functions using .NET 8 in isolated process mode. We walked through a practical example of an exception-handling middleware that catches unhandled exceptions and returns a standardized error response.

If you found this guide helpful, consider sharing it with others and stay tuned for more Azure Functions tutorials!