You can\u2019t run to the grocery store these days without hearing about the Model Context Protocol (MCP)! Well, I hope the grocery store is your safe haven from AI, but the fact is that MCP is one of the hottest and most talked about topics in software development. And I\u2019m going to keep talking about it because I want to show you a brand new experimental preview feature of Azure Functions that takes a ton of work out of creating remote MCP Servers and brings all the goodness of Azure Functions to the equation too.<\/p>\n\n
The Model Context Protocol is nothing more than a specification that makes it easier for AI applications to talk to tooling of some sort.<\/p>\n
And generally speaking, that tooling will provide\/expose some core business functionality. Like maybe an API of sorts that stores and returns data from Azure Blob Storage.<\/p>\n
So here\u2019s the situation: you\u2019re going to have a chat interface of some sort that uses an LLM. How do you get it so that when the LLM is responding to a prompt it knows to invoke the tooling? That\u2019s where MCP comes in.<\/p>\n
But MCP is a spec \u2013 and that means you have to implement it yourself. And plumbing code is no fun. So that\u2019s what I\u2019m really<\/em> here to show you today, how to create a remote MCP server using Azure Functions.<\/p>\n You may have noticed I\u2019m being very intentional to specify remote MCP server<\/em>. And there\u2019s a reason for that.<\/p>\n Right now the most common scenario that involves MCP is a client running locally, like VS Code or Claude Desktop, that has an extension that acts the MCP client (think GitHub Copilot for VS Code) that uses an LLM to call a MCP server also running locally. The MCP server is usually hosted in a Docker container.<\/p>\n But it gets old pretty quickly to install the same MCP server locally everywhere you may need it. Much less making sure people on your team have the same version installed \u2013 it\u2019s like taking care of a desktop app.<\/p>\n Remote MCP servers run remotely. As long as the endpoint supports server-side events (SSE), you\u2019re good to go.<\/p>\n Azure Functions is an event-based serverless product. To me, the defining feature of Functions is its ability to seamlessly integrate with other Azure services just be adding attributes to the function definition.<\/p>\n For example, if you want to write to a blob in Azure Storage just decorate your function definition with [BlobOutput(blobPath)] and whatever value you return from the function gets written to the blob specified in blobPath.<\/p>\n The Functions team recently released an experimental preview that turns a function app into a MCP Server via a [MCPToolTrigger] attribute. So now it\u2019s amazingly simple to build an MCP server by using the straightforward development experience of Azure Functions and<\/em> you still get all the great Azure integration you\u2019ve come to expect too!<\/p>\n Instead of doing a file->new sample, let\u2019s start from one that\u2019s already ready to go and explore its defining characteristics. Head over to the Remote MCP Functions Sample<\/a> repo to fork\/clone\/download or just follow along with the code.<\/p>\n This function app lets users highlight text in the editor of VS Code and ask GitHub Copilot to save it with a name. You can then retrieve it using the name you saved it as.<\/p>\n First things first. If you open up the FunctionsMcpTool.csproj<\/strong> you\u2019ll see that there\u2019s a NuGet package called Microsoft.Azure.Functions.Worker.Extensions.Mcp<\/strong>. This is the one that adds all the MCP-ness to the Function app.<\/p>\n Now checkout Program.cs<\/strong>. See the line builder.EnableMcpToolMetaData()? That\u2019s going to expose the metadata of each function, like name and description, to the client so the LLM is able to figure out when to invoke it.<\/p>\n Head on over to SnippetsTool.cs<\/strong>. There are 2 functions here. SaveSnippet<\/strong> adds text as a blob to Azure Storage. And the other, GetSnippet<\/strong> returns the text stored in the blob.<\/p>\n Let\u2019s see how to save some text as a blob:<\/p>\n [Function(nameof(SaveSnippet))] Let\u2019s explain this a bit as there\u2019s a lot of constants being passed in to the properties.<\/p>\n [McpToolTrigger]: This defines the function as a something that can be invoked from the MCP client. SaveSnippetToolName and SaveSnippetToolDescription are constants from the ToolsInformation.cs<\/strong> that the builder.EnableMcpToolMetaData() uses to help the client\u2019s LLM know when to invoke this function. Then because this function is decorated with BlobOutput anything we return from it will be written to blob storage. And in this case that is the snippet that was sent from the MCP client.<\/p>\n Cool? Cool.<\/p>\n We return the blob just a little bit differently because we wanted to show off how to do it without using the [McpToolProperty] attributes.<\/p>\n Open up Program.cs<\/strong> again and checkout:<\/p>\n builder So that\u2019s saying: for the function defined with the name GetSnippetTool (which is a constant in the ToolsInformation.cs<\/strong>) add a MCP property to its definition. The property is named SnippetNamePropertyName has a description of SnippetNamePropertyDescription and it\u2019s a string type.<\/p>\n The function definition looks like:<\/p>\n [Function(nameof(GetSnippet))] So it\u2019s returning whatever is in the BlobPath. That is defined as:<\/p>\n private const string BlobPath = “snippets\/{mcptoolargs.” + SnippetNamePropertyName + “}.json”;<\/p>\n Well look at that, SnippetNamePropertyName makes an appearance. So the path of where the blob is stored within the storage container is defined by its name!<\/p>\n The real reason we started with this pre-baked sample is because it\u2019s super easy to deploy it to Azure thanks to the Azure Developer CLI (azd).<\/p>\n Assuming you have azd already installed. Open up a terminal, change to the base directory of the repository and run:<\/p>\n azd up<\/p>\n That\u2019s it. After asking a couple of questions like which Azure subscription you want to use, a name to use, and which region to deploy in, azd will take care of everything. It will provision all the Azure resources. It will deploy the code. It\u2019s going to do everything except setup VS Code.<\/p>\n\n Note<\/strong><\/p>\n You don\u2019t need to deploy to Azure! Follow these steps<\/a> to run the Function app locally with the Functions Core CLI.<\/p><\/div>\n We\u2019re going to use VS Code, and specifically the GitHub Copilot extension, to test out the remote MCP server. (Find out more about Copilot plans<\/a>).<\/p>\n There are 2 pieces of information we\u2019ll need about the Azure function we just deployed. The default domain and the system key for the mcp_extension<\/strong>.<\/p>\n Go to the Azure portal and open the Function app you just deployed with azd up. The default domain will be listed in the Overview<\/strong> tab under the Essentials<\/strong> section.<\/p>\n\n Next open up the App Keys<\/strong> tab. (It may be easiest to search for it.) And copy the value from the mcp_extension<\/strong> key.<\/p>\n\n Open up a brand new instance of VS Code and open or create a .NET project (this way we have some code to save ).<\/p>\n In VS Code\u2019s command palette, type (and select): > MCP: Add Server… Now you\u2019ll have to enter the server URL. That\u2019s going to be https:\/\/{default-function-domain}\/runtime\/webhooks\/mcp\/sse. Don\u2019t forget the \/runtime\/webhooks\/mcp\/sse part!<\/p>\n You\u2019ll get prompted for a local name \u2013 you can use the default one or any name you\u2019d like. A file named mcp.json<\/strong> will be created in the .vscode<\/strong> folder for you. It will look like this: Almost there! Functions is going to require the mcp_extension<\/strong> key we copied earlier to be sent in the header. We could hardcode it in, but let\u2019s instead make VS Code prompt us for it. Update the mcp.json<\/strong> file so it looks like this: There should be a Start<\/strong> text link right above the server definition. Click it. VS Code will prompt you for the key.<\/p>\n If all goes well, you should be connected to your Azure Functions remote MCP server and see that you have 3 tools available.<\/p>\n Now for the fun stuff \u2013 getting the LLM to invoke the MCP server (or the tools) just by kinda sorta telling it to.<\/p>\n Open up a code file and then Copilot. Make sure Copilot is set to be in Agent<\/strong> mode.<\/p>\n\n You\u2019ll notice on top of the text box where you chat with Copilot is a little icon that looks like 2 wrenches. If you click on that a listing of all the tools that Copilot (our MCP client) has access to will appear.<\/p>\n\n So highlight some code in the editor. Then in the Copilot chat window say something like:<\/p>\n Save the highlighted code and call it best-snippet-in-the-world<\/p>\n Copilot will start to figure out what to do and it should eventually ask you if you want to run the save_snippet<\/strong> tool.<\/p>\n\n Then somewhere else \u2013 a new file or wherever, prompt Copilot with something like the following:<\/p>\n Put the best-snippet-in-the-world at the cursor<\/p>\n Copilot will do running and then prompt if you want to perform the get_snippets<\/strong> tool. If you say yes, it will put the snippet you saved before where your cursor was!<\/p>\n Adding tooling to LLM-based applications was possible before MCP, but the Model Context Protocol has made it much simpler and also opened the world up to a greater variety of tooling you can add.<\/p>\n Azure Functions is one of those and all it takes is creating a function that\u2019s a McpToolTrigger and away you go.<\/p>\n Don\u2019t forget to check out the code for this sample<\/a> and watch the complete walkthrough in this video:<\/p>\n\n The post Build MCP Remote Servers with Azure Functions<\/a> appeared first on .NET Blog<\/a>.<\/p>","protected":false},"excerpt":{"rendered":" You can\u2019t run to the grocery store these days without hearing about the Model Context Protocol (MCP)! Well, I hope […]<\/p>\n","protected":false},"author":0,"featured_media":0,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[7],"tags":[],"class_list":["post-1935","post","type-post","status-publish","format-standard","hentry","category-dotnet"],"_links":{"self":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/1935","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/comments?post=1935"}],"version-history":[{"count":0,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/1935\/revisions"}],"wp:attachment":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/media?parent=1935"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/categories?post=1935"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/tags?post=1935"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Remote vs local MCP servers<\/h3>\n
Azure Functions remote MCP servers<\/h2>\n
Let\u2019s explore an Azure Functions MCP server<\/h3>\n
\n[BlobOutput(BlobPath)]
\npublic string SaveSnippet(
\n [McpToolTrigger(SaveSnippetToolName, SaveSnippetToolDescription)]
\n ToolInvocationContext context,
\n [McpToolProperty(SnippetNamePropertyName, PropertyType, SnippetNamePropertyDescription)]
\n string name,
\n [McpToolProperty(SnippetPropertyName, PropertyType, SnippetPropertyDescription)]
\n string snippet
\n)
\n{
\n return snippet;
\n}<\/p>\n
\n[McpToolProperty]: There are 2 of these in this function. One is for taking in the name of the snippet from the user so it can later be retrieved and the other is of the snippet itself. SnippetNamePropertyName and SnippetNamePropertyDescription are used as metadata. The PropertyType in this case indicates we can expect a string.<\/p>\n
\n .ConfigureMcpTool(GetSnippetToolName)
\n .WithProperty(SnippetNamePropertyName, PropertyType, SnippetNamePropertyDescription);<\/p>\n
\npublic object GetSnippet(
\n [McpToolTrigger(GetSnippetToolName, GetSnippetToolDescription)]
\n ToolInvocationContext context,
\n [BlobInput(BlobPath)] string snippetContent
\n)
\n{
\n return snippetContent;
\n}<\/p>\nDeploy to Azure<\/h3>\n
Consuming the MCP remote server<\/h2>\n
Grabbing the Functions info<\/h3>\n
Setting up VS Code<\/h3>\n
\nNext select HTTP (server-sent events)<\/p>\n
\nThen when asked about where you want to save this, pick Workspace.<\/p>\n
\n{
\n “servers”: {
\n “my-mcp-server-f84232fb”: {
\n “type”: “sse”,
\n “url”: “https:\/\/YOUR-DEFAULT-DOMAIN-URL\/runtime\/webhooks\/mcp\/sse”
\n }
\n }
\n}<\/p>\n
\n{
\n “inputs”: [
\n {
\n “type”: “promptString”,
\n “id”: “functions-mcp-extension-system-key”,
\n “description”: “Azure Functions MCP Extension System Key”,
\n “password”: true
\n }
\n ],
\n “servers”: {
\n “my-mcp-server-f84232fb”: {
\n “type”: “sse”,
\n “url”: “https:\/\/YOUR-DEFAULT-DOMAIN-URL\/runtime\/webhooks\/mcp\/sse”,
\n “headers”: {
\n “x-functions-key”: “${input:functions-mcp-extension-system-key}”
\n }
\n }
\n }
\n}<\/p>\nUsing the MCP server<\/h3>\n
Summary<\/h2>\n