5.1 Integration with Azure

Enterprise Integration

When building MCP Servers in an enterprise context, you often need to integrate with existing AI platforms and services.

This section covers how to integrate MCP with enterprise systems like Azure OpenAI and Microsoft AI Foundry, enabling advanced AI capabilities and tool orchestration.

Introduction

In this lesson, you'll learn how to integrate Model Context Protocol (MCP) with enterprise AI systems, focusing on Azure OpenAI and Microsoft AI Foundry.

These integrations allow you to leverage powerful AI models and tools while maintaining the flexibility and extensibility of MCP.

Learning Objectives

By the end of this lesson, you will be able to:

Azure OpenAI Integration

Azure OpenAI provides access to powerful AI models like GPT-4 and others. Integrating MCP with Azure OpenAI allows you to utilize these models while maintaining the flexibility of MCP's tool orchestration.

C# Implementation

In this code snippet, we demonstrate how to integrate MCP with Azure OpenAI using the Azure OpenAI SDK.

// .NET Azure OpenAI Integration

using Microsoft.Mcp.Client;

using Azure.AI.OpenAI;

using Microsoft.Extensions.Configuration;

using System.Threading.Tasks;



namespace EnterpriseIntegration

{

    public class AzureOpenAiMcpClient

    {

        private readonly string _endpoint;

        private readonly string _apiKey;

        private readonly string _deploymentName;

        

        public AzureOpenAiMcpClient(IConfiguration config)

        {

            _endpoint = config["AzureOpenAI:Endpoint"];

            _apiKey = config["AzureOpenAI:ApiKey"];

            _deploymentName = config["AzureOpenAI:DeploymentName"];

        }

        

        public async Task<string> GetCompletionWithToolsAsync(string prompt, params string[] allowedTools)

        {

            // Create OpenAI client

            var client = new OpenAIClient(new Uri(_endpoint), new AzureKeyCredential(_apiKey));

            

            // Create completion options with tools

            var completionOptions = new ChatCompletionsOptions

            {

                DeploymentName = _deploymentName,

                Messages = { new ChatMessage(ChatRole.User, prompt) },

                Temperature = 0.7f,

                MaxTokens = 800

            };

            

            // Add tool definitions

            foreach (var tool in allowedTools)

            {

                completionOptions.Tools.Add(new ChatCompletionsFunctionToolDefinition

                {

                    Name = tool,

                    // In a real implementation, you'd add the tool schema here

                });

            }

            

            // Get completion response

            var response = await client.GetChatCompletionsAsync(completionOptions);

            

            // Handle tool calls in the response

            foreach (var toolCall in response.Value.Choices[0].Message.ToolCalls)

            {

                // Implementation to handle Azure OpenAI tool calls with MCP

                // ...

            }

            

            return response.Value.Choices[0].Message.Content;

        }

    }

}

In the preceding code we've:

You're encouraged to implement the actual tool handling logic based on your specific MCP server setup.

Microsoft AI Foundry Integration

Azure AI Foundry provides a platform for building and deploying AI agents. Integrating MCP with AI Foundry allows you to leverage its capabilities while maintaining the flexibility of MCP.

In the below code, we develop an Agent integration that processes requests and handles tool calls using MCP.

Java Implementation

// Java AI Foundry Agent Integration

package com.example.mcp.enterprise;



import com.microsoft.aifoundry.AgentClient;

import com.microsoft.aifoundry.AgentToolResponse;

import com.microsoft.aifoundry.models.AgentRequest;

import com.microsoft.aifoundry.models.AgentResponse;

import com.mcp.client.McpClient;

import com.mcp.tools.ToolRequest;

import com.mcp.tools.ToolResponse;



public class AIFoundryMcpBridge {

    private final AgentClient agentClient;

    private final McpClient mcpClient;

    

    public AIFoundryMcpBridge(String aiFoundryEndpoint, String mcpServerUrl) {

        this.agentClient = new AgentClient(aiFoundryEndpoint);

        this.mcpClient = new McpClient.Builder()

            .setServerUrl(mcpServerUrl)

            .build();

    }

    

