Building Custom MCP Servers with C# and Semantic Kernel: Developer Guide

Expert guide to building enterprise MCP servers with C# SDK and Semantic Kernel. Real developer implementation with security, monitoring, and business intelligence ROI plus code examples.

Alex’s Development Challenge

Alex Rodriguez, Innanis’s Lead Developer, sits in his cluttered Seattle office surrounded by three monitors displaying code, documentation, and error logs. It’s been two weeks since Jennifer Walsh’s marketing intelligence system went live, and the requests haven’t stopped coming.

“Alex, can you connect our customer success platform to MCP?” asks Sarah Chen during their morning standup. “I need to understand how account health correlates with support ticket sentiment.”

“What about our competitive intelligence database?” adds Jennifer. “The standard MCP servers can’t access our proprietary research platform.”

Michael Park, Innanis’s IT Director, chimes in from his laptop: “We also need integration with our custom analytics engine. The business team wants AI that understands our unique KPI calculations.”

Alex takes a long sip of his coffee and grins. “This is exactly why Microsoft partnered with Anthropic for the C# SDK. We can build custom MCP servers for any system we need to integrate.”

The truth is, Alex has been waiting for this moment. While community MCP servers handle standard Microsoft 365 services well, Innanis’s competitive advantage comes from their proprietary systems—databases built over years, analytics engines tuned to their industry, and customer success workflows designed around their unique business model.

Standard MCP servers can’t expose this intellectual property. But custom MCP server development can.

Understanding Custom MCP Server Architecture

Before diving into code, Alex explains the architecture to his development team during their Thursday technical session.

“Think of MCP servers as intelligent APIs designed specifically for AI consumption,” Alex begins, sketching on the whiteboard. “Traditional REST APIs return raw data. MCP servers return contextual information that helps AI models understand not just what the data is, but what it means for business decisions.”

The Three-Layer MCP Server Structure

Transport Layer: Handles communication between AI clients and your server using protocols like HTTP streaming, Server-Sent Events, or standard input/output.

Protocol Layer: Manages MCP message formatting, tool discovery, authentication, and error handling using Microsoft’s C# SDK.

Business Logic Layer: Contains your proprietary algorithms, data access methods, and domain-specific intelligence that creates competitive advantage.

Alex’s insight resonates with his team: “We’re not just exposing database tables. We’re packaging years of business intelligence into interfaces that AI can understand and leverage.”

Why Semantic Kernel Integration Matters

Microsoft’s Semantic Kernel framework provides enterprise-grade capabilities that Alex’s team needs for production MCP servers:

Content Safety: Every tool call gets validated before execution using SK Filters, ensuring AI agents can’t perform unauthorized actions.

Observability: Tool call logs, traces, and metrics integrate with Innanis’s existing monitoring infrastructure.

Interoperability: Existing SK plugins can be exposed as MCP tools, protecting previous development investments.

“The beautiful part,” Alex explains, “is that Semantic Kernel handles the enterprise concerns while we focus on business logic.”

Building Innanis’s First Custom MCP Server

Alex decides to start with Innanis’s customer success platform—a system that tracks customer health scores, support interactions, and expansion opportunities using proprietary algorithms developed over three years.

Project Setup and Dependencies

Alex creates a new .NET 8 console application and adds the required packages:

dotnet new console -n InnanisCustomerSuccessMCP
cd InnanisCustomerSuccessMCP
dotnet add package Microsoft.Extensions.Hosting
dotnet add package ModelContextProtocol --prerelease
dotnet add package Microsoft.SemanticKernel

The project structure reflects enterprise development practices:

InnanisCustomerSuccessMCP/
├── Program.cs
├── Services/
│   ├── CustomerSuccessService.cs
│   └── HealthScoreCalculator.cs
├── Models/
│   ├── CustomerHealth.cs
│   └── SuccessMetrics.cs
├── MCP/
│   ├── CustomerSuccessTools.cs
│   └── MCPServerHost.cs
└── Configuration/
    └── AppSettings.json

Implementing Business Logic

Alex starts by implementing Innanis’s proprietary customer health scoring algorithm:

