DEV Community: Oleksii Nikiforov

Introducing Technical Debt Master: AI-Powered Code Analysis with Local LLMs

Oleksii Nikiforov — Sat, 09 Aug 2025 00:00:00 +0000

TL;DR

Introducing tdm, a CLI tool that automates technical debt discovery, triage, and resolution. tdm transforms technical debt management into a proactive, automated process that works seamlessly with your existing development tools through MCP integration.

Source code: https://github.com/NikiforovAll/tech-debt-master

TL;DR
Motivation
tdm workflow
Let’s Get Started
- Installation
- Configuration
Technical Debt Discovery
Triaging Technical Debt
Technical Debt Resolution
References

Motivation

As software development continues to evolve, one thing remains constant: technical debt accumulates faster than we can manage it.

This is where Technical Debt Master (hereafter tdm) comes in. With the emergence of local/open-weights LLMs like DeepSeek R1 and GPT-OSS models that can run through tools like Ollama or LM Studio, we now have an unprecedented opportunity to bring AI-powered code analysis directly to our development environments.

But the advantages of using local LLMs for code analysis are compelling:

Privacy and Security: Your code never leaves your environment
Cost Efficiency: No API costs for analysis runs
Offline Capability: Work without internet connectivity
Control: Full control over model versions and behavior

Another compelling reason to use tdm in automation. Instead of relying on developers to remember which parts of the codebase need attention or hoping that code reviews will catch accumulating problems, tdm transforms this reactive approach into a proactive, automated system that works alongside your existing development workflow. More importantly, you catch architectural problems and code quality issues before they become expensive to fix, fundamentally shifting the cost curve in your favor.

`tdm` workflow

tdm implements a structured, phase-based approach to technical debt management:

Phase1️⃣ - Discovery. Continuous scanning identifies new technical debt as it’s introduced and AI-powered analysis provides context and severity assessment.
Phase2️⃣ - Triage. This stage offers two workflows: interactive CLI for individual developers to review and prioritize issues directly in the terminal, or HTML reports for team-based collaborative sessions where developers can discuss priorities together.
Phase3️⃣ - Resolution. The resolution stage leverages MCP server to enable automated technical debt remediation. Once triaged, identified technical debt items are exposed through the MCP server, effectively creating a structured backlog that AI coding agents can consume and act upon. This approach provides great flexibility - you can integrate tdm with your existing AI tools such as GitHub Copilot, Cursor, Claude Code CLI, Gemini CLI, etc.

Let’s Get Started

Installation

Install tdm from source code:

dotnet cake --target pack
dotnet tool install --global --add-source ./Artefacts TechDebtMaster.Cli

You can use tdm help to get a helpful reference for all available commands.

tdm help
# Available Commands:

# Repository Management
# repo Repository management and indexing operations
# ├─ index [path] Index repository content
# └─ status [path] Show status of previous analysis and repository changes

# Debt Analysis
# debt Technical debt analysis and reporting
# ├─ analyze [path] Perform debt analysis on all indexed files
# ├─ show [path] Show technical debt statistics in a tree structure grouped by tags
# ├─ view [path] View detailed content of specific technical debt items
# ├─ report [path] Generate an interactive HTML report of technical debt
# └─ import [report-file] Import modified HTML report to update analysis data

# System Management
# init Initialize tdm in the current repository
# config Manage configuration settings
# ├─ show Display current configuration
# └─ set [key] [value] Set a configuration value
# prompts Manage prompt templates
# ├─ edit Edit a prompt template
# ├─ restore Restore prompt templates to default state
# └─ set-default Set the default prompt template
# mcp Start Model Context Protocol server
# clean Remove the .tdm folder from the current directory
# help Show this detailed help information

Configuration

You can manage tdm configuration settings using the tdm config command. This allows you to customize various aspects of the tool to better fit your needs.

tdm integrates with OpenTelemetry to export detailed telemetry data including token consumption, model inference times, and per-analysis cost breakdowns, providing precise visibility into codebase analysis costs. In this blog post I will use it in conjunction with the .NET Aspire Dashboard. Also, we will use Aspire to work with Ollama to deploy local LLM models.

var builder = DistributedApplication.CreateBuilder(args);

var ollama = builder
    .AddOllama("ollama")
    .WithImageTag("0.6.0")
    .WithOpenWebUI(ui => ui.WithImageTag("0.5.20"))
    .WithDataVolume()
    .WithLifetime(ContainerLifetime.Persistent);

var r1 = ollama.AddModel("deepseek-r1", "deepseek-r1:1.5b");
// (alternatively) if you have free 16GB of RAM you can try something like
var gpt = ollama.AddModel("gpt-oss", "gpt-oss:20b");
// (optional) we use it to get a connecting string and otel configuration
builder
    .AddProject<Projects.TechDebtMaster_Cli>("tdm")
    .WithArgs("--", "help")
    .WithReference(r1);

builder.Build().Run();

Now, we can run it using Aspire CLI:

aspire run

Now we can configure tdm:

OTEL_EXPORTER_OTLP_ENDPOINT=https://localhost:21050
OTEL_EXPORTER_OTLP_HEADERS=x-otlp-api-key=ddc6b5e2c7f7ef486697b3a60a9aee52
OTEL_EXPORTER_OTLP_PROTOCOL=grpc
tdm config set ai.provider ollama
tdm config set ai.url http://localhost:62604
tdm config set ai.model 'deepseek-r1:1.5b'
tdm config set default.include '\.cs$' # we will use it with C# code base, so it makes sense to analyze only C# files

The beautiful part about tdm is that you can customize analysis prompts to better fit your project’s needs. Run tdm prompts edit to open the prompt in your default system editor.

💡 For example, you can configure tdm to identify specifically security-related issues by creating dedicated security.prompty file. tdm leverages Prompty for prompt management.

Technical Debt Discovery

Initialize tdm and index the repository with technical debt. In our case it is called tdm-testproject-monkeymcp (some project with technical debt)

tdm init
# √ Updated .gitignore to include .tdm folder
# √ TechDebtMaster initialization complete!
tdm repo index
# Analyzing repository: .
# Include pattern (from default.include): \.cs$ (only files matching this pattern will be analyzed)

# √ Repository analyzed successfully!
tdm repo status
# Analysis Status for: .
# Last analyzed: 2025-08-09 15:53:45 UTC

# Recent Changes:
# New files (6):
# + MonkeyMCP/Program.cs
# + MonkeyMCPShared/MonkeyPrompts.cs
# + MonkeyMCPShared/MonkeyResources.cs
# + MonkeyMCPShared/MonkeyTools.cs
# + MonkeyMCPSSE/Program.cs
# ... and 1 more

Now we are ready to perform technical debt analysis for the configured prompt using.

tdm debt analyze

Here is an example of data we can find in the Aspire Dashboard, each command has a separate trace:

💡 Each command has a separate trace

💡 You can drill down to see individual traces for find per-file analysis traces.

💡 Metrics give you insights into the overall LLM usage.

Once we have a backlog of technical debt identified, we can prioritize and address it effectively.

Triaging Technical Debt

Triaging technical debt means prioritizing identified issues based on business impact and remediation effort. tdm enables effective team triaging through structured reports where developers can collaboratively assess technical complexity against business priorities.

Use tdm debt show to get a tree view of technical debt items:

tdm debt show

You can work with items using tdm debt view --interactive command:

tdm debt view --interactive

💡 In the demo above, I showcased how to interactively view, manage, and export backlog items in various formats. For example, using --xml can be useful if you prefer not to use MCP and instead want to export backlog items in a more portable format. Similarly, a command like tdm debt show --json would also work.

If you are not a CLI-type of person, you can use tdm debt report to open a web-based interface for managing your technical debt. The neat trick here is that you can actually save the report once you are done and import it back to tdm.

tdm debt report -o report.html --open

💡 Use tdm debt import report.html --apply to export modified report back to tdm.

Technical Debt Resolution

Now, we can use MCP integration to work on technical debt resolution. tdm provides out of the box integration/prompts for popular tools like GitHub Copilot , Claude Code , Gemini CLI.

tdm init --profile vscode --force
# √ Created .vscode/mcp.json configuration
# √ Created .github/prompts/tdm-work-on-debt.prompt.md
# √ Updated .gitignore to include .tdm folder
# √ TechDebtMaster initialization complete!
# You can now start the MCP server with: tdm mcp

This initialization command produces the necessary configuration files for integrating with the MCP server.

tdm offers complete control over agent behavior through customizable prompt files (e.g.: .github/prompts/tdm-work-on-debt.prompt.md). These files define how AI coding agents interact with your technical debt backlog via the MCP interface. You can tailor prompts to align with your team’s coding standards, preferences, and risk tolerance. This flexibility allows you to decide whether agents should automatically resolve straightforward issues or require human approval for more complex changes. The prompt-based configuration enables you to adjust the level of automation to suit different scenarios. For those feeling adventurous, you can even run a coding agent like Claude Code in “YOLO mode” with a simple prompt such as “resolve technical debt.”. The benefit of using tdm in this case is that coding agent can focus on resolving exactly technical debt you triaged previously.

