Module 7: Lessons from Early Adoption

import asyncio
from modelcontextprotocol import create_server, ServerConfig
from modelcontextprotocol.resources import ResourceDefinition
from modelcontextprotocol.prompts import PromptDefinition
from modelcontextprotocol.tool import ToolDefinition
from modelcontextprotocol.transports import create_http_transport

async def main():
    config = ServerConfig(
        name="Enterprise Customer Support Server",
        version="1.0.0",
        description="MCP server for handling customer support inquiries"
    )
    server = create_server(config)

    # Register knowledge base as a resource
    server.resources.register(
        ResourceDefinition(name="customer_kb",
                           description="Customer knowledge base documentation"),
        lambda params: get_customer_documentation(params)
    )

    # Register response templates as prompts
    server.prompts.register(
        PromptDefinition(name="support_template",
                         description="Templates for customer support responses"),
        lambda params: get_support_templates(params)
    )

    # Register ticketing as a tool
    server.tools.register(
        ToolDefinition(name="ticketing",
                       description="Create and update support tickets"),
        handle_ticketing_operations
    )

    transport = create_http_transport(port=8080)
    await server.run(transport)

asyncio.run(main())

// C# MCP client in a healthcare application
public class DiagnosticAssistant
{
    private readonly MCPHostClient _mcpClient;

    public DiagnosticAssistant(PatientContext patientContext)
    {
        var clientOptions = new ClientOptions
        {
            Name = "Healthcare Diagnostic Assistant",
            Version = "1.0.0",
            Security = new SecurityOptions
            {
                Encryption = EncryptionLevel.Medical,
                AuditEnabled = true
            }
        };

        _mcpClient = new MCPHostClientBuilder()
            .WithOptions(clientOptions)
            .WithTransport(new HttpTransport("https://healthcare-mcp.example.org"))
            .WithAuthentication(new HIPAACompliantAuthProvider())
            .Build();
    }

    public async Task<DiagnosticSuggestion> GetDiagnosticAssistance(
        string symptoms, string patientHistory)
    {
        var response = await _mcpClient.SendPromptRequestAsync(
            promptName: "diagnostic_assistance",
            parameters: new Dictionary<string, object>
            {
                ["symptoms"] = symptoms,
                ["patientHistory"] = patientHistory
            });
        return DiagnosticSuggestion.FromMCPResponse(response);
    }
}

// Java MCP server for financial risk assessment
public class FinancialRiskMCPServer {
    public static void main(String[] args) {
        MCPServer server = new MCPServerBuilder()
            .withModelProviders(
                new ModelProvider("risk-assessment-primary",
                    new AzureOpenAIProvider()),
                new ModelProvider("risk-assessment-audit",
                    new LocalLlamaProvider())
            )
            .withPromptTemplateDirectory("./compliance/templates")
            .withAccessControls(new SOCCompliantAccessControl())
            .withDataEncryption(EncryptionStandard.FINANCIAL_GRADE)
            .withAuditLogging(new DatabaseAuditLogger())
            .build();

        server.addRequestValidator(new FinancialDataValidator());
        server.addResponseFilter(new PII_RedactionFilter());
        server.start(9000);
    }
}

// TypeScript: registering Playwright browser automation tools
import { createServer, ToolDefinition } from 'modelcontextprotocol';
import { launch } from 'playwright';

const server = createServer({
  name: 'Playwright MCP Server',
  version: '1.0.0',
  description: 'MCP server for browser automation using Playwright'
});

server.tools.register(
  new ToolDefinition({
    name: 'navigate_and_screenshot',
    description: 'Navigate to a URL and capture a screenshot',
    parameters: { url: { type: 'string', description: 'The URL to visit' } }
  }),
  async ({ url }) => {
    const browser = await launch();
    const page = await browser.newPage();
    await page.goto(url);
    const screenshot = await page.screenshot();
    await browser.close();
    return { screenshot };
  }
);

server.listen(8080);

# Azure MCP server deployment configuration
apiVersion: mcp.microsoft.com/v1
kind: McpServer
metadata:
  name: enterprise-mcp-server
spec:
  modelProviders:
    - name: azure-openai
      type: AzureOpenAI
      endpoint: https://<your-openai-resource>.openai.azure.com/
      apiKeySecret: <your-azure-keyvault-secret>
  tools:
    - name: document_search
      type: AzureAISearch
      endpoint: https://<your-search-resource>.search.windows.net/
      apiKeySecret: <your-azure-keyvault-secret>
  authentication:
    type: EntraID
    tenantId: <your-tenant-id>
  monitoring:
    enabled: true
    logAnalyticsWorkspace: <your-log-analytics-id>