    public AgentResponse processAgentRequest(AgentRequest request) {

        // Process the AI Foundry Agent request

        AgentResponse initialResponse = agentClient.processRequest(request);

        

        // Check if the agent requested to use tools

        if (initialResponse.getToolCalls() != null && !initialResponse.getToolCalls().isEmpty()) {

            // For each tool call, route it to the appropriate MCP tool

            for (AgentToolCall toolCall : initialResponse.getToolCalls()) {

                String toolName = toolCall.getName();

                Map<String, Object> parameters = toolCall.getArguments();

                

                // Execute the tool using MCP

                ToolResponse mcpResponse = mcpClient.executeTool(toolName, parameters);

                

                // Create tool response for AI Foundry

                AgentToolResponse toolResponse = new AgentToolResponse(

                    toolCall.getId(),

                    mcpResponse.getResult()

                );

                

                // Submit tool response back to the agent

                initialResponse = agentClient.submitToolResponse(

                    request.getConversationId(), 

                    toolResponse

                );

            }

        }

        

        return initialResponse;

    }

}

In the preceding code, we've:

Integrating MCP with Azure ML

Integrating MCP with Azure Machine Learning (ML) allows you to leverage Azure's powerful ML capabilities while maintaining the flexibility of MCP.

This integration can be used to execute ML pipelines, register models as tools, and manage compute resources.

Python Implementation

# Python Azure AI Integration

from mcp_client import McpClient

from azure.ai.ml import MLClient

from azure.identity import DefaultAzureCredential

from azure.ai.ml.entities import Environment, AmlCompute

import os

import asyncio



class EnterpriseAiIntegration:

    def __init__(self, mcp_server_url, subscription_id, resource_group, workspace_name):

        # Set up MCP client

        self.mcp_client = McpClient(server_url=mcp_server_url)

        

        # Set up Azure ML client

        self.credential = DefaultAzureCredential()

        self.ml_client = MLClient(

            self.credential,

            subscription_id,

            resource_group,

            workspace_name

        )

    

    async def execute_ml_pipeline(self, pipeline_name, input_data):

        """Executes an ML pipeline in Azure ML"""

        # First process the input data using MCP tools

        processed_data = await self.mcp_client.execute_tool(

            "dataPreprocessor",

            {

                "data": input_data,

                "operations": ["normalize", "clean", "transform"]

            }

        )

        

        # Submit the pipeline to Azure ML

        pipeline_job = self.ml_client.jobs.create_or_update(

            entity={

                "name": pipeline_name,

                "display_name": f"MCP-triggered {pipeline_name}",

                "experiment_name": "mcp-integration",

                "inputs": {

                    "processed_data": processed_data.result

                }

            }

        )

        

        # Return job information

        return {

            "job_id": pipeline_job.id,

            "status": pipeline_job.status,

            "creation_time": pipeline_job.creation_context.created_at

        }

    

    async def register_ml_model_as_tool(self, model_name, model_version="latest"):

        """Registers an Azure ML model as an MCP tool"""

        # Get model details

        if model_version == "latest":

            model = self.ml_client.models.get(name=model_name, label="latest")

        else:

            model = self.ml_client.models.get(name=model_name, version=model_version)

        

        # Create deployment environment

        env = Environment(

            name="mcp-model-env",

            conda_file="./environments/inference-env.yml"

        )

        

        # Set up compute

        compute = self.ml_client.compute.get("mcp-inference")

        

        # Deploy model as online endpoint

        deployment = self.ml_client.online_deployments.create_or_update(

            endpoint_name=f"mcp-{model_name}",

            deployment={

                "name": f"mcp-{model_name}-deployment",

                "model": model.id,

                "environment": env,

                "compute": compute,

                "scale_settings": {

                    "scale_type": "auto",

                    "min_instances": 1,

                    "max_instances": 3

                }

            }

        )

        

        # Create MCP tool schema based on model schema

        tool_schema = {

            "type": "object",

            "properties": {},

            "required": []

        }

        

        # Add input properties based on model schema

        for input_name, input_spec in model.signature.inputs.items():

            tool_schema["properties"][input_name] = {

                "type": self._map_ml_type_to_json_type(input_spec.type)

            }

            tool_schema["required"].append(input_name)

        

        # Register as MCP tool

        # In a real implementation, you would create a tool that calls the endpoint

        return {

            "model_name": model_name,

            "model_version": model.version,

            "endpoint": deployment.endpoint_uri,

            "tool_schema": tool_schema

        }

    

    def _map_ml_type_to_json_type(self, ml_type):

        """Maps ML data types to JSON schema types"""

        mapping = {

            "float": "number",

            "int": "integer",

            "bool": "boolean",

            "str": "string",

            "object": "object",

            "array": "array"

        }

        return mapping.get(ml_type, "string")

In the preceding code, we've:

What's next