Qu'est-ce que MCP ?

MCP est comme un port USB-C pour les applications AI

Un protocole ouvert qui standardise la connexion entre les modèles AI et les sources de données/outils

Le Problème Avant MCP

//  Approche traditionnelle : APIs spécifiques
var chatGPT = new OpenAIClient();
var claude = new AnthropicClient(); 
var gemini = new GoogleClient();
// Chaque intégration unique !

La Solution MCP

//  Avec MCP : Interface standardisée
var mcpClient = new McpClient();
mcpClient.ConnectToServer("file-system");
mcpClient.ConnectToServer("database-server");
// Un protocole, multiple serveurs !

Avantages pour l'IA Agentic

• Autonomie : L'IA peut découvrir et utiliser des outils
• Flexibilité : Changement de provider sans recodage
• Sécurité : Données restent dans votre infrastructure

Architecture MCP

┌───────────────────────────────┐          ┌─────────────────┐
│        MCP HOST               │          │   MCP SERVER    │
│  ┌─────────────────────────┐  │          │                 │
│  │ Claude Desktop          │  │◄───────► │ NuGet Server    │
│  │ VS Code                 │  │ JSON-RPC │ Database API    │
│  │ Custom Apps             │  │ over     │ File System     │
│  │                         │  │ Transport│ Weather API     │
│  │  ┌─────────────────┐    │  │          │ Git Server      │
│  │  │   MCP CLIENT    │    │  │          └─────────────────┘
│  │  │ (embedded)      │    │  │                  │
│  │  │ • Protocol      │    │  │                  ▼
│  │  │ • Connections   │    │  │         ┌─────────────────┐
│  │  │ • 1:1 per server│    │  │         │ LOCAL/REMOTE    │
│  │  └─────────────────┘    │  │         │ DATA SOURCES    │
│  └─────────────────────────┘  │         │                 │
└───────────────────────────────┘         │ • Databases     │
                                          │ • APIs          │
                                          │ • Files         │
                                          └─────────────────┘

Architecture MCP

• MCP Host : Application consommatrice avec client MCP intégré. Celle qui comprends le protocole JSON-RPC.
• MCP Client : Intégré dans le Host, gère les connexions 1:1
• MCP Server : Programme léger exposant des capacités via MCP

Concepts MCP vs HTTP

Resources = GET

Récupérer des données/contenus

// HTTP GET
GET /api/docs?status=available

// MCP Resource
[McpServerResource]
public static async Task<ApiDocInfo[]> ListApiDocumentations()
{
    return await _documentationService.GetAvailableDocsAsync();
}

Tools = POST

Exécuter des actions

// HTTP POST
POST /api/docs/generate { "projectPath": "/src/MyProject" }

// MCP Tool
[McpServerTool, Description("Generate API documentation")]
public static async Task<DocumentationResult> GenerateApiDocs(string projectPath)
{
    return await _documentationService.GenerateAsync(projectPath);
}

Prompts = Templates

Workflows pré-définis
Le guide pour l'IA.

// Template de requête réutilisable
[McpServerPrompt, Description("Generate API documentation")]
public static PromptMessage GenerateApiDocs(string projectPath)
{
    return new PromptMessage($"""
        Analyze the project at {projectPath} and generate API documentation.
        Focus on public endpoints and data models.
        """);
}

Standard Input/Output (Stdio)

• Usage : Créer des outils CLI, Exécuter des scripts shell
• Usage : Interagir avec des applications locales
• Usage : Besoin simple de communication entre processus
   
• Avantages : Sécurité implicite (pas de port réseau), Pas de dépendance réseau
• Avantages : Performance élevée (pas de latence réseau)
   
• Inconvénients : Limité à des échanges locaux, Fragile

Server-Sent Events (SSE)

Déprécié depuis la version 2024-11-05, remplacé par Streamable HTTP

Streamable HTTP

• Usage : Besoin de supporter plusieurs clients simultanés
• Usage : Besoin d'un communication HTTP
   
• Avantages : Standard web compatible HTTP/2 & HTTP/3
• Avantages : Scalabilité et load balancing possibles
• Avantages : Reprise automatique en cas de perte de flux
   
