microsoft--mcp-for-beginners/translations/sv/05-AdvancedTopics/mcp-integration/README.md

Företagsintegration

När du bygger MCP-servrar i en företagskontext behöver du ofta integrera med befintliga AI-plattformar och tjänster. Detta avsnitt täcker hur du integrerar MCP med företagsystem som Azure OpenAI och Microsoft AI Foundry, vilket möjliggör avancerade AI-funktioner och verktygsorkestrering.

Introduktion

I den här lektionen lär du dig hur du integrerar Model Context Protocol (MCP) med företags-AI-system, med fokus på Azure OpenAI och Microsoft AI Foundry. Dessa integrationer gör att du kan använda kraftfulla AI-modeller och verktyg samtidigt som du behåller MCP:s flexibilitet och utbyggbarhet.

Lärandemål

I slutet av denna lektion kommer du att kunna:

• Integrera MCP med Azure OpenAI för att använda dess AI-funktioner.
• Implementera MCP-verktygsorkestrering med Azure OpenAI.
• Kombinera MCP med Microsoft AI Foundry för avancerade AI-agentfunktioner.
• Utnyttja Azure Machine Learning (ML) för att köra ML-pipelines och registrera modeller som MCP-verktyg.

Azure OpenAI-integration

Azure OpenAI ger tillgång till kraftfulla AI-modeller som GPT-4 och andra. Genom att integrera MCP med Azure OpenAI kan du använda dessa modeller samtidigt som du behåller flexibiliteten i MCP:s verktygsorkestrering.

C#-implementering

I denna kodsnutt visar vi hur du integrerar MCP med Azure OpenAI med hjälp av 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;
        }
    }
}

I den föregående koden har vi:

• Konfigurerat Azure OpenAI-klienten med endpoint, driftsättningsnamn och API-nyckel.
• Skapat en metod GetCompletionWithToolsAsync för att få svar med verktygsstöd.
• Hanterat verktygsanrop i svaret.

Du uppmanas att implementera den faktiska logiken för verktygshantering baserat på din specifika MCP-serveruppsättning.

Microsoft Foundry-integration

Microsoft Foundry erbjuder en plattform för att bygga och distribuera AI-agenter. Genom att integrera MCP med Microsoft Foundry kan du utnyttja dess funktioner samtidigt som du bibehåller MCP:s flexibilitet.

I koden nedan utvecklar vi en agentintegration som bearbetar förfrågningar och hanterar verktygsanrop med MCP.

Java-implementering

// 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) {
        // Bearbeta AI Foundry Agent-förfrågan
        AgentResponse initialResponse = agentClient.processRequest(request);
        
        // Kontrollera om agenten begärde att använda verktyg
        if (initialResponse.getToolCalls() != null && !initialResponse.getToolCalls().isEmpty()) {
            // För varje verktygsanrop, dirigera det till rätt MCP-verktyg
            for (AgentToolCall toolCall : initialResponse.getToolCalls()) {
                String toolName = toolCall.getName();
                Map<String, Object> parameters = toolCall.getArguments();
                
                // Utför verktyget med hjälp av MCP
                ToolResponse mcpResponse = mcpClient.executeTool(toolName, parameters);
                
                // Skapa verktygssvar för AI Foundry
                AgentToolResponse toolResponse = new AgentToolResponse(
                    toolCall.getId(),
                    mcpResponse.getResult()
                );
                
                // Skicka verktygssvaret tillbaka till agenten
                initialResponse = agentClient.submitToolResponse(
                    request.getConversationId(), 
                    toolResponse
                );
            }
        }
        
        return initialResponse;
    }
}

I den föregående koden har vi:

• Skapat en klass AIFoundryMcpBridge som integrerar både AI Foundry och MCP.
• Implementerat en metod processAgentRequest som bearbetar en AI Foundry-agentförfrågan.
• Hanterat verktygsanrop genom att utföra dem via MCP-klienten och skicka tillbaka resultaten till AI Foundry-agenten.

Integrera MCP med Azure ML

Att integrera MCP med Azure Machine Learning (ML) gör att du kan utnyttja Azures kraftfulla ML-funktioner samtidigt som du behåller MCP:s flexibilitet. Denna integration kan användas för att köra ML-pipelines, registrera modeller som verktyg och hantera beräkningsresurser.

Python-implementering

# 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):
        # Ställ in MCP-klient
        self.mcp_client = McpClient(server_url=mcp_server_url)
        
        # Ställ in Azure ML-klient
        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"""
        # Bearbeta först indata med MCP-verktyg
        processed_data = await self.mcp_client.execute_tool(
            "dataPreprocessor",
            {
                "data": input_data,
                "operations": ["normalize", "clean", "transform"]
            }
        )
        
        # Skicka pipeline till 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
                }
            }
        )
        
        # Returnera jobbinformation
        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"""
        # Hämta modelldetaljer
        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)
        
        # Skapa distributionsmiljö
        env = Environment(
            name="mcp-model-env",
            conda_file="./environments/inference-env.yml"
        )
        
        # Ställ in beräkning
        compute = self.ml_client.compute.get("mcp-inference")
        
        # Distribuera modell som 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
                }
            }
        )
        
        # Skapa MCP-verktygsschema baserat på modelschema
        tool_schema = {
            "type": "object",
            "properties": {},
            "required": []
        }
        
        # Lägg till indataegenskaper baserat på modelschema
        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)
        
        # Registrera som MCP-verktyg
        # I en verklig implementation skulle du skapa ett verktyg som anropar endpointen
        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")

I den föregående koden har vi:

• Skapat en klass EnterpriseAiIntegration som integrerar MCP med Azure ML.
• Implementerat en metod execute_ml_pipeline som bearbetar indata med hjälp av MCP-verktyg och skickar en ML-pipeline till Azure ML.
• Implementerat en metod register_ml_model_as_tool som registrerar en Azure ML-modell som ett MCP-verktyg, inklusive att skapa nödvändig driftsättningsmiljö och beräkningsresurser.
• Mappat Azure ML-datatyper till JSON-schema-typer för verktygsregistrering.
• Använt asynkron programmering för att hantera potentiellt långvariga operationer som ML-pipeline-körning och modellregistrering.

Vad händer härnäst

• 5.2 Multi modality

---

Ansvarsfriskrivning: Detta dokument har översatts med hjälp av AI-översättningstjänsten Co-op Translator. Även om vi strävar efter noggrannhet, var vänlig notera att automatiska översättningar kan innehålla fel eller brister. Det ursprungliga dokumentet på dess modersmål bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för några missförstånd eller feltolkningar som uppstår till följd av användningen av denna översättning.