Azure AI Foundry & MCP: Enterprise AI Integration

Azure AI Foundry & MCP: Connecting Enterprise AI to Your Workflow

As enterprises increasingly leverage AI to drive innovation, the challenge shifts from building individual AI models to seamlessly integrating them into existing business processes and developer workflows. This is where Azure AI Foundry and the Microsoft Cloud Platform (MCP) SDKs shine. This chapter dives deep into how experienced developers can harness these tools to connect sophisticated AI capabilities, like those powered by Claude Code, into their .NET and Java applications, all orchestrated within the Azure ecosystem.

TL;DR

• Azure AI Foundry provides a curated, enterprise-grade platform for discovering, deploying, and managing AI models and solutions.
• MCP SDKs offer robust, idiomatic interfaces for interacting with Azure AI services from .NET and Java, simplifying complex API calls.
• Claude Code integration via MCP allows developers to leverage advanced generative AI capabilities within their applications.
• This chapter presents architectural patterns and practical code examples for seamless AI integration in enterprise contexts.

Understanding Azure AI Foundry and MCP

Azure AI Foundry isn’t just a collection of services; it’s a strategic approach to AI adoption. It emphasizes responsible AI, governance, and scalability. For developers, it means access to:

• Curated Models: Pre-trained and fine-tuned models, including those from partners, readily available for deployment.
• Deployment & Management: Simplified deployment pipelines, versioning, monitoring, and access control for AI assets.
• Developer Tooling: Integrated SDKs and APIs that abstract away low-level complexities.

The Microsoft Cloud Platform (MCP) SDKs are the primary programmatic interfaces to Azure services. For .NET and Java, these translate into intuitive, type-safe libraries that accelerate development. Key areas relevant to AI integration include:

• Azure OpenAI Service: For accessing powerful large language models (LLMs) like those behind Claude Code.
• Azure Machine Learning: For managing custom models, training, and endpoints.
• Azure AI Vision, Speech, Language: For specialized AI capabilities.

Crucially, MCP SDKs enable developers to interact with these services using familiar language constructs, reducing cognitive load and the likelihood of integration errors.

Integrating Claude Code with MCP in .NET

The claude CLI is your gateway to interacting with Claude Code models. When integrating with .NET applications, you’ll typically interact with the Azure OpenAI SDK, which provides access to compatible models. The key is to understand how to configure the SDK to point to your deployed model endpoint and then to leverage the generated prompts and responses within your application logic.

Architectural Consideration: For enterprise applications, a common pattern is to abstract AI interactions behind a dedicated service layer. This allows for easier testing, swapping out underlying models, and implementing cross-cutting concerns like logging, caching, and error handling.

Example Scenario: Imagine a .NET application that needs to summarize customer feedback. We’ll use the Azure OpenAI SDK to connect to a fine-tuned Claude Code model deployed on Azure.

Prerequisites:

1. Azure OpenAI Resource: A deployed Azure OpenAI resource with a Claude Code model deployment.
2. API Key and Endpoint: Obtained from your Azure portal.
3. NuGet Package: Azure.AI.OpenAI installed in your .NET project.

appsettings.json Configuration:

{
  "AzureOpenAI": {
    "Endpoint": "YOUR_AZURE_OPENAI_ENDPOINT",
    "DeploymentName": "claude-code-model-deployment", // Your specific deployment name
    "ApiKey": "YOUR_AZURE_OPENAI_API_KEY"
  }
}

C# Service Implementation:

using Azure;
using Azure.AI.OpenAI;
using Microsoft.Extensions.Configuration;
using System;
using System.IO;
using System.Threading.Tasks;

public class AiSummarizationService
{
    private readonly OpenAIClient _client;
    private readonly string _deploymentName;

    public AiSummarizationService(IConfiguration configuration)
    {
        var endpoint = configuration["AzureOpenAI:Endpoint"];
        var apiKey = configuration["AzureOpenAI:ApiKey"];
        _deploymentName = configuration["AzureOpenAI:DeploymentName"];

        if (string.IsNullOrEmpty(endpoint) || string.IsNullOrEmpty(apiKey) || string.IsNullOrEmpty(_deploymentName))
        {
            throw new ArgumentNullException("Azure OpenAI configuration is missing. Please ensure Endpoint, DeploymentName, and ApiKey are set.");
        }

        var credential = new AzureKeyCredential(apiKey);
        _client = new OpenAIClient(new Uri(endpoint), credential);
    }

