DEV Community: Microsoft Azure

Getting started with GitHub Copilot part 2, streamable responses

Chris Noring — Mon, 16 Mar 2026 20:14:28 +0000

I'm sure you've seen many AI apps where you sit tight for 30s or and you wonder if things are stuck? Not a great experience right? Yes, you're right, you deserve better, so how do we fix it?

Type your prompt> Tell me a joke
.
.
.
.
.
.
.
.
Why could I never find the atoms, cause they split..

Series on Copilot SDK

This series is about Copilot SDK and how you can leverage your existing GitHub Copilot license to integrate AI into your apps

Part 1 - install and your first app
Part 2 - streamable response, you're here

Addressing the problem

By streaming the response, the response now arrives in chunks, pieces that you can show as soon as they arrive. How can we do that though and how can GitHub Copilot SDK help out?

Well, there's two things you need to do:

Enable streaming. You need to set streaming to True when you call create_session.
Listen for events that contains a chunk. Specifically, you need to listen to ASSISTANT_MESSAGE_DELTA and print out the chunk.

# 1. Enable streaming
session = await client.create_session({
        "model": "gpt-4.1",
        "on_permission_request": PermissionHandler.approve_all,
        "streaming": True,
    })

print("Starting streamed response:")

# Listen for response chunks
def handle_event(event):
    if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
        // 2. Chunk arrived, print it
        sys.stdout.write(event.data.delta_content)
        sys.stdout.flush()
    if event.type == SessionEventType.SESSION_IDLE:
        print()  # New line when done

Here's what the full application looks like:

import asyncio
import sys
from copilot import CopilotClient, PermissionHandler
from copilot.generated.session_events import SessionEventType

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session({
        "model": "gpt-4.1",
        "on_permission_request": PermissionHandler.approve_all,
        "streaming": True,
    })

    print("Starting streamed response:")

    # Listen for response chunks
    def handle_event(event):
        if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
            sys.stdout.write(event.data.delta_content)
            sys.stdout.flush()
        if event.type == SessionEventType.SESSION_IDLE:
            print()  # New line when done

    session.on(handle_event)

    print("Sending prompt...")
    await session.send_and_wait({"prompt": "Tell me a short joke"})

    await client.stop()

if __name__ == "__main__":
    asyncio.run(main())

That's it folks, now go out and build better experiences for your users.

Get started with GitHub Copilot CLI: A free, hands-on course

Renee Noble — Thu, 05 Mar 2026 04:44:08 +0000

GitHub Copilot has grown well beyond code completions in your editor. It now lives in your terminal, too. GitHub Copilot CLI lets you review code, generate tests, debug issues, and ask questions about your projects without ever leaving the command line.

To help developers get up to speed, we put together a free, open source course: GitHub Copilot CLI for Beginners. It’s 8 chapters, hands-on from the start, and designed so you can go from installation to building real workflows in a few hours. Already have a GitHub account? GitHub Copilot CLI works with GitHub Copilot Free, which is available to all personal GitHub accounts.

In this post, I’ll walk through what the course covers and how to get started.

What GitHub Copilot CLI can do

If you haven’t tried it yet, GitHub Copilot CLI is a conversational AI assistant that runs in your terminal. You point it at files using @ references, and it reads your code and responds with analysis, suggestions, or generated code.

You can use it to:

Review a file and get feedback on code quality
Generate tests based on existing code
Debug issues by pointing it at a file and asking what’s wrong
Explain unfamiliar code or confusing logic
Generate commit messages, refactor functions, and more
Write new app features (front-end, APIs, database interactions, and more)

It remembers context within a conversation, so follow-up questions build on what came before.

What the course covers

The course is structured as 8 progressive chapters. Each one builds on the last, and you work with the same project throughout: a book collection management app. Instead of jumping between isolated snippets, you keep improving one codebase as you go.

Here’s what using GitHub Copilot CLI looks like in practice. Say you want to review a Python file for potential issues. Start up Copilot CLI and ask what you’d like done:

$ copilot
> Review @samples/book-app-project/books.py for potential improvements. Focus on error handling and code quality.

Copilot reads the file, analyzes the code, and gives you specific feedback right in your terminal.

Here are the chapters covered in the course:

Quick Start — Installation and authentication
First Steps — Learn the three interaction modes: interactive, plan, and one-shot (programmatic)
Context and Conversations — Using @ references to point Copilot at files and directories, plus session management with --continue and --resume
Development Workflows — Code review, refactoring, debugging, test generation, and Git integration
Custom Agents — Building specialized AI assistants with .agent.md files (for example, a Python reviewer that always checks for type hints)
Skills — Creating task-specific instructions that auto-trigger based on your prompt
MCP Servers — Connecting Copilot to external services like GitHub repos, file systems, and documentation APIs via the Model Context Protocol
Putting It All Together — Combining agents, skills, and MCP servers into complete development workflows
learning path image

Every command in the course can be copied and run directly. No AI or machine learning background is required.

Who this is for

The course is built for:

Developers using terminal workflows: If you’re already running builds, checking git status, and SSHing into servers from the command line, Copilot CLI fits right into that flow.
Teams looking to standardise AI-assisted practices: Custom agents and skills can be shared across a team through a project’s .github/agents and .github/skills directories.
Students and early-career developers: The course explains AI terminology as it comes up, and every chapter includes assignments with clear success criteria.

You don’t need prior experience with AI tools. If you can run commands in a terminal, you learn and apply the concepts in this course.

How the course teaches

Each chapter follows a consistent pattern: a real-world analogy to ground the concept, then the core technical material, then hands-on exercises. For instance, the three interaction modes are compared to ordering food at a restaurant. Plan mode is more like mapping your route to the restaurant before you start driving. Interactive mode is a back-and-forth conversation with a waiter. And one-shot mode (programmatic mode) is like going through the drive-through.

Later chapters use different comparisons: agents are like hiring specialists, skills work like attachments for a power drill, and MCP servers are compared to browser extensions. The goal is to provide you with a visual and mental model before the technical details land.

The course also focuses on a question that’s harder than it looks: when should I use which tool? Knowing the difference between reaching for an agent, a skill, or an MCP server takes practice, and the final chapter walks through that decision-making in a realistic workflow.

Get started

The course is free and open source. You can clone the repo, or open it in GitHub Codespaces for a fully configured environment. Jump right in, get Copilot CLI running, and see if it fits your workflow.

GitHub Copilot CLI for Beginners

For a quick reference, see the CLI command reference.

Subscribe to GitHub Insider for more developer tips and guides.

Get started with GitHub Copilot SDK, part 1

Chris Noring — Wed, 04 Mar 2026 20:48:00 +0000

Did you know GitHub Copilot now has an SDK and that you can leverage your existing license to build AI integrations into your app? No, well I hope I have you attention now.

Series on Copilot SDK

This series is about Copilot SDK and how you can leverage your existing GitHub Copilot license to integrate AI into your apps

Part 1 - install and your first app, you're here
Part 2 - streamable responses

Install

You need two pieces here to get started:

GitHub Copilot CLI
A supported runtime, which at present means either Node.js, .NET, Python or Go

Then you need to install the SDK for your chosen runtime like so:

pip install github-copilot-sdk

The parts

So what do you need to know to get started? There are three concepts:

Client, you need to create and instance of it. Additionally you need to start and stop it when you're done with it.
Session. The session takes an object where you can set things like model, system prompt and more. Also, the session is what you talk when you want to carry out a request.
Response. The response contains your LLM response.

Below is an example program using these three concepts. As you can see we choose "gpt-4.1" as model but this can be changed. See also how we pass the prompt to the function send_and_wait.

