DEV Community: Antonio Di Motta

MCP Server with .Net

Antonio Di Motta — Thu, 12 Mar 2026 22:52:52 +0000

With the release 1.0 of the official ModelContextProtocol .Net SDK, we are ready to make a MCP Server fully compliant with MCP specs and entirely in C#.

As usually when I need to learn new stuffs I develop a simple demo around a real scenario. For the MCP Server I thought to build one for managing some data like customers, products and orders stored into a Postgres database.

The MCP server provides the data on behalf of user prompt like:

    give me the customer list
    tell me the most expensive order
    how many USB-C Hub has been ordered ?
    give me the customer list without orders
    suggest a new product for the customer Jane Smith
    add new order
    .....

The most important feature of MCP Server is the tool as function able to do something. Below an example of tool:

[McpServerTool(Name = "GetCustomer"), Description("Retrieve a single customer from the database.")]
public static async Task<object> GetCustomer(AppDbContext db, CancellationToken ct, ILogger<MCPTool> logger, [Description("Full name of the customer to retrieve.")] string fullName ){
        logger.LogDebug( $"Executing GetCustomer tool with full name : {fullName }" );

  var query = db.Customers.AsNoTracking();
  var result = await query.Where(c => (c.FirstName + " " + c.LastName) == fullName)
                          .FirstOrDefaultAsync(ct);

  if (result == null)
     return $"Customer with full name {fullName} not found.";

  return result;
}

The example shows how to help llm to recognize the right tool by using specific custom attributes [McpServerTool].

Another interesting feature is the prompt. I implemented one to create a model capable of handling requests that require more complex and detailed context for responses.

Here an example:

[McpServerPrompt, Description("Generate product suggestion for new order prompt")]
public static IEnumerable<ChatMessage> SuggestProductByCustomer(
        [Description("Full name of the customer")] string fullName )
{
        return [
            new(ChatRole.System, "You are an assistant for an e-commerce platform. You help customers find products based on their preferences and past purchases."),
            new(ChatRole.User, $"Please suggest products for the customer with full name: {fullName}"),
            new(ChatRole.Assistant, "To suggest products for the customer, I will need to look up their past purchases and preferences in the database. I will use the GetCustomer and GetOrders tools to retrieve this information and then analyze it to find suitable product suggestions.")
        ];
}

The entire demo is available here. It contains a dev setup environment which able to spin up quickly the Postgres database with already some test data.

happy coding!

Azure Key Vault for local development

Antonio Di Motta — Sun, 23 Jul 2023 16:01:05 +0000

One of the most huge mistakes that a developer can do It's storing secrets (i.e. database connection string) directly into the source code repository and also forgetting one could be very dangerous.

Ideally, all secrets should be stored and accessible by a secret manager (Azure Key Vault) and stored on repository only reference to right secret. On the other hand, the developer needs to use the secret's values on their configuration files (i.e. appSettings.json), so a fast way for retrieve them from Key Vault should be nice.

To accomplish this operation I have developed a powershell script called Set-ValuesFromKeyVault, which I have included an example of using it below.

Example

We want replace the key vault references into the following json file:

{
  "parent-property1": "@Microsoft.KeyVault(SecretUri=https://<<your-keyvault-resource>>.vault.azure.net/secrets/<<your-secret1>>)",
  "Values":
  {    
    "nested-property2": "@Microsoft.KeyVault(SecretUri=https://<<your-keyvault-resource>>.vault.azure.net/secrets/<<your-secret2>>)",
    "nested-property3": "@Microsoft.KeyVault(SecretUri=https://<<your-keyvault-resource>>.vault.azure.net/secrets/<<your-secret3>>)",
    "non-keyvault-binding-property": "<<any-value>>"
  }
}

To do that, first establish a connection to an Azure account and than execute the powershell script as reported below:

# connect to azure
Connect-AzAccount