    public async Task<string> SummarizeTextAsync(string inputText)
    {
        if (string.IsNullOrWhiteSpace(inputText))
        {
            return "Input text is empty.";
        }

        try
        {
            // Construct the prompt for Claude Code
            var prompt = $"Please summarize the following customer feedback:\n\n{inputText}\n\nSummary:";

            var chatCompletionsOptions = new ChatCompletionsOptions()
            {
                DeploymentName = _deploymentName,
                Messages =
                {
                    new ChatRequestSystemMessage("You are a helpful assistant that summarizes text."),
                    new ChatRequestUserMessage(prompt),
                },
                MaxTokens = 200, // Adjust as needed
                Temperature = 0.7f, // Adjust for creativity vs. determinism
                // Use Functions for more structured interactions if needed
            };

            Response<ChatCompletions> response = await _client.GetChatCompletionsAsync(chatCompletionsOptions);

            if (response.Value.Choices.Count > 0)
            {
                return response.Value.Choices[0].Message.Content.Trim();
            }
            else
            {
                return "No summary could be generated.";
            }
        }
        catch (RequestFailedException ex)
        {
            // Log the detailed error
            Console.Error.WriteLine($"Error calling Azure OpenAI: {ex.Message}");
            Console.Error.WriteLine($"Status Code: {ex.Status}");
            Console.Error.WriteLine($"Error Code: {ex.ErrorCode}");
            Console.Error.WriteLine($"Error Details: {ex.ToString()}");
            return $"An error occurred during summarization. Please contact support. Error Code: {ex.ErrorCode}";
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"An unexpected error occurred: {ex.Message}");
            return "An unexpected error occurred during summarization.";
        }
    }
}

This service can then be registered in your DI container and injected into your controllers or other services.

Integrating Claude Code with MCP in Java

Similar to .NET, Java developers use the Azure SDKs to interact with Azure AI services. The azure-ai-openai Maven package is your primary tool for connecting to Claude Code models deployed via Azure OpenAI.

Architectural Consideration: In Java applications, especially those built with Spring Boot, a common pattern is to create a @Service component that encapsulates AI interaction logic. This promotes modularity and testability.

Example Scenario: A Java application needs to generate product descriptions based on a few keywords.

Prerequisites:

1. Azure OpenAI Resource: A deployed Azure OpenAI resource with a Claude Code model deployment.
2. API Key and Endpoint: Obtained from your Azure portal.
3. Maven Dependency: Add azure-ai-openai to your pom.xml.

pom.xml Dependency:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-openai</artifactId>
    <version>1.0.0</version> <!-- Use the latest stable version -->
</dependency>

application.properties (Spring Boot) Configuration:

azure.openai.endpoint=YOUR_AZURE_OPENAI_ENDPOINT
azure.openai.deploymentName=claude-code-model-deployment # Your specific deployment name
azure.openai.apiKey=YOUR_AZURE_OPENAI_API_KEY

Java Service Implementation (Spring Boot):

import com.azure.ai.openai.OpenAIClient;
import com.azure.ai.openai.OpenAIClientBuilder;
import com.azure.ai.openai.models.ChatCompletions;
import com.azure.ai.openai.models.ChatCompletionsOptions;
import com.azure.ai.openai.models.ChatRequestSystemMessage;
import com.azure.ai.openai.models.ChatRequestUserMessage;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.exception.ResourceNotFoundException;
import com.azure.core.exception.ServiceErrorException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.List;

@Service
public class ProductDescriptionGenerator {

    private static final Logger logger = LoggerFactory.getLogger(ProductDescriptionGenerator.class);

    private final OpenAIClient client;
    private final String deploymentName;

    public ProductDescriptionGenerator(
            @Value("${azure.openai.endpoint}") String endpoint,
            @Value("${azure.openai.deploymentName}") String deploymentName,
            @Value("${azure.openai.apiKey}") String apiKey) {

        if (endpoint == null || deploymentName == null || apiKey == null) {
            throw new IllegalArgumentException("Azure OpenAI configuration is missing. " +
                    "Please ensure azure.openai.endpoint, azure.openai.deploymentName, and azure.openai.apiKey are set.");
        }

        this.deploymentName = deploymentName;
        this.client = new OpenAIClientBuilder()
                .endpoint(endpoint)
                .credential(new AzureKeyCredential(apiKey))
                .buildClient();
    }