For example, here is a default prompt generated during vscode profile initialization:

---
mode: agent
tools: ['changes', 'codebase', 'editFiles', 'fetch', 'findTestFiles', 'problems', 'runCommands', 'runTasks', 'search', 'searchResults', 'terminalLastCommand', 'terminalSelection', 'testFailure', 'usages', 'tdm-get-item', 'tdm-list-items', 'tdm-remove-item', 'tdm-show-repo-stats']
description: 'An autonomous workflow for identifying, analyzing, and resolving technical debt in a codebase to improve maintainability and efficiency.'
---
## Workflow
Execute the following workflow to systematically address technical debt:

### 1. Assessment Phase
- Use `tdm-show-repo-stats` to gather repository-wide technical debt metrics

### 2. Prioritization Phase
- Use `tdm-list-items` to retrieve first page of technical debt items

### 3. Verification Phase
- For each item in the list:
- Use `tdm-get-item` to fetch detailed information about the item
- Present the item to the user for review
- Ask user for confirmation to proceed with the item

### 4. Resolution Phase
- Use `tdm-get-item` to fetch detailed item information
- Present user with the item
- Analyze item validity:
- Review related code
- Verify if debt is still relevant
- Document investigation findings
- For each valid item:
- Implement necessary fixes
- Remove resolved items using `tdm-remove-item`

### 5. Validation Requirements
- Ensure all changes maintain existing functionality
- Document any architectural decisions
- Request human review for complex changes
- Once an item is resolved or is no longer relevant, remove it from the list using 'tdm-remove-item'.

🤖Let’s see it in practice:

tdm mcp
# Starting MCP server for repository: .
# Server will listen on: http://localhost:3001
# Press Ctrl+C to stop the server

# √ MCP server started successfully

And run /tdm-work-on-debt prompt for GitHub Copilot chat window:

Source code: github.com/NikiforovAll/tech-debt-master

If you have feedback, questions, or want to contribute, feel free to open an issue or pull request on GitHub.

References

Monitoring Claude Code with .NET Aspire Dashboard

Oleksii Nikiforov — Sat, 14 Jun 2025 00:00:00 +0000

Introduction

Claude Code is a powerful AI coding assistant that can help you with various development tasks. It support telemetry monitoring, so I thought it would be fun to set up a .NET Aspire dashboard to visualize my usage and see how claude operates under the hood.

Source code: github.com/NikiforovAll/claude-code-rules

Setting Up .NET Aspire Dashboard

The first step is to run the Aspire dashboard. You can do this easily with Podman or Docker:

podman run --rm -it -d \
    -p 18888:18888 \
    -p 4317:18889 \
    --name aspire-dashboard \
    mcr.microsoft.com/dotnet/aspire-dashboard

This command starts the Aspire dashboard with the following configuration:

Dashboard UI accessible at port 18888
OpenTelemetry collector at port 4317

Configuring Claude Code Telemetry

Next, we need to configure Claude Code to send telemetry data to our Aspire dashboard. This is done through environment variables.

Create an .env file with the following content:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_LOG_USER_PROMPTS=1
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc

export OTEL_LOGS_EXPORTER=otlp
export OTEL_LOGS_EXPORT_INTERVAL=5000

export OTEL_EXPORTER_OTLP_METRICS_PROTOCOL=grpc
export OTEL_METRICS_EXPORTER=otlp
export OTEL_METRIC_EXPORT_INTERVAL=10000

export OTEL_SERVICE_NAME=claude-code
export OTEL_RESOURCE_ATTRIBUTES=service.instance.id=nikiforovall

Then load these environment variables in your terminal:

export $(grep -v '^#' .env | xargs)

See Monitoring Usage for more details on how to configure telemetry for Claude Code.

Using the Dashboard

With everything set up, you can now:

Open your browser and navigate to http://localhost:18888
Use Claude Code as you normally would
Watch as telemetry data appears in the Aspire dashboard

The dashboard will show various metrics and logs that can help you understand:

What kind of models and tools are being used
How often Claude Code is invoked
What prompts are being sent
Token usage patterns
Any errors or issues that occur ## Benefits of Monitoring

Setting up telemetry monitoring for Claude Code offers several advantages:

Usage Insights : Understand how Claude Code performs in real-world scenarios.
Resource Management : Monitor token usage and adjust your subscription if necessary.

My Claude Code Usage Best Practices and Recommendations

Oleksii Nikiforov — Fri, 13 Jun 2025 00:00:00 +0000

This post shares my collection of practical recommendations and principles for using Claude Code. For more details and the full source code, check out my repository:

Source code: github.com/NikiforovAll/claude-code-rules

Practical Recommendations

Here is my list of practical recommendations for using Claude Code:

Planning

Ask Claude to brainstorm ideas and iterate on them. Later, these ideas can be used as grounding context for your prompts.
plan mode vs auto-accept mode vs edit mode:
- Verify what is about to be performed using plan mode.
- Once verified, proceed with auto-accept mode.
- Step-by-step mode is the default mode with no auto-accept.
Workflows:
- a. Explore, plan, code, commit.
- b. Write tests, commit; code, iterate, commit.
- c. Write code, screenshot results, iterate.
Ask “think hard” to trigger deep thinking:
- “think” < “think hard” < “think harder” < “ultrathink”

AI Task-Based Development

Write a plan to an external source (e.g., file - plan.md) and use it as a checklist.
plan.prompt.md - use an external file as memory for task management and planning.

I’ve created a set of commands to help with AI task-based development:

Use /create-prd to create a Product Requirements Document (PRD) based on user input.
Use /generate-tasks to create a task list from the PRD.
Use /process-task-list to manage and track task progress.

Project structure looks like this:

tree -a
# .
# ├── .claude
# │   ├── commands
# │   │   ├── create-prd.md
# │   │   ├── generate-tasks.md
# │   │   └── process-task-list.md
# │   └── settings.local.json
# ├── .mcp.json
# └── README.md

For more details, please refer to source code.

Knowledge Mining / Grounding

Use the /init command to initialize the CLAUDE.md file. There’s no required format for CLAUDE.md files. I recommend keeping it concise and human-readable. You can use it to store important information about your project, such as architecture, design decisions, and other relevant details that can help Claude understand your codebase better.
CLAUDE.md can open other files like this: @path/to/import. Be careful, as this file is attached every time you submit a prompt.
There are two different types:
- Project memory ./CLAUDE.md - share it with your team.
- User memory ~/.claude/CLAUDE.md - personal preferences.
You can use # <text> to add particular memory to the CLAUDE.md file.
Use /memory to edit the memory file directly. It will open the file in your default editor.
Codebase Q&A: Use Claude Code to ask questions about your codebase. It can help during onboarding or when you need to understand how something works.
Use hints, reference files, provide examples, mention documentation, and provide links.

Miscellaneous

Use in “pipe” mode, as Unix philosophy utils: claude -p "" or echo '' | claude -p "".
🗑️ /clear and /compact <specific prompt for aggregation> can be very helpful.
🧠 If you don’t know something about Claude Code, ask it! It’s self-aware.
- E.g., What kind of tools do you have? Can you perform a web search?

MCP Servers

You can use MCP servers. See claude-code/mcps.

Here is an example of how to setup MCP servers, just create a .mcp.json file in your project root:

{
  "mcpServers": {
    "microsoft.docs.mcp": {
      "type": "http",
      "url": "https://learn.microsoft.com/api/mcp"
    },
    "context7": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@upstash/context7-mcp@latest"
      ]
    }
  }
}

🎁 Bonus: Turn Claude Code into an Interactive Tutor with Microsoft Docs & Context7

You can supercharge Claude Code by integrating it with Microsoft Docs and Context7. It can be useful for learning and development tasks.

Useful Links

⭐ Learn best practices for Claude Code: engineering/claude-code-best-practices.
⭐ Tutorials - https://docs.anthropic.com/en/docs/claude-code/tutorials
Explore common use cases for Claude Code: claude-code/common-tasks.
CLI Usage - https://docs.anthropic.com/en/docs/claude-code/cli-usage
Claude Code Memory - https://docs.anthropic.com/en/docs/claude-code/memory
General Prompt Engineering with Claude Models - https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview
Interactive Tutorial for Prompt Engineering - https://github.com/anthropics/prompt-eng-interactive-tutorial

If you have questions or want to see more, check out the GitHub repository or leave a comment below!

Hangfire MCP Server in Standalone Mode

Oleksii Nikiforov — Thu, 29 May 2025 00:00:00 +0000

TL;DR