import asyncio
from copilot import CopilotClient

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session({"model": "gpt-4.1"})
    response = await session.send_and_wait({"prompt": "What is 2 + 2?"})

    print(response.data.content)

    await client.stop()

asyncio.run(main())

Ok, now that we know what a simple program looks like, let's make something interesting, an FAQ responder.

Your first app

An FAQ for a web page, is often a pretty boring read. A way to make that more interesting for the end user is if they can instead chat with the FAQ, let's make that happen.

Here's the plan:

Define a static FAQ
Add the FAQ as part of the prompt.
Make a request to to the LLM and print out the response.

Let's build out the code little by little. First, let's define the FAQ information.

-1- FAQ information

# faq.py

faq = {
  "warranty": "Our products come with a 1-year warranty covering manufacturing defects. Please contact our support team for assistance.",
  "return_policy": "We offer a 30-day return policy for unused products in their original packaging. To initiate a return, please visit our returns page and follow the instructions.",     
  "shipping": "We offer free standard shipping on all orders over $50. Expedited shipping options are available at checkout for an additional fee.",
}

Next, let's add the call to the Copilot SDK

-2 Adding the LLM call


import asyncio
from copilot import CopilotClient

def faq_to_string(faq: dict) -> str:
    return "\n".join([f"{key}: {value}" for key, value in faq.items()])

async def main(user_prompt: str = "Tell me about shipping"):
    client = CopilotClient()
    await client.start()

    prompt = f"Here's the FAQ, {faq_to_string(faq)}\n\nUser question: {user_prompt}\nAnswer:"   

    session = await client.create_session({"model": "gpt-4.1"})
    response = await session.send_and_wait({"prompt": prompt})

    print(response.data.content)

    await client.stop()

if __name__ == "__main__":
    print("My first app using the GitHub Copilot SDK!")
    print(f"[LOG] Asking the model about shipping information...")
    asyncio.run(main("Tell me about shipping"))

Note how we concatenate the FAQ data with the user's prompt:

 prompt = f"Here's the FAQ, {faq_to_string(faq)}\n\nUser question: {user_prompt}\nAnswer:"

-3- Let's run it

Now run it:

uv run faq.py

You should see output like so:

My first app using the GitHub Copilot SDK!
[LOG] Asking the model about shipping information...
We offer free standard shipping on all orders over $50. Expedited shipping options are available at checkout for an additional fee.

What's next

Check out the official docs

The JavaScript AI Build-a-thon Season 2 starts March 2!

Julia Muiruri — Wed, 25 Feb 2026 04:09:06 +0000

Most applications used by millions of people every single day are powered by JavaScript/TypeScript. But when it comes to AI, most learning resources and code samples assume you're working in Python and will leave you trying to stitch scattered tutorials together to build AI into your stack.

The JavaScript AI Build-a-thon is a free, hands-on program designed to close that gap. Over the course of four weeks (March 2 - March 31, 2026), you'll move from running AI 100% on-device (Local AI), to designing multi-service, multi-agentic systems, all in JavaScript/ TypeScript and using tools you are already familiar with.
The series will culminate in a hackathon, where you will create, compete and turn what you'll have learnt into working projects you can point to, talk about and extend.

How the program works!

The program is organized around 2 phases: -

Phase I: Learn & Skill Up Schedule (Mar 2 - 13)

Self-paced quests that teach core AI patterns,
Interactive Expert-led sessions on Microsoft Reactor (Livestreams) and Discord (Office hours & QnA)

Day/Time (PT)	Topic	Links to join
Mon 3/2, 8:00 AM PST	Local AI Development with Foundry Local	Livestream Discord Office Hour
Wed 3/4, 8:00 AM PST	End-to-End Model Development on Microsoft Foundry	Livestream Discord Office Hour
Fri 3/6, 9:00 AM PST	Advanced RAG Deep Dive + Guided Project	Livestream Discord Office Hour
Mon 3/9, 8:00 AM PST	Design & Build an Agent E2E with Agent Builder (AITK)	Livestream Discord Office Hour
Wed 3/11, 8:00 AM PST	Build, Scale & Govern AI Agents + Guided project	Livestream Discord Office Hour

The Build-a-thon prioritizes practical learning, so you'll complete 2 guided projects by the end of this phase:-

1. A Local Serverless AI chat with RAG
Concepts covered include: -

RAG Architecture
RAG Ingestion pipeline
Query & Retrieval
Response Generation (LLM Chains)

2. A Burger Ordering AI Agent
Concepts covered include: -

Designing AI Agents
Building MCP Tools (Backend API Design)

Phase II: Global Hack! (Mar 13 - 31)

Product demo series to showcase the latest product features that will accelerate your builder experience
A Global hackathon to apply what you learn into real, working AI solutions

This is where you'll build something that matters using everything learnt in the quests, and beyond, to create an AI-powered project that solves a real problem, delights users, or pushes what's possible.

The hackathon launches on March 13, 2026. Full details on registration, submission, judging criteria, award categories, prizes, and the hack phase schedule will be published when the hack goes live. Stay tuned!

But, here's what we can tell you now:

🏆 6 award categories
💻 Product demo showcases throughout the hack phase to keep you building with the latest tools
👥 Teams of up to 4 or solo. Your call

Start Now (Join the Community)

Join our community to connect with other participants and experts from Microsoft &. GitHub to support your builder journey.