    public String generateDescription(List<String> keywords) {
        if (keywords == null || keywords.isEmpty()) {
            return "No keywords provided to generate a description.";
        }

        String keywordString = String.join(", ", keywords);
        String prompt = String.format("Generate a compelling product description for a product that includes the following keywords: %s. Focus on benefits and unique selling points.", keywordString);

        try {
            ChatCompletionsOptions options = new ChatCompletionsOptions()
                    .setMessages(Arrays.asList(
                            new ChatRequestSystemMessage("You are a creative copywriter specializing in product descriptions."),
                            new ChatRequestUserMessage(prompt)
                    ))
                    .setDeploymentName(deploymentName)
                    .setMaxTokens(300) // Adjust as needed
                    .setTemperature(0.8f); // Higher temperature for more creative output

            ChatCompletions completions = client.getChatCompletions(options);

            if (completions.getChoices() != null && !completions.getChoices().isEmpty()) {
                return completions.getChoices().get(0).getMessage().getContent().trim();
            } else {
                return "Could not generate a product description.";
            }
        } catch (ServiceErrorException e) {
            logger.logServiceError(e);
            return "An error occurred while generating the product description. Please check logs.";
        } catch (ResourceNotFoundException e) {
            logger.error("Azure OpenAI deployment not found: {}", deploymentName, e);
            return "The AI model deployment is not available.";
        } catch (Exception e) {
            logger.error("An unexpected error occurred during description generation.", e);
            return "An unexpected error occurred.";
        }
    }

    // Helper to log Azure specific errors
    private void logServiceError(ServiceErrorException e) {
        logger.error("Azure Service Error: Status={}, ErrorCode={}, ErrorMessage='{}'",
                e.getResponse() != null ? e.getResponse().getStatusCode() : "N/A",
                e.getValue() != null ? e.getValue().getCode() : "N/A",
                e.getValue() != null ? e.getValue().getMessage() : "N/A",
                e);
    }
}

This Java service can be injected into your Spring Boot controllers to handle API requests.

Architectural Patterns for Enterprise AI Integration

Beyond basic integration, consider these patterns:

1. AI Gateway/Orchestrator: A dedicated service that acts as a single point of entry for all AI requests. It can handle authentication, authorization, request routing, rate limiting, and model selection. This decouples your core business logic from the specifics of AI service interaction.
2. Prompt Engineering Layer: Centralize prompt creation and management. This could be a service or a configuration system that stores and retrieves standardized prompts, making it easier to update prompts across the application and ensure consistency.
3. Agentic Workflows: For more complex tasks, consider building agents. An agent can use LLMs to reason, plan, and execute a series of tools (APIs, databases, other AI models). Azure AI offers capabilities for building such agents. MCP SDKs can be used to connect these agents to Azure services and external tools.
4. Data Privacy and Security: When using enterprise data with AI models, ensure compliance. Implement robust access controls, data masking, and consider fine-tuning models on anonymized data or using Azure Private Link for secure network access.

Common Pitfalls and How to Avoid Them

Anti-patterns

• Direct API Calls from UI/Client: Developers sometimes embed API keys and make direct calls to Azure OpenAI from front-end applications or less secure backend services.
  • Why it’s wrong: Exposes credentials, lacks central control, makes updates difficult, and bypasses security/governance.
  • Solution: Always use a dedicated backend service or API Gateway to proxy AI requests. Store credentials securely in Azure Key Vault.
• Monolithic AI Service: A single, large service that handles all AI tasks (summarization, generation, classification) for the entire application.
  • Why it’s wrong: Becomes a bottleneck, difficult to scale specific AI functionalities, and makes code maintenance challenging.
  • Solution: Decompose AI functionalities into smaller, focused services (e.g., SummarizationService, DescriptionGeneratorService).

Other Pitfalls

• Ignoring Model Latency and Throughput: Assuming AI models respond instantly and can handle high volumes without tuning.
  • Avoidance: Design for asynchronous operations. Implement retry mechanisms with exponential backoff. Monitor API usage and set appropriate MaxTokens to control response size and cost. Consider caching frequent or identical requests.
• Over-reliance on Default Prompts: Using generic prompts without tailored context or specific instructions for Claude Code.
  • Avoidance: Invest time in prompt engineering. Experiment with different phrasing, few-shot examples, and system messages to guide the model effectively. Version your prompts.
• Insufficient Error Handling and Logging: Treating AI API calls as infallible.
  • Avoidance: Implement comprehensive try-catch blocks for API interactions. Log detailed error messages, including request/response payloads (where appropriate and secure), error codes, and timestamps. This is crucial for debugging and performance tuning.

Conclusion

Azure AI Foundry and MCP SDKs provide a powerful, integrated platform for bringing advanced AI capabilities, including Claude Code, into your enterprise workflows. By adopting sound architectural patterns, focusing on security and governance, and being mindful of common pitfalls, you can effectively leverage AI to build more intelligent, efficient, and innovative applications. Remember that continuous experimentation with prompts and model configurations is key to unlocking the full potential of these technologies.