# LLMApi: Exemples d'architecture modulaire

<!--category-- AI, LLM,  LLMApi, ASP.NET Core, API, Nuget, mockllmapi, AI-Article-->
<datetime class="hidden">2025-11-02T12:30</datetime>

# Introduction

L’une des choses clés que j’ai voulues avec LLMApi était la capacité pour qu’il soit aussi léger que possible (pour simuler simplement le type api que vous voulez ) ET être super facile à obtenir intp; de sorte que vous pourriez être en mesure d’obtenir EVERYTHING just as easilyM SK3 En gardant cela à l’esprit, je l’ai conçue avec modularité à l'esprit (whispersMSC5à l’avenir, je veux que vous puissiez ajouter Plugins+' qui permettront encore plus d’être possiblesMSSK8C’est iciMK9l’article sur la façon dont fonctionne cette architecture et tout ce qui s’y rapporte

Vous pouvez trouver le[ GitHub ici ](https://github.com/scottgal/LLMApi)pour le projet, tous les domaines publics, etc.

> NOTE: Il s'agit du live de gitHub. Il est généré par l'AIM SK2

[![NuGet](https://img.shields.io/nuget/v/mostlylucid.mockllmapi.svg)](https://www.nuget.org/packages/mostlylucid.mockllmapi)
[![NuGet](https://img.shields.io/nuget/dt/mostlylucid.mockllmapi.svg)](https://www.nuget.org/packages/mostlylucid.mockllmapi)

Vous pouvez trouver le[ GitHub ici ](https://github.com/scottgal/LLMApi)pour le projet, tous les domaines publics, etc.

# Exemples d'architecture modulaire

**Nouveaux dans v1.2.0+:** Modularité complète! Chacune des protocoles (RESTM SK2 Streaming , GraphQLMSC4 SignalRMska5 gRPCMske6 OpenAPIM Ska7 peut maintenant être ajouté et mapped indépendammentMSKA8 Plus de chargements dynamiques d'échantillonnage de spécificationsMsko9 gestion du contexteMisko10 et plus encoreMsco11

## Table des matières

- [Compatible à l'arrière (Approche unifiée)](#backward-compatible-unified-approach)
- [Approche modulaire](#modular-approach)
  - [REST seulement](#rest-only)
  - [GraphQL seulement](#graphql-only)
  - [S'acheminant seulement](#streaming-only)
  - [SignalR seulement](#signalr-only)
  - [gRPC seulement](#grpc-only)
  - [OpenAPI seulement](#openapi-only)
  - [Context Management API](#context-management-api)
  - [Mélanger et correspondre](#mix-and-match)
- [Instances multiples](#multiple-instances)
- [Avantages de l'approche modulaire](#benefits-of-modular-approach)
- [Guide des migrations](#migration-guide)
- [Résumé](#summary)

---


## Compatible à l'arrière (Approche unifiée)

**Le code existant continue de fonctionner sans changements:**

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Registers ALL services (REST, Streaming, GraphQL)
builder.Services.AddLLMockApi(builder.Configuration);

// Optional: Add SignalR
builder.Services.AddLLMockSignalR(builder.Configuration);

builder.Services.AddRazorPages();

var app = builder.Build();

app.UseStaticFiles();
app.UseRouting();
app.MapRazorPages();

// Maps ALL endpoints (REST, Streaming, GraphQL) at /api/mock
app.MapLLMockApi("/api/mock", includeStreaming: true, includeGraphQL: true);

// Optional: Map SignalR
app.MapLLMockSignalR("/hub/mock", "/api/mock");

app.Run();
```

**Cela crée:**

- `/api/mock/**` Points finals de REST -
- `/api/mock/stream/**` - Points finals d'écoulement de l'SSE
- `/api/mock/graphql` - GraphQL point final
- `/hub/mock` - Noyau de SignalR  s’il est ajoutéM SK2
- `/api/mock/contexts` - API de gestion de SignalR  s'il est ajoutéM SK2

---


## Approche modulaire

### REST seulement

Perfect pour le montage simple de l'API REST sans frais supplémentaires:

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register ONLY REST services
builder.Services.AddLLMockRest(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map ONLY REST endpoints
app.MapLLMockRest("/api/mock");

app.Run();
```

**Cela crée:**

- `/api/mock/**` - Seulement les points de fin REST

**Avantages:**

- Imprint minimal de la mémoire
- Temps de démarrage plus rapide
- Ne comprend que RegularRequestHandler

---


### GraphQL seulement

Perfect pour GraphQL-pour les applications seulement:

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register ONLY GraphQL services
builder.Services.AddLLMockGraphQL(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map ONLY GraphQL endpoint
app.MapLLMockGraphQL("/api/mock");

app.Run();
```

**Cela crée:**

- `/api/mock/graphql` - GraphQL seulement point final

**Avantages:**

- Établissement propre GraphQL-seulement
- Aucune manipulatrice de REST inutile
- Perfect pour l'essai de GraphQL

---


### S'acheminant seulement

Perfect pour tester les clients de streaming SSE:

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register ONLY Streaming services
builder.Services.AddLLMockStreaming(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map ONLY Streaming endpoints
app.MapLLMockStreaming("/api/mock");

app.Run();
```

**Cela crée:**

- `/api/mock/stream/**` - Seulement les points finals d'écoulement de l'SSE

**Avantages:**

- Écoulement léger-système de configuration seulement
- Perfect pour les essais de EventSource
- Aucune REST/GraphQL surcoût

---


### SignalR seulement

Perfect pour la mise au point de prototypes de tableaux de bord réels.

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register ONLY SignalR services (includes core services automatically)
builder.Services.AddLLMockSignalR(options =>
{
    options.BaseUrl = "http://localhost:11434/v1/";
    options.ModelName = "llama3";
    options.SignalRPushIntervalMs = 5000;
});

var app = builder.Build();

app.UseRouting();

// Map ONLY SignalR endpoints
app.MapLLMockSignalR("/hub/mock", "/api/contexts");

app.Run();
```

**Cela crée:**

- `/hub/mock` - SignalR hub
- `/api/contexts` - API de gestion du contexte

**Avantages:**

- Établissement de temps réel-
- Il n'y a pas de point final HTTP en tête.
- Perfect pour les tests WebSocket

---


### gRPC seulement

Perfect pour tester les clients gRPC avec des définitions proto dynamiques:

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register services (gRPC included in AddLLMockApi)
builder.Services.AddLLMockApi(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map ONLY gRPC endpoints
app.MapLLMockGrpcManagement("/api/grpc-protos");  // Proto file management
app.MapLLMockGrpc("/api/grpc");                   // gRPC service calls

app.Run();
```

**Cela crée:**

- `/api/grpc-protos` - Soumettre à la disposition de l’utilisateur les fichiers protégés.
- `/api/grpc/{serviceName}/{methodName}` - Invoquer les méthodes gRPC de modèle

**Avantages:**

- Enregistrement dynamique de proto sans recompilation
- Perfect pour l'essai du client gRPC
- LLM génère des réponses protobuf réalistes

**Exemple d'utilisation:**

```bash
# 1. Upload a proto definition
curl -X POST http://localhost:5116/api/grpc-protos \
  -H "Content-Type: text/plain" \
  --data 'syntax = "proto3"; service UserService { rpc GetUser(GetUserRequest) returns (User); }'

# 2. Call the gRPC method
curl -X POST http://localhost:5116/api/grpc/UserService/GetUser \
  -H "Content-Type: application/json" \
  -d '{"user_id": 123}'
```

---


### OpenAPI seulement

Perfectieux pour reproduire les OpenAPI existants/Swagger specs:

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register ONLY OpenAPI services
builder.Services.AddLLMockOpenApi(options =>
{
    options.BaseUrl = "http://localhost:11434/v1/";
    options.ModelName = "llama3";
    options.OpenApiSpecs = new List<OpenApiSpecConfig>
    {
        new OpenApiSpecConfig
        {
            Name = "PetStore",
            Source = "https://petstore3.swagger.io/api/v3/openapi.json",
            BasePath = "/api/petstore"
        }
    };
});

var app = builder.Build();

app.UseRouting();

// Map ONLY OpenAPI endpoints
app.MapLLMockOpenApi();                      // Loads configured specs
app.MapLLMockOpenApiManagement("/api/specs"); // Dynamic spec management

app.Run();
```

**Cela crée:**

- Tous les points de fin définis dans votre spécification OpenAPI (eM SK1g., `/api/petstore/pet/{petId}`)
- `/api/specs` - Upload/manage les spécifications OpenAPI dynamiquement POSTM SK3 GETMSC4 DELETEMST5

**Avantages:**

- Modifier automatiquement l'ensemble des spécifications OpenAPI
- Aucune cartographie manuelle du point final n'est requise
- Supporte à la fois les spécifications statiques (configuredM SK1 et dynamiques (uploaded)
- Perfect pour l'essai des contrats d'API

---


### Context Management API

Ajouter la visualisation et la modification de l’histoire du contexte:

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register REST services
builder.Services.AddLLMockRest(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map REST endpoints
app.MapLLMockRest("/api/mock");

// Add context management API
app.MapLLMockApiContextManagement("/api/contexts");

app.Run();
```

**Cela crée:**

- `/api/mock/**` Points finals de REST -
- `/api/contexts/{contextId}` - Voir/ Modifier l'historique de la conversation

**Avantages:**

- Voir l'histoire de la conversation LLM pour le débugging
- Modifier le contexte pour diriger les réponses
- Débarrasser le contexte pour rétablir l'état
- Perfect pour tester des scénarios d'état

---


### Mélanger et correspondre

Combinez les protocoles nécessaires à votre cas d'utilisation:

#### Exemple 1: REST ≥+ GraphQL (No Streaming)

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register REST and GraphQL services
builder.Services.AddLLMockRest(builder.Configuration);
builder.Services.AddLLMockGraphQL(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map both protocols
app.MapLLMockRest("/api/mock");
app.MapLLMockGraphQL("/api/mock");

app.Run();
```

**Cela crée:**

- `/api/mock/**` Points finals de REST -
- `/api/mock/graphql` - GraphQL point final
- Aucun point final d'écoulement

---


#### Exemple 2: GraphQL + SignalR (Sans RESTM SK3

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register GraphQL and SignalR services
builder.Services.AddLLMockGraphQL(builder.Configuration);
builder.Services.AddLLMockSignalR(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map both protocols
app.MapLLMockGraphQL("/api/queries");
app.MapLLMockSignalR("/hub/realtime", "/api/contexts");

app.Run();
```

**Cela crée:**

- `/api/queries/graphql` - GraphQL point final
- `/hub/realtime` - SignalR hub
- `/api/contexts` - API de gestion SignalR
- Aucun point final REST ou SSE

---


#### Exemple 3: Tout avec différents patrons

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register all services modularly
builder.Services.AddLLMockRest(builder.Configuration);
builder.Services.AddLLMockStreaming(builder.Configuration);
builder.Services.AddLLMockGraphQL(builder.Configuration);
builder.Services.AddLLMockSignalR(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map each protocol with custom patterns
app.MapLLMockRest("/api/rest");           // /api/rest/**
app.MapLLMockStreaming("/api/stream");    // /api/stream/stream/**
app.MapLLMockGraphQL("/api/graphql");     // /api/graphql/graphql
app.MapLLMockSignalR("/hub/live", "/api/hub");

app.Run();
```

**Cela crée:**

- `/api/rest/**` Points finals de REST -
- `/api/stream/stream/**` - Écoulement de l'SSE
- `/api/graphql/graphql` - GraphQL point final
- `/hub/live` - SignalR hub
- `/api/hub/contexts` - Gestion de SignalR

---


#### Exemple 4: REST + OpenAPI + Gestion du contexte

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register REST and OpenAPI services
builder.Services.AddLLMockRest(builder.Configuration);
builder.Services.AddLLMockOpenApi(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map all three capabilities
app.MapLLMockRest("/api/mock");
app.MapLLMockOpenApi();
app.MapLLMockApiContextManagement("/api/contexts");

app.Run();
```

**Cela crée:**

- `/api/mock/**` Points finals de REST -
- Points de fin des spécifications OpenAPI (de specs configurés)
- `/api/contexts/{contextId}` - Gestion du contexte
- Aucun flux, GraphQL, SignalRM SK2 ou gRPC

---


#### Exemple 5: gRPC + OpenAPI (Protocol Bridge Testing)

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register services for both protocols
builder.Services.AddLLMockApi(builder.Configuration);  // Includes gRPC
builder.Services.AddLLMockOpenApi(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map both protocols
app.MapLLMockGrpcManagement("/api/grpc-protos");
app.MapLLMockGrpc("/api/grpc");
app.MapLLMockOpenApi();

app.Run();
```

**Cela crée:**

- `/api/grpc-protos` - gRPC proto management
- `/api/grpc/{service}/{method}` - appels gRPC
- Points finals spéciaux de l'OpenAPI
- Perfect pour tester les ponts de protocole/gateways

---


#### Exemple 6: Tout modulaire (Examen complet de l'échantillonnage

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Register everything modularly
builder.Services.AddLLMockRest(builder.Configuration);
builder.Services.AddLLMockStreaming(builder.Configuration);
builder.Services.AddLLMockGraphQL(builder.Configuration);
builder.Services.AddLLMockSignalR(builder.Configuration);
builder.Services.AddLLMockOpenApi(options =>
{
    options.BaseUrl = "http://localhost:11434/v1/";
    options.ModelName = "llama3";
    options.OpenApiSpecs = new List<OpenApiSpecConfig>
    {
        new OpenApiSpecConfig
        {
            Name = "External API",
            Source = "https://api.example.com/openapi.json",
            BasePath = "/api/external"
        }
    };
});

var app = builder.Build();

app.UseRouting();

// Map everything at different paths
app.MapLLMockRest("/api/rest");
app.MapLLMockStreaming("/api/stream");
app.MapLLMockGraphQL("/api/graphql");
app.MapLLMockSignalR("/hub/realtime", "/api/hub");
app.MapLLMockOpenApi();
app.MapLLMockOpenApiManagement("/api/specs");
app.MapLLMockGrpcManagement("/api/grpc-protos");
app.MapLLMockGrpc("/api/grpc");
app.MapLLMockApiContextManagement("/api/contexts");

app.Run();
```

**Cela crée:**

- `/api/rest/**` Points finals de REST -
- `/api/stream/stream/**` - Écoulement de l'SSE
- `/api/graphql/graphql` - GraphQL point final
- `/hub/realtime` - SignalR hub
- `/api/hub/contexts` - Gestion de SignalR
- `/api/external/**` - Points finals de spécification OpenAPI
- `/api/specs` - Gestion OpenAPI
- `/api/grpc-protos` - gRPC proto management
- `/api/grpc/{service}/{method}` - appels gRPC
- `/api/contexts/{contextId}` - Gestion du contexte

**Perfect pour:**

- Essais d'intégration approfondis
- Examen des architectures de microservice
- Portails multi-protocol API
- Développement complet d’un stade avec différents types de clients

---


## Instances multiples

Faire fonctionner plusieurs APIs de simulation indépendantes avec différentes configurations:

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Development endpoints - high randomness
builder.Services.AddLLMockRest(options =>
{
    options.BaseUrl = "http://localhost:11434/v1/";
    options.ModelName = "llama3";
    options.Temperature = 1.5;
});

builder.Services.AddLLMockGraphQL(options =>
{
    options.BaseUrl = "http://localhost:11434/v1/";
    options.ModelName = "llama3";
    options.Temperature = 1.5;
});

var app = builder.Build();

app.UseRouting();

// Development endpoints
app.MapLLMockRest("/api/dev");
app.MapLLMockGraphQL("/api/dev");

// Stable test endpoints (would need separate config)
app.MapLLMockRest("/api/test");
app.MapLLMockGraphQL("/api/test");

app.Run();
```

---


## Avantages de l'approche modulaire

### 1. **Réduction des empreintes digitales de la mémoire**

Ne chargez que les gestionnaires que vous utilisez en fait:

- REST seulement: ~30% moins mémoire
- GraphQL seulement: ~40% moins mémoire
- Streaming seulement: ~40% moins mémoire

### 2. **Démarrage plus rapide**

Moins de services pour enregistrer = un démarrage d’application plus rapide

### 3. **Intention plus claire**

Le code indique explicitement les protocoles utilisés par votre app

### 4. **Essais plus faciles**

Essais de protocoles isolés:

```csharp
// Test file for REST only
builder.Services.AddLLMockRest(config);
app.MapLLMockRest("/api/mock");

// Test file for GraphQL only
builder.Services.AddLLMockGraphQL(config);
app.MapLLMockGraphQL("/api/mock");
```

### 5. **Aucun changement non interrompu**

Code existant continue de fonctionner:

```csharp
// This still works exactly as before
builder.Services.AddLLMockApi(configuration);
app.MapLLMockApi("/api/mock");
```

### 6. **Modèles flexibles**

Monter les protocoles à n'importe quel chemin:

```csharp
app.MapLLMockRest("/rest");
app.MapLLMockGraphQL("/gql");
app.MapLLMockStreaming("/events");
app.MapLLMockSignalR("/ws", "/manage");
```

---


## Guide des migrations

### De v1.1.0 à v 1.2.0

**Aucun changement requis!** Votre code existant fonctionne comme-is.

**Optionnel: Migration vers une approche modulaire pour les avantages**

**Avant (vM SK1**

```csharp
builder.Services.AddLLMockApi(builder.Configuration);
app.MapLLMockApi("/api/mock", includeStreaming: true, includeGraphQL: true);
```

**Après (vM SK1 - Modulaire):**

```csharp
// Only include what you need
builder.Services.AddLLMockRest(builder.Configuration);
builder.Services.AddLLMockGraphQL(builder.Configuration);

app.MapLLMockRest("/api/mock");
app.MapLLMockGraphQL("/api/mock");
```

Les deux approches fonctionnent identiquement, mais l’approche modulaire est plus explicite et efficace.

---


## Résumé

### Services du protocole de base

| Approche | Méthode d'addition
|----------|------------|------------|----------|
| **Unité** | `AddLLMockApi()` | `MapLLMockApi()` | Tout (RESTM SK2Streaming+GraphQLMST4gRPCMSC5 backward compatible SSK6
| **REST** | `AddLLMockRest()` | `MapLLMockRest()` | Remplacement REST simple |
| **GraphQL** | `AddLLMockGraphQL()` | `MapLLMockGraphQL()` | GraphQLM SK1Apps seulement |
| **Enregistrement** | `AddLLMockStreaming()` | `MapLLMockStreaming()` | SSE transmise uniquement |
| **SignalR** | `AddLLMockSignalR()` | `MapLLMockSignalR()` | Données WebSocket réellesM SK1heures |
| **OpenAPI** | `AddLLMockOpenApi()` | `MapLLMockOpenApi()` | Mock de OpenAPI/Spécifications d'évacuateur |

### Caractéristiques additionnelles (No Add Method Required)

| Caractéristique | Méthode de cartographie MSC2 Usage MSC3
|---------|------------|----------|
| **gRPC Gestion** | `MapLLMockGrpcManagement()` | Soumettre à la disposition de l’utilisateur les fichiers protégaux / générer
| **Les appels gRPC** | `MapLLMockGrpc()` | Invoquer les méthodes gRPC modèles |
| **Gestion OpenAPI** | `MapLLMockOpenApiManagement()` | Charger dynamiquement les spécifications OpenAPI |
| **Gestion du contexte** | `MapLLMockApiContextManagement()` | Voir/ Modifier l'historique de la conversation LLM |

**Notes:**

- Les services gRPC sont inclus dans `AddLLMockApi()` mais la carte séparément
- La gestion OpenAPI permet de charger des spécifications dynamiques au moment du démarrage
- La gestion du contexte fonctionne avec tout protocole qui maintient l'état de conversation
- Toutes les fonctions peuvent être mélangées et adaptées au besoin

**Choisissez l’approche qui convient le mieux à vos besoins!**