# execute the replace on data.json file
./Set-ValuesFromKeyVault.ps1 -FileName data.json

The result will be a new json file called out.json within the secrets replaced as this:

{
  "parent-property1": "<<your-secret1-value>>",
  "Values":
  {    
    "nested-property2": "<<your-secret2-value>>",
    "nested-property3": "<<your-secret3-value>>",
    "non-keyvault-binding-property": "<<any-value>>"
  }
}

The script is available on my repository.

The powershell way to validate Azure infrastructure

Antonio Di Motta — Sun, 19 Feb 2023 12:10:48 +0000

One of the most important challenge in the cloud era is to use the flexibility provided in the most productive way possible for our projects. To help about this Microsoft provides a set of guiding tenets called Azure Well-Architected Framework, that can be used to improve the quality of a workload.

The framework consists of five pillars of architectural excellence:

The set of rules are available directly on Microsoft documentation.

To validate an infrastructure about the following of rules, we can use Azure Advisor which is able to make an assessment review of the resources provisioned by generating a set of recommendations.

As devops I prefer an alternative way based on Powershell called PSRule for Azure which provides a suite of rules to validate resources and infrastructure as code (IaC) using PSRule. It provides two methods for analyzing Azure resources:

Pre-flight - Before resources are deployed from Azure Resource Manager templates.
In-flight - After resources are deployed to an Azure subscription.

Below an example of In-flight use:

# STEP 1: Install PSRule.Rules.Azure from the PowerShell Gallery
Install-Module -Name 'PSRule.Rules.Azure' -Scope CurrentUser;

# STEP 2: Authenticate to Azure, only required if not currently connected
Connect-AzAccount;

# Confirm the current subscription context
Get-AzContext;

# STEP 3: Exports a resource graph stored as JSON for analysis
Export-AzRuleData -OutputPath 'out/templates/';

# STEP 4: Run analysis against exported data
Invoke-PSRule -InputPath 'out/templates/' -Module 'PSRule.Rules.Azure' -As Summary;

RuleName                            Pass  Fail  Outcome
--------                            ----  ----  -------
Azure.ACR.MinSku                    0     1     Fail
Azure.AppService.PlanInstanceCount  0     1     Fail
Azure.AppService.UseHTTPS           0     2     Fail
Azure.Resource.UseTags              73    36    Fail
Azure.SQL.ThreatDetection           0     1     Fail
Azure.SQL.Auditing                  0     1     Fail
Azure.Storage.UseReplication        1     7     Fail
Azure.Storage.SecureTransferRequ... 2     6     Fail
Azure.Storage.SoftDelete            0     8     Fail

Some examples of PSRule for Azure module usage are:

Managing Powershell collections graphically

Antonio Di Motta — Sat, 28 Jan 2023 15:36:25 +0000

One of the most interesting features of Powershell is manipulation of data as object collections, which is a feature inherited from the .net platform.

A collection (eg array) can be the result of powershell command and it could contain a lot of objects but only a subset of them could be interesting. To facilitate the selection of data subset, exists a Powershell Cmdlet console-based GUI called Out-ConsoleGridView.

# installation
Install-Module Microsoft.PowerShell.ConsoleGuiTools

# usage example1:
PS C:\> Get-Process | Out-ConsoleGridView

As you can see the tool is always integrated into the terminal because it has built on a cross platform UI toolkit based on a fantastic open source project called Terminal.Gui. Now you can select the objects by using space bar and than confirm the selection with enter.
The result will be:

As you noted the result its still a collection so we can use it by pipe with another Powershell command:

# usage example2:
PS C:\> Get-Process | Out-ConsoleGridView | Export-Csv -Path .\ProcessLog.csv

Powershell Secret Store

Antonio Di Motta — Tue, 10 Jan 2023 10:46:34 +0000

As devops I have to use a lot of secrets for managing my projects which are complex and requires several environments (dev,sit,uat,e2e,prod...), so the number of secrets to manage can grow quickly.