Enqueue background jobs using the Hangfire MCP server in “standalone” mode using the .NET global tool.

Source code: https://github.com/NikiforovAll/hangfire-mcp

In my previous blog post, I showed you how to set up a Hangfire MCP server in a .NET application. We built Hangfire MCP from scratch, and as a prerequisite, you need to reference an assembly that contains Hangfire jobs directly in the Hangfire MCP project. This is a great approach if you want to extend the Hangfire MCP server’s capabilities, but it is not very convenient if you just want to use the Hangfire MCP server to enqueue background jobs.

In this post, I will show you how to use the Hangfire MCP server in “standalone” mode using the .NET global tool. Here is a NuGet package that I created for this purpose: Nall.HangfireMCP.

Here is how to setup it as an MCP server in VSCode:

dotnet tool install --global --add-source Nall.HangfireMCP
# You can invoke the tool using the following command: HangfireMCP
# Tool 'nall.hangfiremcp' (version '1.0.0') was successfully installed.

All we need to do is configure the mcp.json file to add the Hangfire MCP server and set the environment variables to specify the Hangfire jobs assembly, the job discovery expression, and the connection string for Hangfire.

{
  "servers": {
    "hangfire-mcp-standalone": {
      "type": "stdio",
      "command": "HangfireMCP",
      "args": [
        "--stdio"
      ],
      "env": {
        "HANGFIRE_JOBS_ASSEMBLY": "path/to/Jobs.dll",
        "HANGFIRE_JOBS_MATCH_EXPRESSION": "[?IsInterface && contains(Name, 'Job')]",
        "HANGFIRE_CONNECTION_STRING": "Host=localhost;Port=5432;Username=postgres;Password=postgres;Database=hangfire"
      }
    }
  }
}

As a result, the jobs are dynamically loaded from the specified assembly and can be enqueued using the MCP protocol. The rules for matching job names can be specified using the HANGFIRE_JOBS_MATCH_EXPRESSION environment variable. For example, the expression [?IsInterface && contains(Name, 'Job')] will match all interfaces that contain “Job” in their name. It is a JMESPath expression, so you can define how to match job names according to your needs.

Aspire (Bonus)

Here is how to use the Hangfire MCP server in Standalone Mode using Aspire:

var builder = DistributedApplication.CreateBuilder(args);

var postgresServer = builder
    .AddPostgres("postgres-server")
    .WithDataVolume()
    .WithLifetime(ContainerLifetime.Persistent);

var postgresDatabase = postgresServer.AddDatabase("hangfire");

builder.AddProject<Projects.Web>("server")
    .WithReference(postgresDatabase)
    .WaitFor(postgresDatabase);

var mcp = builder
    .AddProject<Projects.HangfireMCP_Standalone>("hangfire-mcp")
    .WithEnvironment("HANGFIRE_JOBS_ASSEMBLY", "path/to/Jobs.dll")
    .WithEnvironment("HANGFIRE_JOBS_MATCH_EXPRESSION", "[?IsInterface && contains(Name, 'Job')]")
    .WithReference(postgresDatabase)
    .WaitFor(postgresDatabase);

builder
    .AddMCPInspector()
    .WithSSE(mcp)
    .WaitFor(mcp);

builder.Build().Run();

Conclusion

The Hangfire MCP server can be used in standalone mode to enqueue background jobs without the need to write custom code. This provides greater flexibility and ease of use, especially when you want to quickly set up a Hangfire MCP server for job processing.

References

Background Job Scheduling Using Hangfire MCP Server

Oleksii Nikiforov — Sun, 25 May 2025 00:00:00 +0000

TL;DR

Enqueue background jobs using the Hangfire MCP server. Source code: https://github.com/NikiforovAll/hangfire-mcp

Motivation

I like Hangfire for background job processing in .NET applications. It has a simple and intuitive API, a powerful dashboard, and supports various storage options. Essentially, it provides everything I need for real-world applications that require background processing. However, sometimes I need to run a job with parameters in the background, and there isn’t an easy way to do it directly from the Hangfire dashboard.

🤔 So, I had an idea to schedule Hangfire jobs through an MCP server. This is exactly the use case for an MCP server.

Setup MCP Server

If you want to set up your own Hangfire MCP Server, you can use the Nall.ModelContextProtocol.Template template that I shared with you in the previous post.

At a high level, you need to do the following:

Set up the MCP server.
Register McpServerTool.
Configure job discovery.
Connect the MCP server to Hangfire using a connection string.
Configure the MCP client to consume the Hangfire MCP server. For example, in VS Code, you can configure the mcp.json file to add your server.

Code Deep Dive

Let’s see how this whole thing is composed by reviewing the AppHost/Program.cs file:

var builder = DistributedApplication.CreateBuilder(args);

var postgresServer = builder.AddPostgres("postgres-server").WithDataVolume();
var postgresDatabase = postgresServer.AddDatabase("hangfire");

builder.AddProject<Projects.Web>("server")
    .WithReference(postgresDatabase)
    .WaitFor(postgresDatabase);

var mcp = builder.AddProject<Projects.HangfireMCP>("hangfire-mcp")
    .WithReference(postgresDatabase)
    .WaitFor(postgresDatabase);

builder.AddMCPInspector().WithSSE(mcp);

builder.Build().Run();

In the above code, we are adding the following components:

Postgres Server : This is where Hangfire will store its data.
Web Project (aka Server): This is the main web application that will perform background job processing.
Hangfire MCP Project : This is the MCP server that will expose Hangfire jobs as MCP commands.
MCP Inspector : This is the MCP inspector that will allow us to interact with the Hangfire MCP server. This is very useful for debugging and testing purposes.