Foundry Discord (#js-ai-build-a-thon channel): Our platform for office hours, live QnA, quick questions, community & expert support
GitHub Discussions: This is where you'll share ideas, ask questions, find teammates
Social: Share your progress online using #JSAIBuildathon

See you soon!

Host Your Node.js MCP Server on Azure Functions in 1 Simple Step

Yohan Lasorsa — Tue, 09 Dec 2025 15:44:53 +0000

Building AI agents with the Model Context Protocol (MCP) is powerful, but when it comes to hosting your MCP server in production, you need a solution that's reliable, scalable, and cost-effective. What if you could deploy your regular Node.js MCP server to a serverless platform that handles scaling automatically while you only pay for what you use?

Let's explore how Azure Functions now supports hosting MCP servers built with the official Anthropic MCP SDK, giving you serverless scaling with almost no changes in your code.

Grab your favorite hot beverage, and let's dive in!

TL;DR key takeaways

Azure Functions now supports hosting Node.js MCP servers using the official Anthropic SDK
Only 1 simple configuration needed: adding host.json file
Currently supports HTTP Streaming protocol with stateless servers
Serverless hosting means automatic scaling and pay-per-use pricing
Deploy with one command using Infrastructure as Code

What will you learn here?

Understand how MCP servers work on Azure Functions
Configure a Node.js MCP server for Azure Functions hosting
Test your MCP server locally and with real AI agents
Deploy your MCP server with Infrastructure as Code and AZD

Reference links for everything we use

Model Context Protocol - Official MCP documentation
Azure Functions - Serverless compute platform
Anthropic MCP SDK - Official TypeScript SDK
Azure Developer CLI - One-command deployment tool
Full sample project - Complete burger ordering system with MCP
Simple example - Minimal MCP server starter
GitHub Copilot prompt helper - Automated setup by Anthony Chu

Requirements

Node.js 22 or higher
Azure account (free signup, or if you're a student, get free credits here)
Azure Developer CLI (for deployment)
GitHub account (optional, for using Codespaces)

What is MCP and why does it matter?

Model Context Protocol is an open standard that enables AI models to securely interact with external tools and data sources. Instead of hardcoding tool integrations, you build an MCP server that exposes capabilities (like browsing a menu, placing orders, or querying a database) as tools that any MCP-compatible AI agent can discover and use. MCP is model-agnostic, meaning it can work with any LLM that supports the protocol, including models from Anthropic, OpenAI, and others. It's also worth noting that MCP supports more than just tool calls, though that's its most common use case.

The challenge? Running MCP servers in production requires infrastructure. You need to handle scaling, monitoring, and costs. That's where Azure Functions comes in.

🚨 Free course alert! If you're new to MCP, check out the MCP for Beginners course to get up to speed quickly.

Why Azure Functions for MCP servers?

Azure Functions is a serverless compute platform that's perfect for MCP servers:

Zero infrastructure management: No servers to maintain
Automatic scaling: Handles traffic spikes seamlessly
Cost-effective: Pay only for actual execution time (with generous free grant)
Built-in monitoring: Application Insights integration out of the box
Global distribution: Deploy to regions worldwide

The new Azure Functions support means you can take your existing Node.js MCP server and deploy it to a production-ready serverless environment with minimal changes. This comes up as an additional option for native Node.js MCP hosting, but you can still use the Azure Functions MCP bindings that were available before.

1 simple step to enable Functions hosting

Let's break down what you need to add to your existing Node.js MCP server to run it on Azure Functions. I'll use a real-world example from our burger ordering system.

If you already have a working Node.js MCP server, you can just follow this to make it compatible with Azure Functions hosting.

Step 1: Add the `host.json` configuration

Create a host.json file at the root of your Node.js project:

{
  "version": "2.0",
  "configurationProfile": "mcp-custom-handler",
  "customHandler": {
    "description": {
      "defaultExecutablePath": "node",
      "arguments": ["lib/server.js"]
    },
    "http": {
      "DefaultAuthorizationLevel": "anonymous"
    },
    "port": "3000"
  }
}

Note: Adjust the arguments array to point to your compiled server file (e.g., lib/server.js or dist/server.js), depending on your build setup. You can also change the port if needed to match your server configuration.

The hosts.json file holds metadata configuration for the Functions runtime. The most important part here is the customHandler section. It configures the Azure Functions runtime to run your Node.js MCP server as a custom handler, which allows you to use any HTTP server framework (like Express, Fastify, etc.) without modification (tip: it can do more than MCP servers! 😉).

There's no step 2 or 3. That's it! 😎

Note: We're not covering the authentication and authorization aspects of Azure Functions here, but you can easily add those later if needed.

Real-world example: Burger MCP Server

Let's look at how this works in practice with a burger ordering MCP server. This server exposes 9 tools for AI agents to interact with a burger API:

get_burgers - Browse the menu
get_burger_by_id - Get burger details
place_order - Place an order
get_orders - View order history
And more...

Here's the complete server implementation using Express and the MCP SDK:

import express, { Request, Response } from 'express';
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
import { getMcpServer } from './mcp.js';

const app = express();
app.use(express.json());

// Handle all MCP Streamable HTTP requests
app.all('/mcp', async (request: Request, response: Response) => {
  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: undefined,
  });

  // Connect the transport to the MCP server
  const server = getMcpServer();
  await server.connect(transport);

  // Handle the request with the transport
  await transport.handleRequest(request, response, request.body);

  // Clean up when the response is closed
  response.on('close', async () => {
    await transport.close();
    await server.close();
  });

  // Note: error handling not shown for brevity
});