Where to store secrets Its important because are critical information and incorrect management can create huge problems for the security of the applications. When deploy the application we use a secret management service like Azure Key Vault, but what can we do with secrets saved on personal machine? If you are using a simple plain text file then you are making a mistake.

A better idea is also have Key Vault on personal machine, so I decided to use Powershell Secret Store which is an extension vault module for the PowerShell SecretManagement module. It stores secrets locally on file for the current user account context, and uses .NET crypto APIs to encrypt file contents. Secrets remain encrypted in-memory, and are only decrypted when retrieved and passed to the user.

Next an example of use:

# install secret management module
Install-Module -Name Microsoft.PowerShell.SecretManagement
# install extension vault to store secrets to the local machine
Install-Module -Name Microsoft.PowerShell.SecretStore

# register a new local secret store
Register-SecretVault -Name mySecretStore -ModuleName Microsoft.PowerShell.SecretStore -DefaultVault

# add two secrets to mySecretStore 
Set-Secret secret1 -Vault mySecretStore -Secret "this-is-the-value-for-secret1" -metadata @{"envname"="dev";"varname"="var1"} 
Set-Secret secret2 -Vault mySecretStore -Secret "this-is-the-value-for-secret2" -metadata @{"envname"="dev";"varname"="var2"}

# show the list of secrets stored into mySecretStore
PS > get-secretinfo -vault mySecretStore | fl

Name      : secret1
Type      : String
VaultName : mySecretStore
Metadata  : {[varname, var1], [envname, dev]}

Name      : secret2
Type      : String
VaultName : mySecretStore
Metadata  : {[varname, var2], [envname, dev]}

# retrieve secret value
PS > get-secret secret1 -vault mySecretStore -asplaintext
this-is-the-value-for-secret1

As you noted Its possible define a set of metadata for each secret, so I decided to use this capability for improving the process of secret retrieve. For example, I defined an envname for better separation of contexts and varname to automate the process of the powershell variables creation to store the secrets in memory.

I implemented this logic into a function called Set-VariablesFromVault which is able retrieve secrets by envname and store them into variables with name format envname_varname. Below an example of use:

# import my functions for loading secrets
Import-Module .\ADMsecret.psm1

# create powershell variables with secret values based metadata envname and varname
Set-VariablesFromVault -vaultname mySecretStore -envname dev

# check the results
PS > get-variable

Name                     Value
----                     -----
dev_var1                 this-is-the-value-for-secret1
dev_var2                 this-is-the-value-for-secret2
......................................................

The code of Set-VariablesFromVault is available here

PowerShell Secret Management

Antonio Di Motta — Thu, 17 Nov 2022 16:17:54 +0000

A secret management is the best way for securely storing and accessing secrets which are anything that you want to tightly control access to, such as API keys, passwords, certificates, or cryptographic keys.

All major cloud providers have a secret management service, for instance Azure Key Vault and AWS Secrets Manager. Usually the common way for managing these services is by web portal or CLI.

Another way to manage secrets is by using PowerShell SecretManagement Module. Next the description of the module grabbed directly from the github repository:

"PowerShell SecretManagement module provides a convenient way for an user to store and retrieve secrets. The secrets are stored in SecretManagement extension vaults. An extension vault is a PowerShell module that has been registered to SecretManagement. An extension vault can store secrets locally or remotely. Extension vaults are registered to the current logged in user context, and will be available only to that user (unless also registered to other users)."

Now, I'm going to describe how to manage secrets stored on Azure Key Vault.

Step 1, install the required modules:

# install secretmanagement module
PS > Install-Module -Name Microsoft.PowerShell.SecretManagement

# install extension vault provider for Azure KeyVault
PS > Install-Module -Name Az.KeyVault

# tip to find the extension vault providers available
PS > Find-Module -tag "SecretManagement"

Step 2, register the extension vault to the current user:

PS > $subId = "<<keyvault-subscriptionid>>"
PS > $vaultName = "<<keyvault-name>>"
PS > Register-SecretVault -Name myAzKV -ModuleName Az.KeyVault -VaultParameters @{AZKVaultName=$vaultName;SubscriptionId=$subId}

# tip to show the list of extension vault registered (can have more)
PS > Get-SecretVault

Name   ModuleName  IsDefaultVault
----   ----------  --------------
myAzKV Az.KeyVault True

Step 3, show the secrets currently stored on registered extension vault:

# get list of secrets
PS > Get-SecretInfo

Name    Type     VaultName
----    ----     ---------
key1    Unknown  myAzKV
key2    Unknown  myAzKV

Step 4, store a new secret

PS > Set-Secret key3 -Vault myAzKV
cmdlet Set-Secret at command pipeline position 1
Supply values for the following parameters:
SecureStringSecret: ***********

# tip add metadata to secret
PS > Set-SecretInfo key3 -Metadata @{"purpose"="demo"}

Step 5, retrieve the contents of a secret

# get secret contents
PS > Get-Secret key3 -AsPlainText -vault myAzKV
Hello World

Thanks for reading!

Expand-JsonFile

Antonio Di Motta — Mon, 17 Oct 2022 17:40:54 +0000

Json format is an amazing way to define things, so devs often use it into the code repository to describe entities. Devops also uses json files to configure application or other stuff.

Proliferation of the number of json files and inconsistent data could be a problem, so to avoid them I have created a small powershell script that is able to resolve expressions contained into json file. The expression defines the correlation between different files.

Example:

Into the data folder there are three json files:

customers.json (which contains a set of customer)
products.json (which contains a set of product)
orders.json (which contains a set of order)

The orders.json has two properties (product and customer) which need to be calculated by evaluating a reference expression:

// orders.json
[
    {
        "created":"2022-10-15T09:00:00",
        "product":"[data/products(pid=1).title]",
        "quantity":1,
        "customer":"[data/customers(cid=3).name]",
        "notes":"this is a note"
    },
    {
        "created":"2022-10-15T10:00:00",
        "product":"[data/products(pid=2).title]",
        "quantity":2,
        "customer":"[data/customers(cid=3).name]",
        "notes":"this is a note2"
    }
]

The function Expand-JsonFile evaluates the reference expressions contained in the orders.json file and produce a new file:

import-module -name .\ADMjson.psm1 -Force
Expand-JsonFile -SourceFile data/orders.json -TargetFile data/orders_expanded.json

The result json file contains property values:

// orders_expanded.json
[
    {
        "created": "2022-10-15T09:00:00",
        "product": "xbox",
        "quantity": 1,
        "customer": "Paperino",
        "notes": "this is a note"
    },
    {
        "created": "2022-10-15T10:00:00",
        "product": "playstation",
        "quantity": 2,
        "customer": "Paperino",
        "notes": "this is a note2"
    }
]

The script code is available here

Postgres environment with docker-compose

Antonio Di Motta — Fri, 08 Jul 2022 21:08:15 +0000

Are you looking for a way to start a new development environment quickly? If this is the case this article could be useful for you.

Summarizing the Wikipedia definition, an environment is a set of resources able to run a software solution. Generally its possible to have many environments each of which has specific goal. For instance, development (dev), system integration test (sit), end to end test (e2e), user acceptance test (uat) and production (prod). All of these must be completely isolated each other, for example we should be sure that the front-end of sit is not able to connect to database of e2e. To do that, we have to design the network system and storage system to avoid any overlaps even if it happens accidentally and if we have many environments it can become a hard job.

Docker-compose is a great tool to start an environment creating all compute resources to run the solution but also the infrastructure resources like networking and storage ready to guarantee the isolation required. To prove this, I wrote a docker-compose yaml file which is able to start a solution based on:

Postgres, as database server
Pgadmin, as postgres management tool
NGinx, as reverse proxy