🚀 You can clone the repository (https://github.com/NikiforovAll/hangfire-mcp) and run the project to see how it works.

aspire run --project ./samples/AppHost/AppHost.csproj

Here is how the Aspire Dashboard looks:

From a high-level perspective, here is how it works:

sequenceDiagram participant User as User participant MCPHangfire as MCP Hangfire participant IBackgroundJobClient as IBackgroundJobClient participant Database as Database participant HangfireServer as Hangfire Server User->>MCPHangfire: Enqueue Job (via MCP Client) MCPHangfire->>IBackgroundJobClient: Send Job Message IBackgroundJobClient->>Database: Store Job Message HangfireServer->>Database: Fetch Job Message HangfireServer->>HangfireServer: Process Job

Hangfire MCP Server

This project is quite straightforward. We just need to map the MCP tool to a Hangfire job and call it a day. Here is how it looks:

[McpServerToolType]
public class HangfireTool(IHangfireDynamicScheduler scheduler)
{
    [McpServerTool(Name = "RunJob")]
    public string Run(
        [Required] string jobName,
        [Required] string methodName,
        Dictionary<string, object>? parameters = null
    )
    {
        var assembly = typeof(ITimeJob).Assembly; // <-- it should point to the assembly where your Hangfire jobs are defined.
        return scheduler.Enqueue(new(jobName, methodName, parameters), assembly);
    }
}

This code defines a Hangfire MCP tool that allows us to enqueue jobs using the MCP protocol. The Run method takes the job name, method name, and optional parameters, and enqueues the job using the IHangfireDynamicScheduler. The IHangfireDynamicScheduler is a custom scheduler that uses reflection to find the job method in the specified assembly and enqueue it.

💡 You can find the implementation of IHangfireDynamicScheduler in the source code of the project.

Now, you can ask GitHub Copilot to enqueue a job using something like this:

Please run the following job: #RunJob

{
    "jobName": "HangfireJobs.ISendMessageJob",
    "methodName": "ExecuteAsync",
    "parameters": {
        "text": "Hello, MCP!"
    }
}

Note that in this case, we need to specify the exact job name and method name, as well as the parameters. Wouldn’t it be great if we could discover the jobs by asking Copilot? Let’s see how we can do that.

[McpServerTool(Name = "ListJobs"), Description("Lists all jobs")]
[return: Description("An array of job descriptors in JSON format")]
public string ListJobs()
{
    var jobs = scheduler.DiscoverJobs(
        type => type.IsInterface && type.Name.EndsWith("Job", StringComparison.OrdinalIgnoreCase),
        typeof(ITimeJob).Assembly // <-- it should point to the assembly where your Hangfire jobs are defined.
    );

    return JsonSerializer.Serialize(jobs);
}

In the code above, we define a ListJobs method that returns a list of all jobs. The DiscoverJobs method uses reflection to find all jobs in the specified assembly.

The idea here is that you can define rules for job discovery that are specific to your application. In this case, we are matching interfaces that end with Job. In my demo application, I have two jobs defined: ITimeJob and ISendMessageJob. Here is how they look:

public interface ITimeJob
{
    public Task ExecuteAsync();
}

public interface ISendMessageJob
{
    public Task ExecuteAsync(string text); // You can specify parameters
    public Task ExecuteAsync(Message message); // Works with complex types as well
}

Let’s take a look at the MCP server from the MCP Inspector:

As you can see, we have a bunch of tools available in the MCP Inspector. We can list jobs, enqueue jobs, get job status by job ID, and requeue jobs. The MCP Inspector allows us to interact with the Hangfire MCP server, making it a nice way to test and debug the MCP server.

Conclusion

Now you can easily enqueue Hangfire jobs using MCP. You can use it to schedule jobs from any MCP client, such as VS Code, or even from your own custom application. If you want to see the end-to-end demo, you can check out the video at the beginning of this post.

References

modelcontextprotocol/csharp-sdk

Code Review with GitHub Copilot in Visual Studio Code

Oleksii Nikiforov — Sat, 03 May 2025 00:00:00 +0000

TL;DR

TL;DR
Introduction
Code Review Custom Instructions
Code Review in Agent Mode
- Crafting the Review Prompt
- Demo
Conclusion
References

In this blog post, I will show you how to leverage GitHub Copilot’s code review capabilities in Visual Studio Code. In addition to the built-in features, I’ll introduce my own agent-based code review workflow using a custom prompt. This approach leverages Copilot’s flexibility to tailor the review process to your team’s needs.

Source code: https://github.com/NikiforovAll/dotnet-copilot-rules

Introduction

Code review has always been a cornerstone of high-quality software development, but its importance has only grown with the advent of LLM-based development tools like GitHub Copilot. As AI-generated code becomes more prevalent, careful reading and thorough review are essential to ensure correctness, maintainability, and security.

🤖 With the latest updates, Copilot code review is seamlessly integrated into Visual Studio Code, providing instant, AI-powered feedback directly in your editor.

Some of the key features include:

Review Selection: Highlight any section of code and request an initial review. Copilot will analyze the selected code and provide feedback, including suggestions for improvements or fixes, which you can apply with a single click.
Review Changes: Request a deeper review of all your staged or unstaged changes directly from the Source Control tab. Copilot will review your modifications and surface comments or suggestions inline and in the Problems tab.

📃 Find out more about these features in the GitHub Copilot documentation.

Code Review Custom Instructions

I already described how to ground Copilot Code Review with custom instructions in my previous post - Enforcing .NET Coding Guidelines with GitHub Copilot Custom Instructions. Basically, it boils down to something like this:

{
    "github.copilot.chat.reviewSelection.enabled": true,
    "github.copilot.chat.reviewSelection.instructions": [
        {
            "file": ".vscode/rules/csharp/coding-guidelines.md"
        }
    ]
}

Code Review in Agent Mode

Beyond the built-in features, I’ve crafted a custom code review prompt designed for agent mode. This approach aims to replicate the functionality of the Pull Request Review from Copilot.

While the standard Copilot Pull Request Review is excellent, it has certain limitations:

It’s restricted to the Web UI, requiring users to leave their IDE.
It cannot be used outside the GitHub environment.
It offers less capability compared to the Agent mode, which allows for the use of MCPs, model switching, etc.

Crafting the Review Prompt

Here is the prompt I use for code reviews:

🚀 https://github.com/NikiforovAll/dotnet-copilot-rules/blob/main/.vscode/prompts/code-review.prompt.md

The prompt has two logical sections:

Description : This section describes the purpose of the prompt and sets the context for the review.

 ---
 description: Perform a code review
 ---
 ## Code Review Expert: Detailed Analysis and Best Practices

 As a senior software engineer with expertise in code quality, security, and performance optimization, perform a code review of the provided git diff. 

 Focus on delivering actionable feedback in the following areas: (Skipped for brevity)

 Format your review using clear sections and bullet points. Include inline code references where applicable.

 Note: This review should comply with the project's established coding standards and architectural guidelines.

Constraints : This section outlines the specific constraints and guidelines that the code should adhere to.

 ## Constraints

 * **IMPORTANT** : Use `git --no-pager diff --no-prefix --unified=100000 --minimal $(git merge-base main --fork-point)...head` to get the diff for code review.
 * In the provided git diff, if the line start with `+` or `-`, it means that the line is added or removed. If the line starts with a space, it means that the line is unchanged. If the line starts with `@@`, it means that the line is a hunk header.

 * Use markdown for each suggestion, like
     ```


     # Code Review for ${feature_description}
     Overview of the code changes, including the purpose of the feature, any relevant context, and the files involved.

     # Suggestions
     ## ${code_review_emoji} ${Summary of the suggestion, include necessary context to understand suggestion}
     * **Priority** : ${priority: (🔥/⚠️/🟡/🟢)}
     * **File** : ${relative/path/to/file}
     * **Details** : ...
     * **Example** (if applicable): ...
     * **Suggested Change** (if applicable): (code snippet...)

     ## (other suggestions...)
     ...

     # Summary


     ```
 * Use the following emojis to indicate the priority of the suggestions:
     * 🔥 Critical
     * ⚠️ High
     * 🟡 Medium
     * 🟢 Low
 * Each suggestion should be prefixed with an emoji to indicate the type of suggestion:
     * 🔧 Change request
     * ❓ Question
     * ⛏️ Nitpick
     * ♻️ Refactor suggestion
     * 💭 Thought process or concern
     * 👍 Positive feedback
     * 📝 Explanatory note or fun fact
     * 🌱 Observation for future consideration

Basically, we ask Copilot to get the diff by running the git diff command and perform a code review based on the output from the terminal.

git --no-pager diff --no-prefix --unified=100000 --minimal $(git merge-base main --fork-point)...head

Demo

Let’s say we have a simple program that counts the number of capital letters in each line of a text file. We can use the code-review.prompt.md file to analyze the proposed solution.

string filePath = "path/to/your/file.txt";

FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);

StreamReader reader = new StreamReader(fileStream);
List<string> lines = new List<string>();

while (!reader.EndOfStream)
{
    string line = await reader.ReadLineAsync();
    lines.Add($"{new Guid()} - {line}[{CountCapitalLetters(line)}]");
}

foreach (string line in lines)
{
    Console.WriteLine(line);
}

// Counts the number of capital latters in a string, the typo in word 'latters' is intentional
int CountCapitalLetters(string input, string param1 = default, int param2 = 0, bool param3 = false, object param4 = null)
{
    int count = 0;
    foreach (char c in input)
    {
        if (char.IsUpper(c))
        {
            count++;
        }
    }

    return count;
}

We can attach the prompt by CTRL + ALT + / and select the code-review.prompt.md file. Then, we can ask Copilot to follow the instructions in the prompt and perform a code review.

✅ And here is the result of the code review:

I would say that the review is quite good. It is a good starting point to keep chatting with Copilot and ask for more details, or even to ask it to rewrite the code based on the suggestions.

💡 The great thing about this is that you can tailor the prompt to your specific needs. You can add or remove sections, change the wording, reference the project’s coding standards, etc.

💡 Treat Copilot as a coworker: start “Voice Chat” mode and engage in a conversation just as you would with a teammate. Ask questions, discuss suggestions, and iterate on solutions together to get the most out of your code review.

Conclusion

References

Prompt Engineering with GitHub Copilot in Visual Studio Code

Oleksii Nikiforov — Sat, 19 Apr 2025 00:00:00 +0000

TL;DR

Learn how to leverage reusable prompts in GitHub Copilot to enhance your productivity in Visual Studio Code.

Source code: https://github.com/NikiforovAll/dotnet-copilot-rules

Introduction

Prompt engineering in the right context can be a very powerful technique when working with LLMs.

In this blog post, I will not dive into the details of prompt engineering. For more information on prompt engineering, check out the Prompt Engineering Guide.

Why Prompt Engineering?

In the context of Visual Studio Code and GitHub Copilot, prompt engineering allows developers to create reusable instructions that streamline workflows, enforce coding standards, and improve collaboration. By leveraging reusable prompts, you can enhance Copilot’s ability to produce meaningful suggestions tailored to your specific needs.

Reusable Prompt Files in GitHub Copilot

GitHub Copilot introduces the concept of reusable prompt files. These files allow you to define task-specific instructions in a structured and reusable way.

You can define prompts at the workspace level, making them accessible to all team members. Or you can create them at the user level, making them available across all your projects.

Setting Up Reusable Prompt Files for Workspaces

Enable Prompt Files :

Open your .vscode/settings.json
Set the chat.promptFiles setting to true to enable reusable prompt files.

{
   "chat.promptFiles": true,
   "chat.promptFilesLocations": {
      ".github/prompts": true,
      ".vscode/prompts": true
   }
}

Now you can create a folder named .github/prompts or .vscode/prompts in your workspace. Inside this folder, you can create prompt files with the .prompt.md extension.

Later, you can attach these prompt files as context to your prompt.

Example

Here is an example of my pros-and-cons.prompt.md file:

---
description: Pros and Cons Analysis
---
# Definition:
Analyze the proposed solution, focusing on its strengths and weaknesses. Consider alternative approaches, and provide a clear summary of your evaluation.

## Constraints
- Ask follow-up questions if needed to clarify the solution. 
- If any questions arise, wait for the user to respond before proceeding with the analysis.
- Provide Pros and Cons in a bulleted list format.
- Highlight best practices and common pitfalls, where relevant.
- Suggest alternative solutions or improvements, if applicable.
- Provide pros and cons for alternative solutions if applicable. Provide at least 3 pros and cons for each alternative solution.
- Use provided emojis below to enhance readability:
- Use ✅ to highlight pros in the list.
- Use ❌ to indicate cons in the list.
- Use ✨ to highlight best practice items in the list.
- Use ☝️ to indicate common pitfalls.
- Use 🔒 to highlight security (InfoSec)-related topics.
- End with a single-paragraph summary of your overall assessment.

## Structure
- **Proposed Solution** : <NAME>
- **Description** : <DESCRIPTION>
- **Pros** :
- **Cons** :
- **Best Practices** :
- **Common Pitfalls** :

- **Alternative Solution** : <NAME>
- **Description** : <DESCRIPTION>

- **Pros** :
- **Cons** :

<!-- ... -->

🚀 Demo

Let’s say we want to implement Basic Authentication in some application. We can use the pros-and-cons.prompt.md file to analyze the proposed solution.

💡 The great thing about this is that you can tailor the prompt to your specific needs.

Other Use Cases

1️⃣ Generated Knowledge Prompting: Rather than including every detail in your initial prompt, you can instruct Copilot to ask clarifying questions. Your responses to these questions are then incorporated as context, enabling Copilot to generate more accurate and relevant code.

For example, here is my qa.prompt.md file:

---
description: Q&A Session
---
# Definition
Ask me a series of yes/no questions to better understand my needs and give a more accurate recommendation.

## Constraints
- Follow best practices, suggest best practices, and avoid common pitfalls.
- The questions should be relevant to the topic at hand.
- The questions should be clear and concise.
- Ask questions in batches of 5.
- Do not ask more than 5 questions.
- Ask all questions in one go.
- Do not proceed without my answer.

2️⃣ Generate Repeatable Code Constructs. Assume you have a specific approach to adding CRUD operations to your application. You can create a reusable prompt file that describes the process and use it in Agent mode to generate the whole feature.

3️⃣ Prompts as Artifacts. Instead of writing in the chat window directly, you can carefully craft the prompt file with necessary requirements and use it to generate the new feature. As a result, not only do you get things done, but you also have a nice artifact for future reference.

Conclusion

References

Composable AI with .NET Aspire: Extending DIAL Assistants with Add-Ons

Oleksii Nikiforov — Fri, 18 Apr 2025 00:00:00 +0000

TL;DR

Source code: https://github.com/NikiforovAll/ai-dial-dotnet

Table of Contents :

TL;DR
Introduction
Build the Assistant from Scratch
- Add DIAL Core
- Add Assistant with Addon
- Deploy OpenAI Model - GPT-4o
- Run Everything Together
Conclusion
References

Introduction

In my previous blog post, I’ve introduced you to DIAL, an open-source AI orchestration platform.

AI DIAL promises to be an extensible platform for building and deploying AI applications. In this post, we will learn how to add Addons to AI DIAL. Addons are a powerful way to extend the functionality of your AI applications by integrating with external services or APIs.

The great thing about DIAL Addons is that they are based on OpenAI GPT Actions (aka Plugins). At their core, GPT Actions leverage Function Calling to execute API calls.

In this blog, we will build a todo-assistant based on the official TODO Assistant from OpenAI. This Addon will allow us to manage our TODO list using natural language commands.

In AI DIAL, conversational agents enable direct interactions between end-users and applications or language models via the AI DIAL Chat interface or AI DIAL API.

Build the Assistant from Scratch

Let’s create empty Aspire AppHost project:

dotnet new aspire-apphost -n AppHost -o AppHost

The default Program.cs looks like this:

var builder = DistributedApplication.CreateBuilder(args);

builder.Build().Run();

Add DIAL Core

📦 Let’s install Aspire Host integration - Nall.EPAM.Dial.Aspire.Hosting.

dotnet add package Nall.EPAM.Dial.Aspire.Hosting

Now we can add the DIAL hosting to our application. The Program.cs file should look like this:

var builder = DistributedApplication.CreateBuilder(args);

var dial = builder.AddDial("dial", port: 8080).WithChatUI(port: 3000); // <--Adds DIAL and Chat UI

builder.Build().Run();

🚀 Now, we can use Aspire cli to run our application:

aspire run --project AppHost/AppHost.csproj

Here is the the Aspire Dashboard:

Add Assistant with Addon

Once we deployed the DIAL Core, we can add the Addon. The Addon is a simple HTTP API that will be called by the DIAL Core when it needs to execute an action.

🐋 Here is an example of Dockerfile of “TODO List” Addon:

FROM python:3.11-alpine AS builder

RUN apk update && apk add git
RUN git clone https://github.com/openai/plugins-quickstart.git

FROM python:3.11-alpine
COPY --from=builder /plugins-quickstart /plugins-quickstart

WORKDIR /plugins-quickstart
RUN pip install -r requirements.txt

EXPOSE 5003
CMD ["python", "main.py"]

We will run this addon as container using Aspire:

var builder = DistributedApplication.CreateBuilder(args);

var dial = builder.AddDial("dial", port: 8080).WithChatUI(port: 3000);

var todoAddonContainer = builder
    .AddDockerfile("todo-addon-container", contextPath: "addons", dockerfilePath: "TodoDockerfile")
    .WithHttpEndpoint(port: null, targetPort: 5003, "http");

builder.Build().Run();

Next, we wil register the Addon with the DIAL Core:

var builder = DistributedApplication.CreateBuilder(args);

var dial = builder.AddDial("dial", port: 8080).WithChatUI(port: 3000);

var todoAddonContainer = builder
    .AddDockerfile("todo-addon-container", contextPath: "addons", dockerfilePath: "TodoDockerfile")
    .WithHttpEndpoint(port: null, targetPort: 5003, "http");

var todoAddon = dial.AddAddon("todo-addon")
    .WithUpstream(todoAddonContainer)
    .WithDisplayName("TODO List")
    .WithDescription("Addon that allows to manage user's TODO list.");

dial.AddAssistantsBuilder()
    .AddAssistant("todo-assistant")
    .WithPrompt(
        "You are assistant that helps to manage TODO list for the user. You can add, remove and view your TODOs."
    )
    .WithDescription(
        "The assistant that manages your TODO list. It can add, remove and view your TODOs."
    )
    .WithDisplayName("TODO Assistant")
    .WithAddon(todoAddon);

builder.Build().Run();

🚀 Let’s run the AppHost and see the result:

aspire run --project AppHost/AppHost.csproj

Here is the ouput of the Aspire CLI:

And here is the Aspire Dashboard:

If you open the Chat UI, you will see the TODO Assistant:

☝️ But before we can use it, we need to deploy OpenAI model that supports Function Calling.

When you open Chat UI, you will see the following message - “Not available agent selected. Please, change the agent to proceed “.

Let’s fix this one.

Deploy OpenAI Model - GPT-4o

📦 We will add Azure OpenAI hosting integration to the AppHost:

dotnet add package Aspire.Hosting.Azure.CognitiveServices

Let’s add model deployment to the AppHost:

var builder = DistributedApplication.CreateBuilder(args);

var openAIApiKey = builder.AddParameter("azure-openai-api-key", secret: true);

var openai = builder
    .AddAzureOpenAI("openai")
    .ConfigureInfrastructure(infra =>
    {
        var resources = infra.GetProvisionableResources();
        var account = resources.OfType<CognitiveServicesAccount>().Single();
        account.Properties.DisableLocalAuth = false; // so we can use api key
    });
var gpt4o = openai.AddDeployment("gpt-4o", "gpt-4o", "2024-08-06");

Now we can register this model with the DIAL Core:

var dial = builder.AddDial("dial", port: 8080)
    .WithChatUI(port: 3000)
    .WaitFor(gpt4o); // <-- Wait for the model to be deployed

var dialGpt4o = dial.AddOpenAIModelAdapter("dial-gpt-4o", deploymentName: "gpt-4o")
    .WithUpstream(gpt4o, openAIApiKey)
    .WithDisplayName("gpt-4o")
    .WithDescription(
        "gpt-4o is engineered for speed and efficiency. Its advanced ability to handle complex queries with minimal resources can translate into cost savings and performance."
    )
    .WithWellKnownIcon(WellKnownIcon.GPT4);

Run Everything Together

And that is it! We have added the OpenAI model to our DIAL Core and we are ready to see how everything works together.

The final Program.cs file should look like this:

var builder = DistributedApplication.CreateBuilder(args);

var openAIApiKey = builder.AddParameter("azure-openai-api-key", secret: true);
var openai = builder
    .AddAzureOpenAI("openai")
    .ConfigureInfrastructure(infra =>
    {
        var resources = infra.GetProvisionableResources();
        var account = resources.OfType<CognitiveServicesAccount>().Single();
        account.Properties.DisableLocalAuth = false; // so we can use api key
    });
var gpt4o = openai.AddDeployment("gpt-4o", "gpt-4o", "2024-08-06");

var dial = builder.AddDial("dial", port: 8080).WithChatUI(port: 3000);

var dialGpt4o = dial.AddOpenAIModelAdapter("dial-gpt-4o", deploymentName: "gpt-4o")
    .WithUpstream(gpt4o, openAIApiKey)
    .WithDisplayName("gpt-4o")
    .WithDescription(
        "gpt-4o is engineered for speed and efficiency. Its advanced ability to handle complex queries with minimal resources can translate into cost savings and performance."
    )
    .WithWellKnownIcon(WellKnownIcon.GPT4);

var todoAddonContainer = builder
    .AddDockerfile("todo-addon-container", contextPath: "addons", dockerfilePath: "TodoDockerfile")
    .WithHttpEndpoint(port: null, targetPort: 5003, "http");

var todoAddon = dial.AddAddon("todo-addon")
    .WithUpstream(todoAddonContainer)
    .WithDisplayName("TODO List")
    .WithDescription("Addon that allows to manage user's TODO list.");

dial.AddAssistantsBuilder()
    .AddAssistant("todo-assistant")
    .WithPrompt(
        "You are assistant that helps to manage TODO list for the user. You can add, remove and view your TODOs."
    )
    .WithDescription(
        "The assistant that manages your TODO list. It can add, remove and view your TODOs."
    )
    .WithDisplayName("TODO Assistant")
    .WithAddon(todoAddon);

builder.Build().Run();

🚀 Let’s run the AppHost again:

aspire run --project AppHost/AppHost.csproj

Here is the output of the Aspire CLI:

And here is the the Aspire Dashboard:

✨ Even more interesting is Aspire Graph Dashboard:

Now, if you open the Chat UI, you will see the TODO Assistant. Let’s try to add some TODOs:

Conclusion

In this blog post, we have learned how to extend AI DIAL with Addons using .NET Aspire. We have built a simple TODO Assistant that allows us to manage our TODO list using natural language commands. We have also learned how to deploy OpenAI model that supports Function Calling and how to integrate it with the DIAL Core.

This is just the beginning of what you can do with AI DIAL and Addons. You can create more complex Addons that integrate with other services or APIs, or you can create your own custom Addons that provide unique functionality.

References

Learn how to use Model Context Protocol (MCP) Server Template in Hybrid Mode

Oleksii Nikiforov — Tue, 08 Apr 2025 00:00:00 +0000

TL;DR

TL;DR
Create from Template
- SSE vs Stdio
- Review the Code
Aspire Integration
Conclusion
References

Use the mcp-server-hybrid template to be able to easily switch between stdio and sse transports.

Source code: https://github.com/NikiforovAll/mcp-template-dotnet

Package	Version
`Nall.ModelContextProtocol.Template`
`Nall.ModelContextProtocol.Inspector.Aspire.Hosting`

Create from Template

Previously, I’ve shared with you the blog post - Simplifying Model Context Protocol (MCP) Server Development with Aspire. In this post we explored two ways to run the MCP server using Aspire.

🎯 In reality, depending on the context, you may want to run the MCP server in different ways. For example, you may want to run the MCP server in sse mode for debugging/development purposes, but in stdio mode for production.

In this post, I will show you how to use a simple template to create an MCP server that can be run in both modes.

📦 As in my previous post, let’s install Nall.ModelContextProtocol.Aspire.Template package:

dotnet new install Nall.ModelContextProtocol.Template
# These templates matched your input: 'mcp'

# Template Name Short Name Language Tags
# ----------------- ----------------- -------- -------------
# MCP Server mcp-server [C#] dotnet/ai/mcp
# MCP Server SSE mcp-server-sse [C#] dotnet/ai/mcp
# MCP Server Hybrid mcp-server-hybrid [C#] dotnet/ai/mcp

➕Create an mcp-server-hybrid project:

 dotnet new mcp-server-hybrid -o MyAwesomeMCPServer -n MyAwesomeMCPServer

Now we can run it in two different modes:

In SSE mode:

dotnet run
# info: Microsoft.Hosting.Lifetime[14]
# Now listening on: http://localhost:3001
# info: Microsoft.Hosting.Lifetime[0]
# Application started. Press Ctrl+C to shut down.
# info: Microsoft.Hosting.Lifetime[0]
# Hosting environment: Development
# info: Microsoft.Hosting.Lifetime[0]
# Content root path: ${HOME}/MyAwesomeMCPServer
# info: Microsoft.Hosting.Lifetime[0]

Start the MCP Inpsector and configure it to listen on the default address: “http://localhost:3001/sse”.

npx @modelcontextprotocol/inspector

In Stdio mode:

npx @modelcontextprotocol/inspector dotnet run -v q -- --stdio
# ⚙️ Proxy server listening on port 6277
# 🔍 MCP Inspector is up and running at http://127.0.0.1:6274 🚀
# New SSE connection
# Query parameters: {
# transportType: 'stdio',
# command: 'dotnet',
# args: 'run -v q --stdio'
# }
# Stdio transport: command=C:\Program Files\dotnet\dotnet.exe, args=run,-v,q,--stdio

SSE vs Stdio

The benefit of the SSE mode is that you can run the MCP server with a debugger attached and/or see the logs directly. The Stdio mode is slightly more complex, as it relies on the MCP Client (e.g., MCP Inspector) to start the server, and it disables logging on the MCP server to maintain compatibility with the MCP Client.

On the other hand, the Stdio Server’s lifetime is managed by the MCP Client. This makes it much easier to consume MCP servers in this mode because you typically don’t have to worry about the server’s lifetime. It is started by the MCP Client and stopped when the MCP Client is stopped.

Review the Code

Before you start developing your own MCPs using this template, let’s take a look at the code generated by the template. Here is a content of Program.cs:

var builder = WebApplication.CreateBuilder(args);
builder.WithMcpServer(args).WithToolsFromAssembly();

var app = builder.Build();
app.MapMcpServer(args);
app.Run();

[McpServerToolType]
public static class EchoTool
{
    [McpServerTool, Description("Echoes the message back to the client.")]
    public static string Echo(string message) => $"hello {message}";
}

💡 All “magic” happens in the McpServerExtensions.cs class. In the code below, we check if the --stdio argument is present. If it is, we configure the server to use the Stdio transport. Otherwise, we use the SSE transport. You don’t need to worry about how to switch between the two modes. The template does it for you.

public static IMcpServerBuilder WithMcpServer(this WebApplicationBuilder builder, string[] args)
{
    var isStdio = args.Contains("--stdio");

    if (isStdio)
    {
        builder.WebHost.UseUrls("http://*:0"); // random port

        // logs from stderr are shown in the inspector
        builder.Services.AddLogging(builder =>
            builder
                .AddConsole(consoleBuilder =>
                {
                    consoleBuilder.LogToStandardErrorThreshold = LogLevel.Trace;
                    consoleBuilder.FormatterName = "json";
                })
                .AddFilter(null, LogLevel.Warning)
        );
    }

    var mcpBuilder = isStdio
        ? builder.Services.AddMcpServer().WithStdioServerTransport()
        : builder.Services.AddMcpServer();

    return mcpBuilder;
}

public static WebApplication MapMcpServer(this WebApplication app, string[] args)
{
    var isSse = !args.Contains("--stdio");

    if (isSse)
    {
        app.MapMcp();
    }

    return app;
}

Aspire Integration

Down below I demonstrate how to run the MCP server using the Aspire hosting integration in two different modes simultaneously.

➕ Create AppHost:

dotnet new aspire-apphost -n AppHost -o AppHost

📦 Install Nall.ModelContextProtocol.Inspector.Aspire.Hosting package:

dotnet add ./Apphost package Nall.ModelContextProtocol.Inspector.Aspire.Hosting

🔗 Add project reference to AppHost:

dotnet add ./AppHost/AppHost.csproj reference ./MyAwesomeMCPServer/MyAwesomeMCPServer.csproj

Add the following code to Program.cs of the AppHost:

var builder = DistributedApplication.CreateBuilder(args);

var sse = builder.AddProject<Projects.MyAwesomeMCPServer>("server");
builder.AddMCPInspector("mcp-sse", serverPort: 9000, clientPort: 8080).WithSSE(sse);

builder
    .AddMCPInspector("mcp-stdio")
    .WithStdio<Projects.MyAwesomeMCPServer>();