// The port configuration
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Burger MCP server listening on port ${PORT}`);
});

The MCP tools are defined using the official SDK:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';

export function getMcpServer() {
  const server = new McpServer({
    name: 'burger-mcp',
    version: '1.0.0',
  });

  server.registerTool(
    'get_burgers',
    { description: 'Get a list of all burgers in the menu' },
    async () => {
      const response = await fetch(`${burgerApiUrl}/burgers`);
      const burgers = await response.json();
      return {
        content: [{
          type: 'text',
          text: JSON.stringify(burgers, null, 2)
        }]
      };
    }
  );

  // ... more tools
  return server;
}

As you can see, the actual implementation of the tool is forwarding an HTTP request to the burger API and returning the result in the MCP response format. This is a common pattern for MCP tools in enterprise contexts, that act as wrappers around one or more existing APIs.

Current limitations

Note that this Azure Functions MCP hosting currently has some limitations: it only supports stateless servers using the HTTP Streaming protocol. The legacy SSE protocol is not supported as it requires stateful connections, so you'll either have to migrate your client to use HTTP Streaming or use another hosting option, like using containers for example.

For most use cases, HTTP Streaming is the recommended approach anyway as it's more scalable and doesn't require persistent connections. Stateful MCP servers comes with additional complexity challenges and have limited scalability if you need to handle many concurrent connections.

Testing the MCP server locally

First let's run the MCP server locally and play a bit with it.

If you don't want to bother with setting up a local environment, you can use the following link or open it in a new tab to launch a GitHub Codespace:

Create Codespace

This will open a VS Code environment in your browser with the repo already cloned and all the tools installed and ready to go. Otherwise you can just clone the repo.

Once you have the code ready, open a terminal and run:

# Install dependencies
npm install

# Start the burger MCP server and API
npm start

This will start multiple services locally, including the Burger API and the MCP server, which will be available at http://localhost:3000/mcp. This may take a few seconds, wait until you see this message in the terminal:

🚀 All services ready 🚀

We're only interested in the MCP server for now, so let's focus on that.

Using MCP Inspector

The easiest way to test the MCP server is with the MCP Inspector tool:

$ npx -y @modelcontextprotocol/inspector

Open the URL shown in the console in your browser, then:

Set transport type to Streamable HTTP
Enter your local server URL: http://localhost:3000/mcp
Click Connect

After you're connected, go to the Tools tab to list available tools. You can then try the get_burgers tool to see the burger menu.

Using GitHub Copilot (with remote MCP)

Configure GitHub Copilot to use your deployed MCP server by adding this to your project's .vscode/mcp.json:

{
  "servers": {
    "burger-mcp": {
      "type": "http",
      "url": "http://localhost:3000/mcp"
    }
  }
}

Click on "Start" button that will appear in the JSON file to activate the MCP server connection.

Now you can use Copilot in agent mode and ask things like:

"What spicy burgers do you have?"
"Place an order for two cheeseburgers"
"Show my recent orders"

Copilot will automatically discover and use the MCP tools! 🎉

Tip: If Copilot doesn't call the burger MCP tools, try checking if it's enabled by clicking on the tool icon in the chat input box and ensuring that "burger-mcp" is selected. You can also force tool usage by adding #burger-mcp in your prompt.

(Bonus) Deploying to Azure with Infrastructure as Code

Deploying an application to Azure is usually not the fun part, especially when it involves multiple resources and configurations.
With the Azure Developer CLI (AZD), you can define your entire application infrastructure and deployment process as code, and deploy everything with a single command.

If you've used the automated setup with GitHub Copilot, you should already have the necessary files. Our burger example also comes with these files pre-configured. The MCP server is defined as a service in azure.yaml, and the files under the infra folder defines the Azure Functions app and related resources.

Here's the relevant part of azure.yaml that defines the burger MCP service:

name: mcp-agent-langchainjs

services:
  burger-mcp:
    project: ./packages/burger-mcp
    language: ts
    host: function

While the infrastructure files can look intimidating at first, you don't need to understand all the details to get started. There are tons of templates and examples available to help you get going quickly, the important part is that everything is defined as code, so you can version control it and reuse it.

Now let's deploy:

# Login to Azure
azd auth login

# Provision resources and deploy
azd up

Pick your preferred Azure region when prompted (if you're not sure, choose East US2), and voilà! In a few minutes, you'll have a fully deployed MCP server running on Azure Functions.

Once the deployment is finished, the CLI will show you the URL of the deployed resources, including the MCP server endpoint.

Example projects

The burger MCP server is actually part of a larger example project that demonstrates building an AI agent with LangChain.js, that uses the burger MCP server to place orders. If you're interested in the next steps of building an AI agent on top of MCP, this is a great resource as it includes:

AI agent web API using LangChain.js
Web app interface built with Lit web components
MCP server on Functions (the one we just saw)
Burger ordering API (used by the MCP server)
Live order visualization
Complete Infrastructure as Code, to deploy everything with one command

But if you're only interested in the MCP server part, then you might want to look at this simpler example that you can use as a starting point for your own MCP servers: mcp-sdk-functions-hosting-node is a server template for a Node.js MCP server using TypeScript and MCP SDK.

What about the cost?

Azure Functions Flex Consumption pricing is attractive for MCP servers:

Free grant: 1 million requests and 400,000 GB-s execution time per month
After free grant: Pay only for actual execution time
Automatic scaling: From zero to hundreds of instances

The free grant is generous enough to allow running a typical MCP server with moderate usage, and all the experimentation you might need. It's easy to configure the scaling limits to control costs as needed, with an option to scale down to zero when idle. This flexibility is why Functions is my personal go-to choice for TypeScript projects on Azure.

Wrap up

Hosting MCP servers on Azure Functions gives you the best of both worlds: the simplicity of serverless infrastructure and the power of the official Anthropic SDK. With just one simple configuration step, you can take your existing Node.js MCP server and deploy it to a production-ready, auto-scaling platform.

The combination of MCP's standardized protocol and Azure's serverless platform means you can focus on building amazing AI experiences instead of managing infrastructure. Boom. 😎

Star the repos ⭐️ if you found this helpful! Try deploying your own MCP server and share your experience in the comments. If you run into any issues or have questions, you can reach for help on the Azure AI community on Discord.

Serverless MCP Agent with LangChain.js v1 — Burgers, Tools, and Traces 🍔

Yohan Lasorsa — Tue, 21 Oct 2025 16:09:46 +0000

AI agents that can actually do stuff (not just chat) are the fun part nowadays, but wiring them cleanly into real APIs, keeping things observable, and shipping them to the cloud can get... messy. So we built a fresh end‑to‑end sample to show how to do it right with the brand new LangChain.js v1 and Model Context Protocol (MCP). In case you missed it, MCP is a recent open standard that makes it easy for LLM agents to consume tools and APIs, and LangChain.js, a great framework for building GenAI apps and agents, has first-class support for it.

This new sample gives you:

A LangChain.js v1 agent that streams its result, along reasoning + tool steps
An MCP server exposing real tools (burger menu + ordering) from a business API
A web interface with authentication, sessions history, and a debug panel (for developers)
A production-ready multi-service architecture
Serverless deployment on Azure in one command (azd up)

Yes, it’s a burger ordering system. Who doesn't like burgers? Grab your favorite beverage ☕, and let’s dive in for a quick tour!

TL;DR key takeaways

New sample: full-stack Node.js AI agent using LangChain.js v1 + MCP tools
Architecture: web app → agent API → MCP server → burger API
Runs locally with a single npm start, deploys with azd up
Uses streaming (NDJSON) with intermediate tool + LLM steps surfaced to the UI
Ready to fork, extend, and plug into your own domain / tools

What will you learn here?

What this sample is about and its high-level architecture
What LangChain.js v1 brings to the table for agents
How to deploy and run the sample
How MCP tools can expose real-world APIs

Reference links for everything we use

Use case

You want an AI assistant that can take a natural language request like “Order two spicy burgers and show me my pending orders” and:

Understand intent (query menu, then place order)
Call the right MCP tools in sequence, calling in turn the necessary APIs
Stream progress (LLM tokens + tool steps)
Return a clean final answer

Swap “burgers” for “inventory”, “bookings”, “support tickets”, or “IoT devices” and you’ve got a reusable pattern!

Sample overview

Before we play a bit with the sample, let's have a look at the main services implemented here:

Service	Role	Tech
Agent Web App (`agent-webapp`)	Chat UI + streaming + session history	Azure Static Web Apps, Lit web components
Agent API (`agent-api`)	LangChain.js v1 agent orchestration + auth + history	Azure Functions, Node.js
Burger MCP Server (`burger-mcp`)	Exposes burger API as tools over MCP (Streamable HTTP + SSE)	Azure Functions, Express, MCP SDK
Burger API (`burger-api`)	Business logic: burgers, toppings, orders lifecycle	Azure Functions, Cosmos DB

Here's a simplified view of how they interact:

There are also other supporting components like databases and storage not shown here for clarity.

For this quickstart we'll only interact with the Agent Web App and the Burger MCP Server, as they are the main stars of the show here.

LangChain.js v1 agent features

The recent release of LangChain.js v1 is a huge milestone for the JavaScript AI community! It marks a significant shift from experimental tools to a production-ready framework. The new version doubles down on what’s needed to build robust AI applications, with a strong focus on agents. This includes first-class support for streaming not just the final output, but also intermediate steps like tool calls and agent reasoning. This makes building transparent and interactive agent experiences (like the one in this sample) much more straightforward.

Quickstart

Requirements

GitHub account
Azure account (free signup, or if you're a student, get free credits here)
Azure Developer CLI

Deploy and run the sample

We'll use GitHub Codespaces for a quick zero-install setup here, but if you prefer to run it locally, check the README.

Click on the following link or open it in a new tab to launch a Codespace:

Create Codespace

This will open a VS Code environment in your browser with the repo already cloned and all the tools installed and ready to go.

Provision and deploy to Azure

Open a terminal and run these commands:

# Install dependencies
npm install

# Login to Azure
azd auth login

# Provision and deploy all resources
azd up

Follow the prompts to select your Azure subscription and region. If you're unsure of which one to pick, choose East US 2.
The deployment will take about 15 minutes the first time, to create all the necessary resources (Functions, Static Web Apps, Cosmos DB, AI Models).

If you're curious about what happens under the hood, you can take a look at the main.bicep file in the infra folder, which defines the infrastructure as code for this sample.

Test the MCP server

While the deployment is running, you can run the MCP server and API locally (even in Codespaces) to see how it works. Open another terminal and run:

npm start

This will start all services locally, including the Burger API and the MCP server, which will be available at http://localhost:3000/mcp. This may take a few seconds, wait until you see this message in the terminal:

🚀 All services ready 🚀

When these services are running without Azure resources provisioned, they will use in-memory data instead of Cosmos DB so you can experiment freely with the API and MCP server, though the agent won't be functional as it requires a LLM resource.

MCP tools

The MCP server exposes the following tools, which the agent can use to interact with the burger ordering system:

Tool Name	Description
`get_burgers`	Get a list of all burgers in the menu
`get_burger_by_id`	Get a specific burger by its ID
`get_toppings`	Get a list of all toppings in the menu
`get_topping_by_id`	Get a specific topping by its ID
`get_topping_categories`	Get a list of all topping categories
`get_orders`	Get a list of all orders in the system
`get_order_by_id`	Get a specific order by its ID
`place_order`	Place a new order with burgers (requires `userId`, optional `nickname`)
`delete_order_by_id`	Cancel an order if it has not yet been started (status must be `pending`, requires `userId`)

You can test these tools using the MCP Inspector. Open another terminal and run:

npx -y @modelcontextprotocol/inspector

Then open the URL printed in the terminal in your browser and connect using these settings:

Transport: Streamable HTTP
URL: http://localhost:3000/mcp
Connection Type: Via Proxy (should be default)

Click on Connect, then try listing the tools first, and run get_burgers tool to get the menu info.

Test the Agent Web App

After the deployment is completed, you can run the command npm run env to print the URLs of the deployed services. Open the Agent Web App URL in your browser (it should look like https://<your-web-app>.azurestaticapps.net).

You'll first be greeted by an authentication page, you can sign in either with your GitHub or Microsoft account and then you should be able to access the chat interface.

From there, you can start asking any question or use one of the suggested prompts, for example try asking: Recommend me an extra spicy burger.

As the agent processes your request, you'll see the response streaming in real-time, along with the intermediate steps and tool calls. Once the response is complete, you can also unfold the debug panel to see the full reasoning chain and the tools that were invoked:

Tip: Our agent service also sends detailed tracing data using OpenTelemetry. You can explore these either in Azure Monitor for the deployed service, or locally using an OpenTelemetry collector. We'll cover this in more detail in a future post.

Wrap it up

Congratulations, you just finished spinning up a full-stack serverless AI agent using LangChain.js v1, MCP tools, and Azure’s serverless platform. Now it's your turn to dive in the code and extend it for your use cases! 😎 And don't forget to azd down once you're done to avoid any unwanted costs.

Going further

This was just a quick introduction to this sample, and you can expect more in-depth posts and tutorials soon.

Since we're in the era of AI agents, we've also made sure that this sample can be explored and extended easily with code agents like GitHub Copilot.
We even built a custom chat mode to help you discover and understand the codebase faster! Check out the Copilot setup guide in the repo to get started.

If you like this sample, don't forget to star the repo ⭐️! You can also join us in the Azure AI community Discord to chat and ask any questions.

Happy coding and burger ordering! 🍔

What’s in a Name? Fuzzy Matching for Real-World Data

Renee Noble — Fri, 17 Oct 2025 00:47:36 +0000

🎥 Watch the full PyCon AU 2025 talk here

When you work with human-entered data (registrations, surveys, customer forms, you name it!) you soon discover that people are very creative typists. Names, schools, companies, and addresses come in with abbreviations, nicknames, missing words, and typos galore.

That mess makes it hard to answer even simple questions like: “Do these two records refer to the same person?” or “How many participants came from this organisation?”

At PyCon AU 2025, I explored how different fuzzy matching techniques, from traditional algorithms to generative AI, can help make sense of that chaos.

The Fuzzy Matching Challenge

String comparison looks straightforward until you meet real-world data. “PLC Sydney” might really be “Presbyterian Ladies’ College Sydney.” “Certain Collage” is obviously a typo for “Certain College” (hopefully). And nicknames like Liz, Lizzy, and Elizabeth might all belong to the same person.

That’s where fuzzy matching comes in, using a variety of techniques we can rank how similar different non-identical words are to try and find the most likely match. But the question is, what fuzzy matching algorithms are best suited for matching what types of data? And can generative AI play a part in this matching game?

Comparing Algorithmic Approaches

I put six Python libraries to the test:

TextDistance and Python-Levenshtein – classic edit-distance approaches.
FuzzyWuzzy and RapidFuzz – hybrids that combine multiple distance metrics.
Nicknames and PyNameMatcher – specialised tools for given-name variations.

To test them, I generated around 100 fake student names with nicknames, misspellings, and swapped orderings. Then I measured how accurately each library matched them to their correct counterparts.

RapidFuzz came out ahead, matching almost every record correctly, and doing it fast! The edit-distance methods struggled most with multicultural names where order or character sets varied, and the nickname libraries were strong but less consistent overall.

When Generative AI Shines

Algorithmic fuzzy matching is fast and accurate, but it only looks at characters, not meaning. That’s where I turned to Azure OpenAI Service for a different kind of help.

By feeding in real school-name data, I found that straight out of the box GPT-5 was exceptionally good at recognising and correcting school names, especially when they were abbreviated, misspelled, or included local school nicknames.

For example, it could confidently map:

“PLC Syd” → “Presbyterian Ladies’ College Sydney”
“Cerdon Collage” → “Cerdon College”
“St Cats” → “St Catherine’s School, Waverley”

That level of contextual correction is almost impossible to achieve with pure algorithmic matching unless you maintain a custom dictionary of every possible variation. And who has time for that!

The trade-off, of course, is performance. Generative models are slower and costlier to run at scale. But when used selectively, just for ambiguous or hard-to-match cases, they can dramatically improve accuracy. And of course this is something this specifically works well for names, like schools, that are well documented on the internet – something that doesn’t apply to the names of individual school students.

Can we have the best of both worlds?

hybrid AI + Algorithmic matching!

In practice, the best results came from a hybrid approach, using traditional fuzzy-matching algorithms for most cases, and bringing in Azure OpenAI only when the names got tricky. For example, RapidFuzz could quickly match “Lizzy Wong” to “Elizabeth Wong,” while the generative model was better at reasoning through ambiguous inputs like “Sally-Anne W.” or reversed multicultural name orders. By combining both, I could match almost every student record accurately, keeping the speed of algorithmic methods while adding the contextual understanding of generative AI.

Try It Yourself

🎥 You can watch my full PyCon AU 2025 talk here:
What’s in a Name: Fuzzy Matching Techniques for Proper Nouns

📁 If you’d like to explore this further you can check out my fuzzy matching repo.

Take a look at the libraries and tool I mentioned above, they’re easy to install and experiment with in Python. If you’re already using Azure OpenAI, it’s worth testing how a small retrieval-augmented setup might complement your existing matching logic.

Chat to us!

💬 To chat more about AI solutions you can join the AI Foundry Discord, where advocates like me are chatting about the latest tools all the time.

Join the Azure AI Foundry Discord here

Good luck on your fuzzy matching adventures!

A Better Way to Tune the JVM in Dockerfiles and Kubernetes Manifests

Bruno Borges — Fri, 12 Sep 2025 03:36:26 +0000

When tuning the JVM inside containers, I often see Dockerfiles and Kubernetes manifests with long, hard-to-read java commands packed with -Xmx, -XX:+UseG1GC, and other flags. Every time you want to tweak memory or GC settings, you have to edit those commands and rebuild or redeploy.

Free webinar Java on Kubernetes Performance Engineering

Running Java on Kubernetes? It's harder - and more critical - than you think. Join us September 25th, 2025, for a live webinar with Akamas & Microsoft on tuning Java apps at scale. JVM tips, GC tuning, JDK 25, Project Leyden & more.

What about JAVA_OPTS?

This flag is not read by the JVM itself. It only works if the launch script explicitly uses it and expands its content into the call to the java launcher. It behaves exactly the same as Apache Tomcat's CATALINA_OPTS, which is read by catalina.sh.

There’s a much cleaner way to do this... and it’s built into the JDK. It’s the most modern, well-scoped solution, playing well with deployment orchestration solutions like Kubernetes.

🚀 Enter JDK_JAVA_OPTIONS

JDK_JAVA_OPTIONS is an environment variable that the JVM reads automatically. Whatever you put there gets appended to the command line of every JDK tool (java, javac, jshell, etc.) This means you can move all your tuning flags out of your launcher command, keeping your Dockerfiles and manifests clean and maintainable.

Cleaned-up Dockerfile

Before (messy):

CMD ["java", "-Xmx512m", "-XX:+UseG1GC", "-jar", "app.jar"]

After (clean):

ENV JDK_JAVA_OPTIONS="-Xmx512m -XX:+UseG1GC"
CMD ["java", "-jar", "app.jar"]

Now, if you need to change heap size or GC settings, you just update the environment variable. No need to touch the command.

Kubernetes Example

If your container is likely to end up on Kubernetes, don't even tune the JVM in the Dockerfile. Consider leaving this as an external configuration, coming from the Kubernetes manifest.

This is because the container image doesn't know what memory limits will be applied during runtime. And even if you set a MaxRAMPercentage for the heap, the amount you set may not be ideal if the container ends up with too much memory, potentially wasting memory from the delta not used, for example.

containers:
  - name: myapp
    image: myapp:latest
    env:
      - name: JDK_JAVA_OPTIONS
        value: "-Xmx512m -XX:+UseG1GC"

Your deployment YAML stays clean and your operations team can tune JVM behavior at deploy time without changing the image.

Why JDK_JAVA_OPTIONS Is Better

✅ Cleaner Manifests – fewer arguments to maintain
🔄 Configurable at Runtime – no rebuild required
🛠 Debug-Friendly – JVM prints the options it picked up
🐳 Perfect for Containers – works across Docker, Kubernetes, ECS, etc.
🎯 Applies to All JDK Tools – not just java, but also javac, jshell, etc.

If you’re running Java apps in Docker or Kubernetes, stop hardcoding JVM flags into your command line. Use JDK_JAVA_OPTIONS instead. It makes your images cleaner, your manifests easier to read, and your JVM tuning more flexible.

Precedence, Order of Priority, and Scope

The HotSpot JVM supports, in practice, three environment variables. And for many historical reasons we ended up in this situation.

But in what order are they processed, and where? The rule of thumb is below. Except that in JDK 8, the variable JDK_JAVA_OPTIONS is not supported.


_JAVA_OPTIONS > JDK_JAVA_OPTIONS > JAVA_TOOL_OPTIONS

Besides the order they are processed, there is also where they are processed and how this impacts what parameters are effective.

According to the bug JDK-8170832:

_JAVA_OPTIONS and JAVA_TOOL_OPTIONS environment variable are interpreted by the VM, not the launcher [java], hence no @-files or launcher-only options. The former is undocumented and unsupported but widely used; the latter is documented and supported.

You can see for yourself the behaviour of these environment variables with this little project I built (with GitHub Copilot): github.com/brunoborges/jdk-env-vars

Thoughts?

What JVM tuning tricks are you using in containers today?
Have you tried JDK_JAVA_OPTIONS yet?
Did you know about it?

Comment below.

Resources

OpenJDK 21: JAVA_TOOL_OPTIONS documentation
OpenJDK 21: JDK_JAVA_OPTIONS documentation
JDK-8170832: Add a new launcher environment variables

Model Mondays S2E04 - AI Developer Experiences

Nitya Narasimhan, Ph.D — Fri, 11 Jul 2025 03:25:13 +0000

🧪 | Some parts of this blog were generated with AI assistance, and reviewed manually before publishing. To learn more about the why and the how, please refer to this document in our website.

Model Mondays is a weekly series that helps you build your AI Model IQ with 5-min news recaps, 15-min tech spotlights and 30-min AMA sessions with subject matter experts. Join us!

Register for upcoming livestreams (Mon @1:30pm ET)

Register for upcoming AMAs (Fri @1:30pm ET)

Subscribe to the weekly newsletter

Explore Season 1 & Season 2 episodes on our repo!

⁉️ | Have questions on the AI TOOLKIT EXTENSION FOR VS CODE

Download the AI Toolkit and try it!

Join the AMA on Friday, Jul 11 on the Azure AI Foundry Discord.

Visit recaps & resources on the Forum to keep learning.

Spotlight On: AI Developer Experiences

In this episode we got to see a hands-on demo from Leo Yao, a Product Manager for the AI Toolkit, who took us through the various tools and capabilities that this extension brings to Visual Studio Code, to streamline our AI development journey. If you missed the livestream, you can catch up on the recap here:

What You'll Learn

So why should you watch this episode? Simple! If you wanted to see how you could streamline your AI Developer Experience without ever leaving Visual Studio Code, then the AI Toolkit is the extension you want to explore. In the space of just 15 minutes, I got to see Leo complete the following tasks, all within the IDE!

Discover & use GitHub Models with a built-in playground feature.
Deploy models (GPT-4) to Azure AI Foundry directly from VS Code.
Build AI agents with Agent Builder (to createa a math tutor)
Configure agents with prompts & tools (for an escape room helper)
Integrate MCP servers to extend functionality (custom Python code)
Deploy agents locally, and to Azure AI Foundry (for flexibility)

And that was just in 15-minutes. I can only imagine what other features and tools we are yet to discover if we try this out ourselves. Want to get links to the extension, documentation and key resources to skill up? You'll find the links in the deck below:

How to Get Started

Looking back, my first introduction to the AI Toolkit was in Model Mondays Season 1, from Microsoft Product PM Rong Lu. She gave us a comprehensive overview of the various features including support for data generation and evaluation. I recommend taking 15 minutes to review her demo in this episode:

Once you're familiar with the basics, I recommend you check out these three links to dive deeper into the process of building agent-based solutions on Azure AI Foundry with AI Toolkit and Visual Studio Code.

1. AI Toolkit for Visual Studio Code - Getting Started Guide - This is my recommended starting point. The tutorial covers installation, then walks you through the steps for downloading models from the catalog, then testing and integrating models into your application. You can then keep going with more tutorials to learn other features like fine-tuning support.

2. Azure AI Foundry Extension for Visual Studio Code - This extension now lets you work with the Azure AI Foundry platform capabilities directly from VS Code. This screenshot from the docs gives you a sense of the tasks you can achieve from your IDE - including project setup and model deployments.

3. Agent Builder in AI Toolkit -The Agent Builder in AI Toolkit simplifies and streamlines your workflow for building agents - from prompt engineering to tool integration (including with MCP servers). Get an intuitive sense for going from model to prompt to agentic workflows with tooling help.

⁉️ | Have questions? Don't forget to join us for the AMA on Friday (Jul 11) on the Azure AI Foundry Discord. Post your questions early on the Forum or revisit it later to get the transcript and resources from the discussion!

Read The Blog

Want an easy way to catch up on all the news? Check out complete blog series written by our resident student blogger here on Tech Community!

You can also follow her posts, right here on dev.to:

Sharda KaurFollow

Gold @Microsoft MLSA || Technical Content Writer || Open Source Contributor || Web Developer || CUIET MCA'26

Build Your Model IQ!

Model Mondays Season 2 is currently scheduled to go from June to September, covering the 12 key topics shown below.

👉🏽👉🏽 Register for Upcoming Livestreams to get reminders
👉🏽👉🏽 Register for Upcoming AMAs to get reminders

Using LlamaIndex.TS to Orchestrate MCP Servers

Wassim Chegham — Mon, 07 Jul 2025 15:49:59 +0000

In this post, we’ll demonstrate how to orchestrate Model Context Protocol (MCP) servers using llamaindex.TS in a real-world TypeScript application. We’ll use the Azure AI Travel Agents project as our base, focusing on best practices for secure, scalable, and maintainable orchestration. Feel free to star the repo to get notified with the latest changes.

If you are interested in an overview of the Azure AI Travel Agents project, please read our announcement blog!

Why llamaindex.TS and MCP?

llamaindex.TS provides a modular, composable framework for building LLM-powered applications in TypeScript.
MCP enables tool interoperability and streaming, making it ideal for orchestrating multiple AI services.

Project Structure

The Llamaindex.TS orchestrator lives in src/api/src/orchestrator/llamaindex, with provider modules for different LLM backends and MCP clients. We currently support:

Azure OpenAI
Docker Models
Azure AI Foundry Local
Github Model
Ollama

Feel free to explore the code base and suggest more providers.

Setting Up the MCP Client with Streamable HTTP

To interact with MCP servers, without using Llamaindex.TS, we can write a custom implementation using the StreamableHTTPClientTransport for efficient, authenticated, and streaming communication.

// filepath: src/api/src/mcp/mcp-http-client.ts
import EventEmitter from 'node:events';
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

export class MCPClient extends EventEmitter {
  private client: Client;
  private transport: StreamableHTTPClientTransport;

  constructor(serverName: string, serverUrl: string, accessToken?: string) {
    this.transport = new StreamableHTTPClientTransport({
      url: serverUrl,
      headers: accessToken ? { Authorization: `Bearer ${accessToken}` } : {},
    });
    this.client = new Client(serverName, this.transport);
  }

  async connect() {
    await this.client.initialize();
  }

  async listTools() {
    return this.client.listTools();
  }

  async callTool(name: string, toolArgs: any) {
    return this.client.callTool(name, toolArgs);
  }

  async close() {
    await this.client.closeGracefully();
  }
}

Best Practice: Always pass the Authorization header for secure access, as shown above.

Calling manually an MCP Tool from the Orchestrator

Suppose you want to get destination recommendations from the MCP server:

import { MCPClient } from '../../mcp/mcp-http-client';

const DESTINATION_SERVER_URL = process.env.MCP_DESTINATION_RECOMMENDATION_URL!;
const ACCESS_TOKEN = process.env.MCP_DESTINATION_RECOMMENDATION_ACCESS_TOKEN;

const mcpClient = new MCPClient('destination-recommendation', DESTINATION_SERVER_URL, ACCESS_TOKEN);

await mcpClient.connect();

const tools = await mcpClient.listTools();
console.log('Available tools:', tools);

const result = await mcpClient.callTool('getDestinationsByPreferences', {
  activity: 'CULTURAL',
  budget: 'MODERATE',
  season: 'SUMMER',
  familyFriendly: true,
});
console.log('Recommended destinations:', result);

await mcpClient.close();

Tip: Always close the MCP client gracefully to release resources.

Orchestrating LLMs and MCP Tools with Llamaindex.TS

The mcp client from @llamaindex/tools makes it easy to connect to MCP servers and retrieve tool definitions dynamically. Below is a sample from the project’s orchestrator setup, showing how to use mcp to fetch tools and create agents for each MCP server.

Here is an example of what an mcpServerConfig object might look like:

const mcpServerConfig = {
  url: "http://localhost:5007", // MCP server endpoint
  accessToken: process.env.MCP_ECHO_PING_ACCESS_TOKEN, // Secure token from env
  name: "echo-ping", // Logical name for the server
};

You can then use this config with the mcp client:

import { mcp } from "@llamaindex/tools";
import { agent, multiAgent, ToolCallLLM } from "llamaindex";

// ...existing code...

const mcpServerConfig = mcpToolsConfig["echo-ping"].config;
const tools = await mcp(mcpServerConfig).tools();
const echoAgent = agent({
  name: "EchoAgent",
  systemPrompt:
    "Echo back the received input. Do not respond with anything else. Always call the tools.",
  tools,
  llm,
  verbose,
});
agentsList.push(echoAgent);
handoffTargets.push(echoAgent);
toolsList.push(...tools);

// ...other code...

const travelAgent = agent({
  name: "TravelAgent",
  systemPrompt:
    "Acts as a triage agent to determine the best course of action for the user's query. If you cannot handle the query, please pass it to the next agent. If you can handle the query, please do so.",
  tools: [...toolsList],
  canHandoffTo: handoffTargets
    .map((target) => target.getAgents().map((agent) => agent.name))
    .flat(),
  llm,
  verbose,
});
agentsList.push(travelAgent);

// Create the multi-agent workflow
return multiAgent({
  agents: agentsList,
  rootAgent: travelAgent,
  verbose,
});

You can repeat this pattern to compose a multi-agent workflow where each agent is powered by tools discovered at runtime from the MCP server. See project for a full example.

You can then use this LLM instance to orchestrate calls to MCP tools, such as itinerary planning or destination recommendation.

Security Considerations

Always use access tokens and secure headers.
Never hardcode secrets; use environment variables and secret managers.

Join the Community:

We encourage you to join our Azure AI Foundry Developer Community to share your experiences, ask questions, and get support:

Join our Discord community for real-time discussions and support.
Visit our Azure AI Foundry Developer Forum to ask questions and share your knowledge.

Conclusion

By combining llamaindex.TS with MCP’s Streamable HTTP transport, you can orchestrate powerful, secure, and scalable AI workflows in TypeScript. The Azure AI Travel Agents project provides a robust template for building your own orchestrator.

References:

Model Mondays S2E03 - SLMs and Reasoning

Nitya Narasimhan, Ph.D — Thu, 03 Jul 2025 03:01:19 +0000

Model Mondays is a weekly series that helps you build your AI Model IQ with 5-min news recaps, 15-min tech spotlights and 30-min AMA sessions with subject matter experts. Join us!

Register for upcoming livestreams (Mon @1:30pm ET)

Register for upcoming AMAs (Fri @1:30pm ET)

Subscribe to the weekly newsletter

Explore Seasom 1 & Season 2 episodes on our repo!

Spotlight On: SLMs and Reasoning

🧪 | This section was generated with AI help and human revision & review. To learn more, please refer to this document in our website.

How can you bring advanced reasoning to resource-constrained devices? This session explores the latest in Small Language Models (SLMs) like Phi-4, which are redefining what’s possible for agentic apps.

Mojan Javaheripi, a Senior Microsoft Researcher, will discuss how SLMs leverage inference-time scaling and chain-of-thought reasoning to deliver powerful results on smaller hardware. Discover use cases, deployment strategies, and how SLMs are making AI more accessible and efficient for everyone.

Download The Deck With Key Resource Links:

Phi-4 Reasoning: Power Through Precision

In her spotlight talk, Mojan introduced the Phi-4-reasoning model and a Phi-4-reasoning-plus model and walked us through the techniques used to create these variants in a manner that allows them to work in resource-constrained environments, while providing comparable accuracy to larger language models. The motivation for this work comes from wanting to bridge the gap between large frontier models and smaller, more efficient models that can run on commodity hardware including personal devices like laptops, but also edge devices at industry scale.

Watch The Replay From Her Livestream

Why is this important?

The Phi-4 reasoning models are designed for explicit, step-by-step problem solving, with a focus on explainability and logical decomposition. Mojan details the training pipeline, including data curation, supervised fine-tuning, and reinforcement learning, and shares benchmarking results that show Phi-4 models outperforming much larger models in math, science, and coding tasks. The discussion covers community adoption, quantization for edge devices, and the importance of fine-tuning for domain-specific applications. Real-world use cases include intelligent tutoring, autonomous agents, code generation, and strategic planning.

Key Takeaways From The Session

Phi-4 reasoning models deliver state-of-the-art reasoning and efficiency at a fraction of the size of frontier models.
SLMs are ideal for edge, local, and resource-constrained deployments, with strong support for quantization and customization.
Fine-tuning & reinforcement learning enable adaptation to new domains & tasks.
Open-source and community contributions accelerate innovation and adoption.
Responsible AI, safety, and explainability are core to Phi-4 model design.

Sidebar: AI & Content Generation

You may have noticed the 🧪 annotation about AI-generated content. Let's talk about how this was done, and why.

Model Mondays is a series about building your AI model IQ - and learning how to find the right model for the task. And the best way to learn something is by applying it to a real problem. Starting this week, I'm using AI to streamline many content-related tasks for Model Mondays. And I wanted to share not just the reasoning for this, but the process and tooling I use - in the hopes that it helps others find productive uses for the same workflows.

Motivation: Efficiency

On a weekly basis I have to plan for two different sessions (livestream and AMA), coordinate across speakers and hosts, then publish pre- and post- event content writeups that provide promotion and recap value respectively.

Writing these manually is not just time-consuming, it is also complicated by the fact that each week has new topics to research - and new discussions to summarize that require cognitive bandwidth. My a-ha moment was in recognizing that prompt creation is also content creation and crafting a well-written prompt to create content can be as rewarding and effective as authoring the content from scratch.

Workflow: Agent Mode + MCP

How am I doing this? I'm using Visual Studio Code Agent Mode in a GitHub Codespaces environment launched on the Model Mondays repo. Every task is reduced to a custom prompt that is stored in the codebase for reuse.

Here are some examples:

Give it the YouTube transcript and have it summarize it
Give it the AMA transcript and have it generate a recap
Detect key terms and use MCP Servers to find resource links.

You can simplify this further if you use MCP Servers to extend Agent Mode as shown - adding new "tools" to help the agent perform key tasks.

In my case, there were 3 tools that were immediately helpful:

Microsoft Docs MCP Server - for related resources
Hugging Face MCP Server - for Model Hub links
Azure AI Foundry MCP Server - for Azure AI Foundry Models catalog

Want to see these in action? Check out the "Related Resources" in this post, populated by using the three MCP servers above.

Keep reading this series for more updates and learnings from our AI experiments!

Read The Recap

Want an easy way to catch up on all the news? Check out complete blog series written by our resident student blogger here on Tech Community!

You can also catch her recap for this week, right here on dev.to:

Sharda Kaur

Jul 5 '25

I Wrote About SLMs in Model Mondays: Easy Explanation Inside!

#microsoft #beginners #ai

1 min read

Build Your Model IQ!

Model Mondays Season 2 is currently scheduled to go from June to September, covering the 12 key topics shown below.

👉🏽👉🏽 Register for Upcoming Livestreams to get reminders
👉🏽👉🏽 Register for Upcoming AMAs to get reminders

Model Mondays S2E02 - AMA on Model Context Protocol

Nitya Narasimhan, Ph.D — Tue, 24 Jun 2025 17:50:47 +0000

Model Mondays is a weekly series that helps you come up to speed with the fast-moving world of AI models. Here are 3 actions you can take to build your model IQ:

Watch Model Mondays Live - for news roundup & tech spotlights in 30 mins
Join Foundry Friday AMA - for discussions with Q&A featuring AI experts
Subscribe Model Mondays Newsletter - a weekly pulse on AI innovation & tech

Spotlight On: Model Context Protocol

We put the spotlight on Model Context Protocol (MCP) with a deep-dive from Den Delimarsky, a member of the MCP Steering Committee.

👉🏽👉🏽 Register for the AMA on our Azure AI Foundry Discord
👉🏽👉🏽 Post Your Questions on our Discussion Forum

Then check out the slides from the presentation, for resource links!

About Model Context Protocol (MCP)

MCP is a protocol that standardizes how AI applications connect the underlying AI models to required knowledge sources (data) and interaction APIs (functions) for more effective task execution. Because these models are pre-trained, they lack access to real-time or proprietary data sources (for knowledge) and real-world environments (for interaction). MCP allows them to "discover and use" relevant knowledge and action tools to add relevant context to the model for task execution.

Explore: The MCP Specification
Learn: MCP For Beginners
Watch: Anthropic Workshop on MCP (below), AI Engineer Summit NY 2025

Securing MCP

As MCP started gaining traction, the conversation turned to the topic of secure MCP usage, particularly in enterprise environments. How should MCP clients authenticate with MCP servers, and get authorization for access to the right resources? In early 2025, the conversation began on an MCP Authorization spec - here are the three documents that help you understand the issues & proposal process.

Aaron Parecki, Let's Fix OAuth in MCP
Den Delimarsky, Improving The MCP Authorization Spec - One RFC At A Time
MCP Specification, Authorization protocol draft

On Monday, Den joined us live to talk about the work he did for the authorization protocol. Watch the session now to get a sense for what the MCP Authorization protocol does, how it works, and why it matters. Have questions? Submit them to the forum or Jon the Foundry Friday AMA on Jun 27 at 1:30pm ET.

Learning MCP

Want to get hands-on experience with MCP from fundamentals to best practices? Explore the "MCP For Beginners" curriculum - a 10-lesson open-source curriculum that is constantly being updated to reflect the latest progress and examples of MCP in action. Go from fundamental concepts to best practices, with hands-on exercises.

👉🏽👉🏽 Explore the Curriculum on GitHub

Read The Recap

Want an easy way to catch up on all the news? Check out complete blog series written by our resident student blogger here on Tech Community!

You can also catch her recap for this week, right here on dev.to:

Sharda Kaur

Jun 29 '25

🚀 Model Mondays S2E2: Understanding Model Context Protocol (MCP) – A Beginner-Friendly Guide

#opensource #mcp #microsoft #beginners

1 min read

Continue Building Model IQ

Check out the upcoming episodes and register for livestreams & AMA:

👉🏽👉🏽 Register for Livestreams to get reminders
👉🏽👉🏽 Register for AMAs to get reminders

DEV Community: Microsoft Azure

Getting started with GitHub Copilot part 2, streamable responses

Series on Copilot SDK

Addressing the problem

Links

Get started with GitHub Copilot CLI: A free, hands-on course

What GitHub Copilot CLI can do

What the course covers

Who this is for

How the course teaches

Get started

Get started with GitHub Copilot SDK, part 1

Series on Copilot SDK

Install

The parts

Your first app

What's next

The JavaScript AI Build-a-thon Season 2 starts March 2!

How the program works!

Phase I: Learn & Skill Up Schedule (Mar 2 - 13)

Phase II: Global Hack! (Mar 13 - 31)

Start Now (Join the Community)

Host Your Node.js MCP Server on Azure Functions in 1 Simple Step

TL;DR key takeaways

What will you learn here?

Reference links for everything we use

Requirements

What is MCP and why does it matter?

Why Azure Functions for MCP servers?

1 simple step to enable Functions hosting

Step 1: Add the host.json configuration

Real-world example: Burger MCP Server

Current limitations

Testing the MCP server locally

Using MCP Inspector

Using GitHub Copilot (with remote MCP)

(Bonus) Deploying to Azure with Infrastructure as Code

Example projects

What about the cost?

Wrap up

Serverless MCP Agent with LangChain.js v1 — Burgers, Tools, and Traces 🍔

TL;DR key takeaways

What will you learn here?

Reference links for everything we use

Use case

Sample overview

LangChain.js v1 agent features

Quickstart

Requirements

Deploy and run the sample

Provision and deploy to Azure

Test the MCP server

MCP tools

Test the Agent Web App

Wrap it up

Going further

What’s in a Name? Fuzzy Matching for Real-World Data

The Fuzzy Matching Challenge

Comparing Algorithmic Approaches

When Generative AI Shines

Can we have the best of both worlds?

Try It Yourself

Chat to us!

A Better Way to Tune the JVM in Dockerfiles and Kubernetes Manifests

Free webinar Java on Kubernetes Performance Engineering

What about JAVA_OPTS?

🚀 Enter JDK_JAVA_OPTIONS

Cleaned-up Dockerfile

Kubernetes Example

Why JDK_JAVA_OPTIONS Is Better

Precedence, Order of Priority, and Scope

Thoughts?

Resources

Model Mondays S2E04 - AI Developer Experiences

Spotlight On: AI Developer Experiences

What You'll Learn

How to Get Started

Read The Blog

Sharda KaurFollow

Build Your Model IQ!

Step 1: Add the `host.json` configuration