Next, I parametrized the composer yaml with a .env properties file which contains some environment parameters:

ENV_NAME=<<environment-name>>
NGINX_RELEASE=1.21
NGINX_HOSTPORT=8081
POSTGRES_RELEASE=12
POSTGRES_USER=<<postgres-user>>
POSTGRES_PASSWORD=<<postgres-password>>
PGADMIN_RELEASE=latest
PGADMIN_EMAIL=<<pgadmin-user>>
PGADMIN_PASSWORD=<<pgadmin-password>>

The most important of them is the first one ENV_NAME is used for identify the scope of networks, volumes and containers. Below an example of how to use it.

# Use postgres/example user/password credentials
version: '3.7'

services:
  proxy:
    image: nginx:${NGINX_RELEASE}
    container_name: ${ENV_NAME}_nginx
    restart: unless-stopped
    environment:
      NGINX_HOST: ${ENV_NAME}
      NGINX_PORT: ${NGINX_HOSTPORT}
    networks:
      - frontend
    volumes:
      - ./config/templates:/etc/nginx/templates
      - ./config/certs:/etc/nginx/certs
    ports:
      - ${NGINX_HOSTPORT}:${NGINX_HOSTPORT}
      - 443:443

  pgadmin:
    image: dpage/pgadmin4:${PGADMIN_RELEASE}
    container_name: ${ENV_NAME}_pgadmin
    depends_on:
      - postgres
    environment:
      PGADMIN_DEFAULT_EMAIL: ${PGADMIN_EMAIL}
      PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_PASSWORD}
    networks:
      - frontend
      - backend
    volumes:
      - pga_data:/var/lib/pgadmin

  postgres:
    image: postgres:${POSTGRES_RELEASE}
    container_name: ${ENV_NAME}_postgres
    restart: always
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - ps_data:/var/lib/postgresql/data
    networks:
      - backend     

volumes:
  ps_data:
    name: ${ENV_NAME}_postgres
  pga_data:
    name: ${ENV_NAME}_pgadmin

networks:
  frontend:
    name: ${ENV_NAME}_frontend
  backend:
    name: ${ENV_NAME}_backend

For example if ENV_NAME is demo_dev we will have the following result:

As you can see the networks, the volumes and the containers names have been customized, so if we will start again the composer with different environments parameters, we will have a new environment isolated from the previous one.

The code is available on my github repository.

BulkRun Powershell Script for Azure Pipelines

Antonio Di Motta — Sun, 12 Jun 2022 10:36:35 +0000

Azure Devops provides a great UI for managing and run the pipelines, but sometimes we need to run it manually, just to reuse the deployment logic or when its required to run many of them.

To accomplish this job, I created a simple powershell script to run a set of pipeline programmatically by using the Azure Devops rest API and it requires a Personal Access Token

Example

# Step 1: Create the pipeline on Azure Devops with following yaml code. Below an example with parameters.

parameters:
  - name: name
    displayName: "Name"
    type: string
  - name: surname
    displayName: "Surname"
    type: string

pool:
  vmImage: ubuntu-latest

steps:
- script: echo Hello ${{ parameters.name }} ${{ parameters.surname }}
  displayName: 'Run a one-line script'

# Step 2: Create a pipeline definition file (pipetorun.csv) with the information to run an ado pipeline for each row.
# The definitionid is the definitionid of Azure Devops pipeline
# Branch is the pipeline's branch.
# Parameters are defined as a dictionary (key=value separate by semicolon, key is equal the pipeline parameter name)

definitionid,name,branch,parameters
12,hello,main,name=Alan;surname=Turing
12,hello,main,name=Clude;surname=Shannon
12,hello,main,name=Tim;surname=Berners-Lee
12,hello,main,name=Edsger;surname=Dijkstra
12,hello,main,name=Leslie;surname=Lamport

# Step 3: Run five pipeline by using the script and the defintion file. (How to create a PAT )