public class CustomerSuccessService
{
    public async Task<CustomerHealth> GetCustomerHealthAsync(string customerId)
    {
        // Innanis's proprietary algorithm combining:
        // - Support ticket sentiment analysis
        // - Product usage patterns
        // - Communication frequency and tone
        // - Payment behavior and contract compliance
        // - Competitive risk indicators
        
        var healthScore = await CalculateHealthScoreAsync(customerId);
        var riskFactors = await IdentifyRiskFactorsAsync(customerId);
        var expansionPotential = await AssessExpansionOpportunityAsync(customerId);
        
        return new CustomerHealth
        {
            CustomerId = customerId,
            OverallScore = healthScore,
            RiskLevel = DetermineRiskLevel(healthScore, riskFactors),
            ExpansionPotential = expansionPotential,
            RecommendedActions = GenerateActionRecommendations(healthScore, riskFactors),
            LastUpdated = DateTime.UtcNow
        };
    }
}

This isn’t just data retrieval—it’s business intelligence that took Innanis years to develop and tune.

Creating MCP Tools with Semantic Kernel

Alex exposes this business logic through MCP tools using Semantic Kernel integration:

public class CustomerSuccessTools
{
    private readonly CustomerSuccessService _customerService;
    
    [KernelFunction]
    [Description("Analyzes comprehensive customer health including proprietary risk scoring, expansion potential, and recommended actions")]
    public async Task<string> AnalyzeCustomerHealth(
        [Description("Customer identifier or company name")] string customerId)
    {
        var health = await _customerService.GetCustomerHealthAsync(customerId);
        
        return $"Customer Health Analysis for {health.CustomerName}:\n" +
               $"Overall Health Score: {health.OverallScore}/100\n" +
               $"Risk Level: {health.RiskLevel}\n" +
               $"Expansion Potential: {health.ExpansionPotential}\n" +
               $"Key Risk Factors: {string.Join(", ", health.RiskFactors)}\n" +
               $"Recommended Actions: {string.Join("; ", health.RecommendedActions)}\n" +
               $"Analysis Date: {health.LastUpdated:yyyy-MM-dd HH:mm}";
    }
    
    [KernelFunction]
    [Description("Identifies customers at risk of churn based on Innanis's proprietary algorithms")]
    public async Task<string> IdentifyChurnRisks(
        [Description("Optional: specific account segment or region")] string segment = null)
    {
        var riskCustomers = await _customerService.GetChurnRiskCustomersAsync(segment);
        
        var analysis = "High-Risk Customer Analysis:\n";
        foreach (var customer in riskCustomers.Take(10))
        {
            analysis += $"• {customer.Name}: {customer.RiskScore}% churn probability - {customer.PrimaryRiskFactor}\n";
        }
        
        return analysis + $"\nTotal at-risk customers: {riskCustomers.Count()}";
    }
}

MCP Server Implementation

Alex implements the MCP server host using Microsoft’s C# SDK:

public class MCPServerHost
{
    private readonly CustomerSuccessTools _customerTools;
    private readonly IKernel _kernel;
    
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // Configure Semantic Kernel with customer success tools
        var builder = Kernel.CreateBuilder();
        builder.Plugins.AddFromObject(_customerTools, "CustomerSuccess");
        _kernel = builder.Build();
        
        // Initialize MCP server with HTTP streaming transport
        var server = new MCPServer(new HttpStreamingTransport());
        
        // Register tools from Semantic Kernel
        foreach (var function in _kernel.Plugins.GetFunctionsMetadata())
        {
            server.RegisterTool(function.Name, function.Description, 
                async (parameters) => await ExecuteKernelFunction(function, parameters));
        }
        
        await server.StartAsync(cancellationToken);
    }
}

Testing and Debugging Custom MCP Servers

Alex’s development process includes comprehensive testing strategies that ensure reliability in production environments.

Local Development Testing

“I always start with simple, direct testing before connecting to Copilot Studio,” Alex explains to his junior developer, Maria Santos.

// Simple console test for MCP tool functionality
var customerTools = new CustomerSuccessTools(customerService);
var result = await customerTools.AnalyzeCustomerHealth("pacific-manufacturing");
Console.WriteLine(result);

Integration Testing with Copilot Studio

Once basic functionality works, Alex tests integration with Copilot Studio by creating a dedicated test agent that connects to his local MCP server running on localhost:3000.

