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

Підприємницька інтеграція

При побудові MCP серверів у підприємницькому контексті часто потрібно інтегруватися з існуючими AI платформами та сервісами. У цьому розділі описується, як інтегрувати MCP з підприємницькими системами, такими як Azure OpenAI та Microsoft AI Foundry, що дозволяє отримати розширені можливості штучного інтелекту та оркестрацію інструментів.

Вступ

У цьому уроці ви дізнаєтеся, як інтегрувати Протокол Контексту Моделі (MCP) з підприємницькими AI системами з акцентом на Azure OpenAI та Microsoft AI Foundry. Ці інтеграції дозволяють використовувати потужні AI моделі та інструменти, зберігаючи гнучкість та розширюваність MCP.

Цілі навчання

Після цього уроку ви зможете:

• Інтегрувати MCP з Azure OpenAI для використання його AI можливостей.
• Реалізувати оркестрацію інструментів MCP з Azure OpenAI.
• Поєднувати MCP з Microsoft AI Foundry для розширених можливостей AI агентів.
• Використовувати Azure Machine Learning (ML) для виконання ML конвеєрів та реєстрації моделей як інструментів MCP.

Інтеграція з Azure OpenAI

Azure OpenAI надає доступ до потужних AI моделей, таких як GPT-4 та інших. Інтеграція MCP з Azure OpenAI дозволяє використовувати ці моделі, зберігаючи гнучкість оркестрації інструментів MCP.

Реалізація на C#

У цьому фрагменті коду ми показуємо, як інтегрувати MCP з Azure OpenAI, використовуючи SDK Azure OpenAI.

// .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;
        }
    }
}

У наведеному вище коді ми:

• Налаштували клієнт Azure OpenAI з кінцевою точкою, іменем розгортання та API ключем.
• Створили метод GetCompletionWithToolsAsync для отримання результатів із підтримкою інструментів.
• Опрацювали виклики інструментів у відповіді.

Рекомендується реалізувати логіку обробки інструментів відповідно до конкретної конфігурації вашого MCP сервера.

Інтеграція з Microsoft Foundry

Microsoft Foundry надає платформу для створення та розгортання AI агентів. Інтеграція MCP з Microsoft Foundry дозволяє використовувати її можливості, зберігаючи гнучкість MCP.

У наведеному нижче коді ми розробляємо інтеграцію агента, який обробляє запити та виклики інструментів за допомогою MCP.

Реалізація на Java

// Інтеграція агента Java AI Foundry
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) {
        // Обробити запит агента AI Foundry
        AgentResponse initialResponse = agentClient.processRequest(request);
        
        // Перевірити, чи агент запросив використання інструментів
        if (initialResponse.getToolCalls() != null && !initialResponse.getToolCalls().isEmpty()) {
            // Для кожного виклику інструменту направити його до відповідного інструменту MCP
            for (AgentToolCall toolCall : initialResponse.getToolCalls()) {
                String toolName = toolCall.getName();
                Map<String, Object> parameters = toolCall.getArguments();
                
                // Виконати інструмент за допомогою MCP
                ToolResponse mcpResponse = mcpClient.executeTool(toolName, parameters);
                
                // Створити відповідь інструменту для AI Foundry
                AgentToolResponse toolResponse = new AgentToolResponse(
                    toolCall.getId(),
                    mcpResponse.getResult()
                );
                
                // Відправити відповідь інструменту назад агенту
                initialResponse = agentClient.submitToolResponse(
                    request.getConversationId(), 
                    toolResponse
                );
            }
        }
        
        return initialResponse;
    }
}

У наведеному вище коді ми:

• Створили клас AIFoundryMcpBridge, який інтегрується як з AI Foundry, так і з MCP.
• Реалізували метод processAgentRequest, який обробляє запит агента AI Foundry.
• Опрацювали виклики інструментів шляхом їх виконання через клієнта MCP і відправки результатів назад агенту AI Foundry.

Інтеграція MCP з Azure ML

Інтеграція MCP з Azure Machine Learning (ML) дозволяє використати потужні можливості Azure ML, зберігаючи гнучкість MCP. Ця інтеграція може бути використана для виконання ML конвеєрів, реєстрації моделей як інструментів та управління обчислювальними ресурсами.

Реалізація на Python

# Інтеграція Python з Azure AI
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):
        # Налаштувати клієнта MCP
        self.mcp_client = McpClient(server_url=mcp_server_url)
        
        # Налаштувати клієнта Azure ML
        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"""
        # Спочатку обробити вхідні дані за допомогою інструментів MCP
        processed_data = await self.mcp_client.execute_tool(
            "dataPreprocessor",
            {
                "data": input_data,
                "operations": ["normalize", "clean", "transform"]
            }
        )
        
        # Надіслати конвеєр в 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_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"""
        # Отримати деталі моделі
        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)
        
        # Створити середовище для розгортання
        env = Environment(
            name="mcp-model-env",
            conda_file="./environments/inference-env.yml"
        )
        
        # Налаштувати обчислювальні ресурси
        compute = self.ml_client.compute.get("mcp-inference")
        
        # Розгорнути модель як онлайн кінцеву точку
        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
                }
            }
        )
        
        # Створити схему інструменту MCP на основі схеми моделі
        tool_schema = {
            "type": "object",
            "properties": {},
            "required": []
        }
        
        # Додати властивості введення на основі схеми моделі
        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)
        
        # Зареєструвати як інструмент MCP
        # У реальній реалізації ви б створили інструмент, що викликає кінцеву точку
        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")

У наведеному вище коді ми:

• Створили клас EnterpriseAiIntegration, який інтегрує MCP з Azure ML.
• Реалізували метод execute_ml_pipeline, який обробляє вхідні дані за допомогою MCP інструментів і запускає ML конвеєр у Azure ML.
• Реалізували метод register_ml_model_as_tool, який реєструє модель Azure ML як інструмент MCP, включаючи створення необхідного середовища розгортання та обчислювальних ресурсів.
• Відобразили типи даних Azure ML у типи схеми JSON для реєстрації інструментів.
• Використали асинхронне програмування для обробки потенційно довготривалих операцій, таких як виконання ML конвеєру та реєстрація моделі.

Що далі

• 5.2 Багатомодальність

---

Відмова від відповідальності: Цей документ було перекладено за допомогою сервісу штучного інтелекту для перекладу Co-op Translator. Хоча ми прагнемо до точності, будь ласка, майте на увазі, що автоматичні переклади можуть містити помилки або неточності. Оригінальний документ рідною мовою слід вважати авторитетним джерелом. Для критично важливої інформації рекомендується професійний людський переклад. Ми не несемо відповідальності за будь-які непорозуміння або неправильні тлумачення, що виникли внаслідок використання цього перекладу.