.\BulkRun.ps1 -PAT personal-access-token -File .\pipetorun.csv

# Result

hello inProgress on main -> https://dev.azure.com/dimotta/demo/_build/results?buildId=119
hello inProgress on main -> https://dev.azure.com/dimotta/demo/_build/results?buildId=120
hello inProgress on main -> https://dev.azure.com/dimotta/demo/_build/results?buildId=121
hello inProgress on main -> https://dev.azure.com/dimotta/demo/_build/results?buildId=122
hello inProgress on main -> https://dev.azure.com/dimotta/demo/_build/results?buildId=123

The BulkRun script code is available here

Powershell Confluence Scripts

Antonio Di Motta — Mon, 25 Apr 2022 18:00:26 +0000

As a devops sometimes I need to create small scripts to include in my pipelines for managing recurring tasks. To carry out this kind of activity powershell provides great features to develop script quickly.

Lately, I needed to create a Confluence's page as the last task of a pipeline with some information reported on it, so I decided to create a small library for this purpose.

The library needs of a Atlassian api token which is provided by https://id.atlassian.com/manage-profile/security/api-tokens

Here are some examples of using the library.

entity2sql

Antonio Di Motta — Sat, 16 May 2020 10:40:21 +0000

I have always had a strong interest in making small libraries that could facilitate the life of a developer. The most useful libraries are those that allow you to solve recurring problems ( possibly without creating others :) )

For this purpose, some time ago, I created a library that would allow me to generate SQL code from the definition of classes that represented my entity data model. It is not an ORM (complete or micro) but a simple generator of SQL code.

I know that there are already many excellent solutions around, but for me, it was an opportunity to analyze an interesting problem and at the same time have full control of the SQL code that I wanted to generate.

The final result is the following:

var sqlBuilder = new SQLStatementBuilder();

var select = sqlBuilder.MakeSelect<User>( o => o.FirstName == "Antonio" || o.LastName == "Di Motta" && o.Age == 150 );
// SELECT t1.ID,t1.FIRST_NAME,t1.LAST_NAME,t1.AGE,t1.RoleID FROM USERS t1 WHERE (t1.FIRST_NAME = 'Antonio' OR (t1.LAST_NAME = 'Di Motta' AND t1.AGE = 150 ))

var join = sqlBuilder.MakeJoin<User,Role>( (u,r) => u.Role.Id == r.Id );
// SELECT t1.ID,t1.FIRST_NAME,t1.LAST_NAME,t1.AGE,t1.RoleID,t2.ID,t2.NAME FROM USERS t1 INNER JOIN ROLES t2 ON t1.RoleID=t2.ID

In order to generate the SQL code, I added metadata (by custom attribute) to the classes of the domain model, below an example:

[TableMap( Name = "USERS" )]
public class User
{
    [PKeyMap( Name ="ID")]
    public int Id { get; set; }

    [ColumnMap( Name ="FIRST_NAME")]
    public string FirstName { get; set; }

    [ColumnMap( Name = "LAST_NAME" )]
    public string LastName { get; set; }

    [ColumnMap( Name = "AGE" )]
    public int Age { get; set; }

    [ColumnMap( Name = "RoleID" )]
    public Role Role { get; set; }
}

[TableMap( Name = "ROLES" )]
public class Role
{
    [PKeyMap( Name = "ID" )]
    public int Id { get; set; }

    [ColumnMap( Name = "NAME" )]
    public string Name { get; set; }
}

The main classes of the library are SQLStatementBuilder and EntityInfo.
The first generates the SQL code by reading the metadata via reflection, which is a very expensive operation in terms of speed, for this reason, it maintains an EntityInfo dictionary for each entity whose metadata it has read.

EntityInfo retains metadata information and It is created on first access to the entity, from the second access on it will no longer be necessary to use reflection.

The code of the entire project is available here

Any advice is welcome.