Read more of this story at Slashdot.
Read more of this story at Slashdot.
Our Python + MCP series is a three-part, hands-on journey into one of the most important emerging technologies of 2025: MCP (Model Context Protocol) — an open standard for extending AI agents and chat interfaces with real-world tools, data, and execution environments. Whether you're building custom GitHub Copilot tools, powering internal developer agents, or creating AI-augmented applications, MCP provides the missing interoperability layer between LLMs and the systems they need to act on.
Across the series, we move from local prototyping, to cloud deployment, to enterprise-grade authentication and security, all powered by Python and the FastMCP SDK. Each session builds on the last, showing how MCP servers can evolve from simple localhost services to fully authenticated, production-ready services running in the cloud — and how agents built with frameworks like Langchain and Microsoft’s agent-framework can consume them at every stage.
🔗 Register for the entire series.
You can also scroll down to learn about each live stream and register for individual sessions.
In addition to the live streams, you can also join office hours after each session in Foundry Discord to ask any follow-up questions.
To get started with your MCP learnings before the series, check out the free MCP-for-beginners course on GitHub.
16 December, 2025 | 6:00 PM - 7:00 PM (UTC) Coordinated Universal Time
Register for the stream on Reactor
In the intro session of our Python + MCP series, we dive into the hottest technology of 2025: MCP (Model Context Protocol). This open protocol makes it easy to extend AI agents and chatbots with custom functionality, making them more powerful and flexible. We demonstrate how to use the Python FastMCP SDK to build an MCP server running locally and consume that server from chatbots like GitHub Copilot. Then we build our own MCP client to consume the server. Finally, we discover how easy it is to connect AI agent frameworks like Langchain and Microsoft agent-framework to MCP servers.
17 December, 2025 | 6:00 PM - 7:00 PM (UTC) Coordinated Universal Time
Register for the stream on Reactor
In our second session of the Python + MCP series, we're deploying MCP servers to the cloud! We'll walk through the process of containerizing a FastMCP server with Docker and deploying to Azure Container Apps, and also demonstrate a FastMCP server running directly on Azure Functions. Then we'll explore private networking options for MCP servers, using virtual networks that restrict external access to internal MCP tools and agents.
18 December, 2025 | 6:00 PM - 7:00 PM (UTC) Coordinated Universal Time
Register for the stream on Reactor
In our third session of the Python + MCP series, we're exploring the best ways to build authentication layers on top of your MCP servers. That could be as simple as an API key to gate access, but for the servers that provide user-specific data, we need to use an OAuth2-based authentication flow. MCP authentication is built on top of OAuth2 but with additional requirements like PRM and DCR/CIMD, which can make it difficult to implement fully. In this session, we'll demonstrate the full MCP auth flow, and provide examples that implement MCP Auth on top of Microsoft Entra.
This week, we discuss AWS re:Invent announcements, Agentic Development, and OpenAI's Code Red. Plus, a Digital ID field test and more on silverware sorting.
Watch the YouTube Live Recording of Episode 549
Photo Credits
Learn how to host secure and scalable remote MCP servers on Azure Functions! Hosting MCP servers remotely allows others to access tools in your servers, not just agents running on your local machine. Azure Functions provides remote hosting for two flavors of MCP servers - those built with the Functions MCP extension or with the official MCP SDKs. In this week's Azure Friday, Lily talks about how to host the SDK flavor with Scott. Check it out if you're looking to build or have already built some servers with these SDKs and are looking for a place to remotely host them!
🌮 Chapter Markers:
00:00 - Introduction
02:51 - Server project walk through
06:12 - Server deployment
07:01 - Test server in Copilot
13:56 - Questions from Scott
16:44 - Sample links and wrap up
🌮 Resources:
Learn Docs: https://learn.microsoft.com/azure/azure-functions/scenario-host-mcp-server-sdks
Azure Product page: https://azure.microsoft.com/products/functions
🌮 Follow us on social:
Scott Hanselman | @SHanselman – https://x.com/SHanselman
Azure Friday | @AzureFriday – https://x.com/AzureFriday
Follow us on social:
Blog - https://aka.ms/azuredevelopers/blog
Twitter - https://aka.ms/azuredevelopers/twitter
LinkedIn - https://aka.ms/azuredevelopers/linkedin
Twitch - https://aka.ms/azuredevelopers/twitch
#azuredeveloper #azure
If you've been using EventCounters for instrumenting your .NET applications, it's time to consider migrating to the newer System.Diagnostics.Metrics API. Based on the OpenTelemetry specification, the Metrics API offers a more modern, flexible, and standardized approach to application instrumentation.
The Metrics API provides several advantages over EventCounters:
Microsoft has indicated that EventCounters are in maintenance mode, with new development focused on the Metrics API.
So reasons enough to migrate our EventCounters to the new Metrics API. Let's go for it!
With EventCounters, you typically created an EventSource and used specialized counter types:
While System.Diagnostics.Metrics is part of .NET 6+, you may want to add OpenTelemetry packages for collection:
dotnet add package OpenTelemetry.Exporter.Console
dotnet add package OpenTelemetry.Extensions.Hosting
Replace your EventSource with a Meter. The meter name should follow reverse domain name notation:
Here's how EventCounter types map to Metrics API instruments:
| Event Counter type | Metrics API equivalent | Use case |
| Event Counter | Counter<T> | Monotonically increasing values (requests, errors) |
| PollingCounter | ObservableGauge<T> | Current value snapshots (queue length, active connections) |
| IncrementingEventCounter | Counter<T> | Cumulative totals |
| IncrementingPollingCounter | ObservableCounter<T> | Cumulative totals from callbacks |
Now we move the different event counter types over:
One powerful feature of the Metrics API is built-in support for tags. This allows you to give extra context to a metric:
Remark: You can further improve the performance of tags by using the built-in source generators.
In your application startup inside Program.cs for ASP.NET Core add the following configuration:
Here is how the complete class looks like after the migration:
Source-generated metrics with strongly-typed tags - .NET | Microsoft Learn
Understanding different metric APIs - .NET | Microsoft Learn