The test reveals issues that don’t surface during unit testing:

• Authentication timing: The MCP server needs to handle Copilot Studio’s authentication flow
• Response formatting: AI agents expect specific response structures for optimal understanding
• Error handling: Network interruptions require graceful degradation

Production Deployment Considerations

Alex deploys custom MCP servers using Azure Container Apps, which provides:

• Automatic scaling based on MCP client demand
• Security boundaries that integrate with Innanis’s Virtual Network
• Monitoring integration with their existing Azure Monitor setup
• CI/CD pipeline compatibility with their GitHub Actions workflows

Real-World Custom Integration Examples

Customer Success Intelligence

Sarah tests Alex’s customer success MCP server with a complex question: “Which of our enterprise customers show expansion potential but also have emerging risk factors?”

The response demonstrates the power of custom business logic:

“Enterprise Expansion Analysis with Risk Assessment:

High Potential, Low Risk:

• Global Logistics Solutions: 89% expansion probability, usage increased 34% this quarter, strong technical team engagement
• Metro Health Systems: 76% expansion probability, budget approved for Q1, positive sentiment in recent communications

High Potential, Moderate Risk:

• Pacific Manufacturing: 82% expansion probability BUT 23% churn risk due to implementation delays and support ticket sentiment decline

Recommended Action: Prioritize Pacific Manufacturing for executive engagement to address concerns while pursuing expansion discussion with Global Logistics.”

This intelligence combines usage analytics, communication sentiment, support ticket analysis, and financial data in ways impossible through standard integrations.

Competitive Intelligence Integration

Jennifer’s marketing needs expand beyond standard analytics. Alex builds a competitive intelligence MCP server that analyzes:

• Market positioning data from their proprietary research database
• Competitor pricing intelligence gathered through various channels
• Win/loss analysis correlated with competitive factors
• Industry trend analysis from their custom analytics platform

When Jennifer asks, “How should we position against Competitor X in the healthcare vertical?” the MCP server provides insights like:

“Healthcare Competitive Positioning vs Competitor X:

Our Advantages: 67% faster implementation (avg 4.2 weeks vs 7.1 weeks), 34% higher customer satisfaction scores, stronger compliance capabilities

Their Advantages: 15% lower entry-level pricing, more established partner network in Southeast region

Win Rate: 73% when competing directly (based on 23 deals this year)

Recommended Messaging: Emphasize speed-to-value and compliance expertise. Consider matching their pricing on deals below $500K to improve win rate in price-sensitive segments.”

Security and Governance for Custom MCP Servers

Michael Park works closely with Alex to ensure custom MCP servers meet Innanis’s enterprise security requirements.

Authentication and Authorization

Custom MCP servers integrate with Azure Active Directory, ensuring they respect existing user permissions:

public class SecureMCPServer
{
    public async Task<bool> ValidateUserAccessAsync(string userId, string requestedResource)
    {
        // Check Azure AD permissions
        var userPrincipal = await _graphClient.Users[userId].GetAsync();
        var hasAccess = await _authService.CheckResourceAccessAsync(userPrincipal, requestedResource);
        
        // Additional business logic validation
        var businessRules = await _businessRuleEngine.ValidateAccessAsync(userId, requestedResource);
        
        return hasAccess && businessRules.IsValid;
    }
}

Data Privacy and Compliance

Custom servers implement data privacy controls that align with Innanis’s compliance requirements:

• Data masking for sensitive customer information based on user roles
• Audit logging for all MCP interactions and data access
• Retention policies that automatically expire cached data
• Cross-border data restrictions for international compliance

Performance and Monitoring

Alex implements comprehensive monitoring using Application Insights:

public class MonitoredMCPTool
{
    private readonly ILogger _logger;
    private readonly TelemetryClient _telemetryClient;
    
    [KernelFunction]
    public async Task<string> ExecuteBusinessLogic(string parameters)
    {
        using var operation = _telemetryClient.StartOperation<RequestTelemetry>("MCP-CustomerAnalysis");
        
        try
        {
            var result = await ProcessBusinessLogicAsync(parameters);
            _telemetryClient.TrackEvent("MCP-Success", new Dictionary<string, string>
            {
                ["Tool"] = "CustomerAnalysis",
                ["ExecutionTime"] = operation.Telemetry.Duration.ToString()
            });
            return result;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "MCP tool execution failed");
            _telemetryClient.TrackException(ex);
            throw;
        }
    }
}