builder.Build().Run();

Here is how the Aspire Dashboard looks like:

And it works like a charm!

Conclusion

References

Simplifying Model Context Protocol (MCP) Server Development with Aspire

Oleksii Nikiforov — Fri, 04 Apr 2025 00:00:00 +0000

TL;DR

TL;DR
Introduction
‘Stdio’ Mode
‘SSE’ Mode
Stdio vs SSE
Conclusion
References

You can use Nall.ModelContextProtocol.Inspector.Aspire.Hosting hosting integration to run MCP Inspector and integrate it with your MCP Servers using Aspire.

Source code: https://github.com/NikiforovAll/mcp-template-dotnet

Introduction

This blog will be in a form of tutorial, we will build a simple echo MCP server by using Nall.ModelContextProtocol.Template template that I’ve shared with you in the previous post.

🚀 Let’s get started. I want to demonstrate two ways (aka Transports) to run the MCP server: stdio and sse.

But first, let’s create Aspire project.

➕ Create AppHost:

dotnet new aspire-apphost -n AppHost -o AppHost

📦 Install Nall.ModelContextProtocol.Inspector.Aspire.Hosting package:

dotnet add ./Apphost package Nall.ModelContextProtocol.Inspector.Aspire.Hosting

📦 As in my previous post, let’s install Nall.ModelContextProtocol.Aspire.Template package:

dotnet new install Nall.ModelContextProtocol.Template
# These templates matched your input: 'mcp'

# Template Name Short Name Language Tags
# -------------- -------------- -------- -------------
# MCP Server mcp-server [C#] dotnet/ai/mcp
# MCP Server SSE mcp-server-sse [C#] dotnet/ai/mcp

‘Stdio’ Mode

➕Create an MCP server:

 dotnet new mcp-server -o MyAwesomeMCPServer -n MyAwesomeMCPServer

🔗 Add project reference to AppHost:

dotnet add ./AppHost/AppHost.csproj reference ./MyAwesomeMCPServer/MyAwesomeMCPServer.csproj

In Program.cs of the AppHost, add the following code:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddMCPInspector().WithStdio<Projects.MyAwesomeMCPServer>();

builder.Build().Run();

It run’s @modelcontextprotocol/inspector under the hood. It is an MCP proxy that allows you to test and debug MCP servers.

💡 Note: The Inspector is responsible for starting the .NET project. So, no corresponding Aspire Resource will be available on the dashboard for the ‘Stdio’ mode.

Open http://127.0.0.1:6274 in your browser and click “Connect.”. Now, you can test the server using the Inspector tool.

‘SSE’ Mode

Let’s generate a new MCP server using the sse transport. You can learn more about MCP transports here - https://modelcontextprotocol.io/docs/concepts/transports

➕ Create a new MCP server:

dotnet new mcp-server-sse -o MyAwesomeMCPServerSSE -n MyAwesomeMCPServerSSE

🔗 Add project reference to AppHost:

dotnet add ./AppHost/AppHost.csproj reference ./MyAwesomeMCPServerSSE/MyAwesomeMCPServerSSE.csproj

In Program.cs of the AppHost, add the following code:

var builder = DistributedApplication.CreateBuilder(args);

var mcp = builder.AddProject<Projects.MyAwesomeMCPServerSSE>("server"); // NOTE, for SSE mode it's a separate project
builder.AddMCPInspector().WithSSE(mcp);

builder.Build().Run();

The Aspire Dashboard looks slightly different for the sse mode. Because, this approach creates a separate Aspire.Hosting.ApplicationModel.ProjectResource with an exposed /sse endpoint. This endpoint allows you to seamlessly connect to the MCP server using the Inspector tool.

Open http://127.0.0.1:6274 in your browser and click “Connect.”. Now, you can test the server using the Inspector tool.

⚠️ As for now, it is not possible to specify sse endpoint in the Inspector command line to automatically configure MCP Inspector. I plan to extend the Aspire integration when the feature will be implemented - modelcontextprotocol/inspector/issues/239. For now, you have to configure the Inspector manually if you divert from standard configuration.

Stdio vs SSE

I demonstrated two approaches to running MCP servers. Personally, I favor the sse mode due to its transparency and ease of troubleshooting. For instance, you can launch an MCP server with a debugger attached or view the output logs directly. In contrast, the stdio mode relies on the Inspector to start the server, which disables logging on the MCP server to maintain compatibility with the Inspector.

Conclusion

I hope this blog post has provided you with a clear way to start building your own MCP servers using the Aspire hosting integration.

References

Simplifying Model Context Protocol (MCP) Server Distribution with .NET Global Tools

Oleksii Nikiforov — Wed, 02 Apr 2025 00:00:00 +0000

TL;DR

Use the Nall.ModelContextProtocol.Template template to create a Model Context Protocol (MCP) server that can be distributed as a global tool:

Install:

dotnet new install Nall.ModelContextProtocol.Template

Source code: https://github.com/NikiforovAll/mcp-template-dotnet

Introduction

In this post, I would like to show you how you can use .NET Global Tool to distribute your Model Context Protocol (MCP) server. I’ve created dotnet new template to support this approach and I will show you how to use it.

Getting Started

Install

dotnet new install Nall.ModelContextProtocol.Template

Verify installation:

dotnet new list mcp
# These templates matched your input: 'mcp'

# Template Name Short Name Language Tags
# ------------- ---------- -------- -------------
# MCP Server mcp-server [C#] dotnet/ai/mcp

Verify output:

dotnet new mcp-server -o MyAwesomeMCPServer -n MyAwesomeMCPServer --dry-run
# File actions would have been taken:
# Create: MyAwesomeMCPServer\.vscode\launch.json
# Create: MyAwesomeMCPServer\MyAwesomeMCPServer.csproj
# Create: MyAwesomeMCPServer\Program.cs
# Create: MyAwesomeMCPServer\Properties\launchSettings.json
# Create: MyAwesomeMCPServer\README.md
# Create: MyAwesomeMCPServer\appsettings.Development.json
# Create: MyAwesomeMCPServer\appsettings.json

Create from template:

dotnet new mcp-server -o MyAwesomeMCPServer -n MyAwesomeMCPServer

Here is a content of Program.cs:

using Microsoft.Extensions.Hosting;

var builder = Host.CreateApplicationBuilder(args);
builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithToolsFromAssembly();

await builder.Build().RunAsync();

[McpServerToolType]
public static class EchoTool
{
    [McpServerTool, Description("Echoes the message back to the client.")]
    public static string Echo(string message) => $"hello {message}";
}

It is a simple echo server that listens for incoming messages and responds with a greeting. You can add more tools by creating additional methods with the [McpServerTool] attribute. The WithToolsFromAssembly() method automatically registers all tools in the assembly.

Run Locally

⚙️ Build from the project directory:

dotnet build -o Artefacts -c Release

🚀 Run the inspector:

npx @modelcontextprotocol/inspector -e DOTNET_ENVIRONMENT=Production dotnet "$(PWD)/Artefacts/MyAwesomeMCPServer.dll"

Open inspector in your browser and test the server:

Distribute as .NET Tool

The basic idea behind this approach is to create a .NET tool that can be installed globally on the user’s machine. This allows users to run the MCP server from anywhere without needing to specify the full path to the executable.

📦 Pack from the project directory:

dotnet pack -o Artefacts -c Release

Install the tool globally:

dotnet tool install --global --add-source ./Artefacts MyAwesomeMCPServer
# You can invoke the tool using the following command: MyAwesomeMCPServer
# Tool 'myawesomemcpserver' (version '1.0.0') was successfully installed.

Now, after you installed this tool globally, you can run it from anywhere on your system. The tool will be available as MyAwesomeMCPServer (or myawesomemcpserver) in your terminal.

🚀 Run the inspector:

npx @modelcontextprotocol/inspector -e DOTNET_ENVIRONMENT=Production myawesomemcpserver

Conclusion

I think MCP opens up a lot of fun possibilities for building AI applications. In post, I showed you how to you mcp-server template to make your life a little easier.

References

Introducing AI DIAL: The Open-Source AI Orchestration Platform

Oleksii Nikiforov — Sun, 30 Mar 2025 00:00:00 +0000

TL;DR

Use AI DIAL to streamline and orchestrate Software Development Lifecycle (SDLC) for enterprise Gen AI applications. In this post, I will introduce you to the platform and its capabilities and show you how to get started with it using .NET Aspire.

Source code: https://github.com/NikiforovAll/ai-dial-dotnet

Table of Contents :

TL;DR
Introduction
Key Features
Getting Started via .NET Aspire
- Hosting Integration
- Client Integration
- Demo
Conclusion
References

Introduction