• Inconvénients : Plus lourd que STDIO
• Inconvénients : Nécessite un serveur HTTP compatible

Use Cases Principaux

1. Installation du Package MCP

# Installation du template MCP
dotnet new install ModelContextProtocol.AspNetCore

Packages NuGet inclus

• ModelContextProtocol : Core MCP functionality

Configuration du Startup

var builder = WebApplication.CreateBuilder(args);

builder.WithMcpServer(args)
    .WithStdioServerTransport() // Pour le mode Stdio
    .WithSseServerTransport()   // Pour le mode SSE
    .WithTools<MyTool>()          // Charger des Tools spécifiques
    .WithResources<MyResource>()  // Charger des Resources spécifiques
    .WithPrompts<MyPrompt>();      // Charger des Prompts spécifiques

var app = builder.Build();

// Mapping des endpoints MCP selon le transport
app.MapMcpServer(args);
app.Run();

Chargement automatique

builder.WithMcpServer(args)
    .WithToolsFromAssembly()      // Scan automatique des Tools `[McpServerTool]`
    .WithResourcesFromAssembly()  // Scan automatique des Resources `[McpServerResource]`
    .WithPromptsFromAssembly();   // Scan automatique des Prompts `[McpServerPrompt]`

var app = builder.Build();

Exemple de Tool (Action)

Créer un nouveau contrat d'assurance

[McpServerToolType]
public static class AssuranceTool
{
    [McpServerTool, Description("Create new insurance contract")]
    public static async Task<ContratResult> CreateContract(
        string customerId, string productType, decimal coverageAmount, DateTime startDate)
    {
        // Validation des données
        // Code simplifié pour l'exemple
        ContratResult result = await _contractUseCase.CreateAsync(contract);

        return result;
    }
}

Exemple de Resource (Lecture)

Lister les contrats d'assurance

[McpServerResourceType]
public static class AssuranceResource
{
    [McpServerResource, Description("List insurance contracts")]
    public static async Task<Contrat[]> ListContractsInsurance(
        string customerId, string status, DateTime startDate)
    {
        // Logique contrat : appel au use case qui va chercher les contrats
        return await _getContractsUseCase.ExecuteAsync(customerId, status, startDate);
    }
}

Exemple de Prompt (Template)

Template d'Analyse de Risque

[McpServerPromptType]
public static class AssurancePrompt
{
    [McpServerPrompt, Description("Analyze insurance risk profile")]
    public static PromptMessage AnalyzeRiskProfile(
        string customerId, string productType)
    {
        return new PromptMessage($"""
            Please analyze the insurance risk profile for:
            - Customer ID: {customerId}
            - Product Type: {productType}
            
            Focus on:
            1. **Historical Claims**: Review past claims frequency and severity
            2. **Customer Profile**: Age, location, occupation, lifestyle factors
            3. **Product Specifics**: Coverage type, limits, deductibles
            4. **Market Trends**: Current market conditions and regulatory changes
            5. **Risk Factors**: Identify high-risk elements and mitigation strategies
            
            For each risk factor, provide:
            - Risk level (Low/Medium/High)
            - Impact assessment
            - Recommended premium adjustment
            - Preventive measures suggestions
            - Underwriting recommendations
            
            Format your response as a comprehensive risk assessment report 
            with actionable insights for underwriters and pricing teams.
            
            Include specific recommendations for:
            - Premium pricing strategy
            - Policy terms and conditions
            - Risk mitigation requirements
            - Monitoring and review schedule
            """);
    }
}

Avantages pour les Développeurs

Avantages pour les Développeurs

Clean Architecture / Hexagonale

• Adapters parfaits : MCP servers = ports d'entrée pour l'IA
• Inversion de dépendance : Use cases indépendants du transport MCP
• Séparation des responsabilités : Logique métier isolée des détails MCP
• Testabilité : Mock des MCP servers facilement

Test avec MCP Inspector

npx @modelcontextprotocol/inspector

Ressources

• Documentation : modelcontextprotocol.io

Questions ?