ROI and Business Impact

Six weeks after deploying custom MCP servers, Innanis measures significant business impact:

Development Efficiency

• Custom integration time: Reduced from 6-8 weeks to 2-3 weeks per system
• Maintenance overhead: 60% reduction in API maintenance due to standardized MCP interfaces
• Code reusability: Existing Semantic Kernel plugins converted to MCP tools with minimal effort

Business Intelligence Quality

• Decision speed: Executive decisions based on AI insights happen 40% faster
• Insight accuracy: Custom business logic provides 3x more relevant intelligence than generic integrations
• Competitive advantage: Proprietary algorithms remain protected while being AI-accessible

User Adoption and Satisfaction

• Sales team productivity: 45% improvement in account analysis quality
• Marketing ROI: 28% improvement in campaign optimization through custom competitive intelligence
• Customer success: 67% faster identification of at-risk accounts

What’s Next: Microsoft 365 Services Integration

Alex’s success with custom MCP servers positions Innanis to tackle their next challenge: comprehensive Microsoft 365 services integration.

“The custom servers proved we can expose any business logic through MCP,” Alex explains during the monthly architecture review. “Now we need to connect the entire Microsoft 365 ecosystem—SharePoint intelligence, Teams collaboration analysis, Outlook relationship tracking—into one unified AI experience.”

Next week, we’ll follow customer support manager Tom Wilson as he implements Microsoft 365 services integration scenarios. We’ll see how Innanis combines custom MCP servers with community-built solutions to create AI agents that understand every aspect of their business communication and collaboration.

Tom’s challenge involves connecting customer support workflows across Teams channels, SharePoint knowledge bases, Outlook communications, and their custom ticketing system—all while maintaining the security and governance standards Michael Park requires.

Ready to Build Your Custom MCP Servers?

Don’t let your organization’s competitive advantages remain locked in proprietary systems. Start building custom MCP servers that expose your unique business intelligence:

1. Identify your proprietary systems that provide competitive advantage
2. Install the Microsoft C# SDK and set up a development environment
3. Start simple with one business function using Semantic Kernel integration
4. Test thoroughly with local development before Copilot Studio integration
5. Deploy securely using Azure Container Apps with proper monitoring

Remember Alex’s transformation: Innanis’s three years of customer success algorithm development became AI-accessible in two weeks of MCP server development. That’s not just technical achievement—that’s competitive intelligence amplification.

The organizations that expose their proprietary intelligence through AI-accessible interfaces will dominate their markets. Custom MCP server development makes that transformation possible today.

References and Additional Resources

Official Microsoft Documentation

• Microsoft partners with Anthropic to create official C# SDK for Model Context Protocol
• Building a Model Context Protocol Server with Semantic Kernel
• Microsoft Semantic Kernel Documentation

MCP Development Resources

• Model Context Protocol Specification
• Microsoft MCP Lab Repository
• MCP C# SDK Examples

Deployment and Security

• Azure Container Apps Documentation
• Application Insights for .NET
• Azure Active Directory B2B Integration

Complete Blog Series

• Part 1: How the Model Context Protocol Elevates Microsoft 365 Efficiency for Businesses
• Part 2: Building AI Agents with Microsoft Copilot Studio and MCP: A Comprehensive Guide
• Part 3: How Power Platform Leverages MCP for Enhanced Integration of Dataverse, Power Apps, and Power Automate
• Part 4: Building Custom MCP Servers with C# and Semantic Kernel: Developer Guide
• Part 5: Microsoft 365 Services and MCP Integration: SharePoint, Teams, and Outlook Automation
• Part 6: Enterprise MCP Implementation Strategy: Governance, Security, and ROI Framework

The characters, company names, and places used in this blog post series are entirely fictitious and created for illustrative purposes. Any resemblance to actual persons, living or dead, real companies, or actual places is purely coincidental.

Last updated: July 2025. Check official Microsoft documentation for current MCP capabilities.