AI DIAL stands for D eterministic I ntegrator of A pplications and L anguage Models. It is an enterprise-grade, open-source AI orchestration platform that simplifies the development, deployment, and management of AI-driven applications. AI DIAL acts as both a development studio and an application server, enabling seamless integration between various AI models, data pipelines, and business applications.

See: DIAL 2.0: The Open Source AI Orchestration Platform Overview - YouTube

Key Features

🔗 Models Connectivity - provides out-of-the-box adapters for all major LLM providers, including all models hosted in Amazon Bedrock, Google’s Vertex AI, and Azure OpenAI Service. Additionally, you can use language models from the open-source community, alternative vendors, and fine-tuned micro models, as well as self-hosted or models listed on HuggingFace or DeepSeek. As of now, there are over 75 ready-to-use adapters, with more being added regularly. If necessary, DIAL SDK can be used to develop adapters for additional models and vendors. [Learn More]
💻 Application Server & Unified API - provides a single Unified API, based on OpenAI API, for accessing all language models, embedding models and applications. The key design principle is to create a unification layer that allows all models and applications to be interchangeable, delivering a cohesive conversational experience and future-proof development of custom GenAI applications.[Learn More]
🛠️ Extensibility - AI DIAL can be extended beyond its standard capabilities to meet specific business requirements. You can leverage the SDK to create custom model adapters and GenAI applications, and even include new application types to build fully custom implementations. AI DIAL Chat also enables the creation of custom chat UI components. [Learn More]
💬 Customizable Chat & Overlay - Powerful and highly customizable chat application for end-users, with enterprise-grade access control, extendable functionality and ability to add custom GenAI applications. Overlay enables a seamless embedding of chat into any existing web application. [Learn More]
➕ Marketplace - Marketplace gives access to all conversational agents available within the organization. Additionally, the marketplace offers collaboration tools for users and supports Role-Based Access Control (RBAC) to streamline teamwork and ensure secure access to resources. [Learn More]

Getting Started via .NET Aspire

Now, you know what DIAL is. Let’s see how to get started with it using .NET Aspire.

🎯 Goal. Let’s say we want to:

Create DIAL installation with two models: deepseek-r1 and phi3
Use DIAL Chat UI to interact with the models
Use them in our application programmatically through DIAL Unified API

Hosting Integration

First, we want to add DIAL hosting integration to AppHost project by adding the EPAM.Dial.Aspire.Hosting NuGet package:

dotnet add package EPAM.Dial.Aspire.Hosting

Then, we need to add the DIAL hosting integration to the AppHost/Program.cs:

var builder = DistributedApplication.CreateBuilder(args);

var ollama = builder
    .AddOllama("ollama")
    .WithDataVolume()
    .WithOpenWebUI();

ollama.AddModel("ollama-deepseek-r1", "deepseek-r1:1.5b");
ollama.AddModel("ollama-phi3", "phi3.5");

var dial = builder
    .AddDial("dial", port: 8080)
    .WaitFor(ollama)
    .WithChatUI(port: 3000);

var deepseek = dial.AddModel("deepseek", DeepSeekR1(ollama.Resource.PrimaryEndpoint));
var phi3 = dial.AddModel("phi3", Phi3(ollama.Resource.PrimaryEndpoint));

builder.AddProject<Projects.Api>("api")
    .WithReference(deepseek)
    .WithReference(phi3)
    .WaitFor(dial);

builder.Build().Run();

In the example above, we are adding the DIAL hosting integration to the AppHost project. We are also adding two models: ollama-deepseek-r1 and ollama-phi3, which are hosted on the Ollama server. We are also adding a DIAL Chat UI that will be available on port 3000.

💡 You are not limited to only self-hosted models. AI DIAL allows you to access models from all major LLM providers, language models from the open-source community, etc. See Supported Models for more information.

Now, we can open Aspire Dashboard and explore the component graph.

Let’s open the DIAL Chat UI and navigate to the marketplace to see the available models.

Select the deepseek model and click on the “Use Model” button. You will be redirected to the chat UI, where you can interact with the model.

The Chat UI is pretty powerful. For example, you can compare the output of two models by using Compare Mode. Here you can see the output of deepseek and phi3 models side by side.

Client Integration

Now, let’s see how to use the DIAL Unified API in our application. We will use the EPAM.Dial.Aspire NuGet package to access the IChatClient implementation to trigger chat completions.

dotnet add package EPAM.Dial.Aspire

All we need is to add the DialClient to the Api/Program.cs:

var builder = WebApplication.CreateBuilder(args);
builder.AddServiceDefaults();

builder.AddDialOpenAIClient`("deepseek").AddChatClient(); // <--- client integration

var app = builder.Build();

app.MapGet(
    "/chat",
    async ([FromQuery] string query, [FromServices] IChatClient client) =>
    {
        var prompt = $"You are helpful assistant. Answer the following question: '{query}'";
        var response = await client.GetResponseAsync(prompt);

        return Results.Ok(response);
    }
);
app.MapDefaultEndpoints();

app.Run();

In the example above, we are adding the DIAL client implementation of the IChatClient from Microsoft.Extensions.AI which is a standard way of integrating with LLMs in .NET.

💡 Note, it is called AddDialOpenAIClient because essentially, it adds OpenAI under the hood. This is possible because completion part of the Unified API is compatible with the OpenAI API.

Demo

🚀Now, let’s this in action:

curl --url 'http://localhost:5181/chat?query=Test'

Output:

{
  "messages": [
    {
      "authorName": null,
      "role": "assistant",
      "contents": [
        {
          "$type": "text",
          "text": "<think>\n\n</think>\n\nIt seems like you might be referring to a \"test\" or something related to testing, but I don’t have specific information about what you’re asking. Could you clarify your needs? Are you asking about how to perform a test, taking a test as part of an educational purpose, or something else? Let me know so I can assist you better!",
          "additionalProperties": null
        }
      ],
      "messageId": "chatcmpl-161",
      "additionalProperties": null
    }
  ],
  "responseId": "chatcmpl-161",
  "chatThreadId": null,
  "modelId": "deepseek-r1:1.5b",
  "createdAt": "2025-03-30T13:05:43+00:00",
  "finishReason": "stop",
  "usage": {
    "inputTokenCount": 16,
    "outputTokenCount": 76,
    "totalTokenCount": 92,
    "additionalCounts": {}
  },
  "additionalProperties": {
    "SystemFingerprint": "fp_ollama"
  }
}

Conclusion

🙌 In this post, I have introduced you to AI DIAL, an open-source AI orchestration platform that simplifies the development, deployment, and management of AI-driven applications. I have also shown you how to get started with it using .NET Aspire.

This is just the a scratch of the surface of what you can do with DIAL. I encourage you to explore the platform and its capabilities further. Let me know if you are interested in more posts about DIAL and its features.

DEV Community: Oleksii Nikiforov

Introducing Technical Debt Master: AI-Powered Code Analysis with Local LLMs

TL;DR

Motivation

tdm workflow

Let’s Get Started

Installation

Configuration

Technical Debt Discovery

Triaging Technical Debt

Technical Debt Resolution

References

Monitoring Claude Code with .NET Aspire Dashboard

Introduction

Setting Up .NET Aspire Dashboard

Configuring Claude Code Telemetry

Using the Dashboard

My Claude Code Usage Best Practices and Recommendations

Practical Recommendations

Planning

AI Task-Based Development

Knowledge Mining / Grounding

Miscellaneous

MCP Servers

🎁 Bonus: Turn Claude Code into an Interactive Tutor with Microsoft Docs & Context7

Useful Links

Hangfire MCP Server in Standalone Mode

TL;DR

Aspire (Bonus)

Conclusion

References

Background Job Scheduling Using Hangfire MCP Server

TL;DR

Motivation

Setup MCP Server

Code Deep Dive

Hangfire MCP Server

Conclusion

References

Code Review with GitHub Copilot in Visual Studio Code

TL;DR

Introduction

Code Review Custom Instructions

Code Review in Agent Mode

Crafting the Review Prompt

Demo

Conclusion

References

Prompt Engineering with GitHub Copilot in Visual Studio Code

TL;DR

Introduction

Reusable Prompt Files in GitHub Copilot

Setting Up Reusable Prompt Files for Workspaces

Example

🚀 Demo

Other Use Cases

Conclusion

References

Composable AI with .NET Aspire: Extending DIAL Assistants with Add-Ons

TL;DR

Introduction

Build the Assistant from Scratch

Add DIAL Core

Add Assistant with Addon

Deploy OpenAI Model - GPT-4o

Run Everything Together

Conclusion

References

Learn how to use Model Context Protocol (MCP) Server Template in Hybrid Mode

TL;DR

Create from Template

SSE vs Stdio

Review the Code

Aspire Integration

Conclusion

References

Simplifying Model Context Protocol (MCP) Server Development with Aspire

TL;DR

Introduction

‘Stdio’ Mode

`tdm` workflow