# Beispiele für modulare Architektur

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

# Einleitung

Eines der wichtigsten Dinge, die ich mit LLMApi wollte, war die Fähigkeit für sie so leicht wie möglich zu sein.(-so JUST simulieren den Api-Typ Sie wollen, )- UND super einfach zu bekommen intp-;-, so sollten Sie in der Lage sein, alles genauso einfach erhalten?.-, In diesem Sinne habe ich es mit Modularität im Kopf entworfen.(-, Whispers in Zukunft Ich möchte, dass Sie können hinzufügen, '-Plugine...

Sie können die[ GitHub hier ](https://github.com/scottgal/LLMApi)für das Projekt – alle öffentlichen Bereiche usw. –

> HINWEIS:-Dies ist das Live von gitHub-.-Es wird KI erzeugt -.-

[![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)

Sie können die[ GitHub hier ](https://github.com/scottgal/LLMApi)für das Projekt – alle öffentlichen Bereiche usw. –

# Beispiele für modulare Architektur

**Neu in v.1.2.0+:-** Komplette Modularität – !-Jedes Protokoll – ( – REST, – Streaming – , – GraphQL3 – SignalR., – gRPC – , – OpenAPI – ) – kann jetzt unabhängig hinzugefügt und abgebildet werden – M. – Plus dynamisches Spekt Laden – MSV9 – Kontextmanagement und mehr – MSSK11 –

## Inhaltsverzeichnis

- [Rückwärtskompatibel -( , Unified Approach , ) ,](#backward-compatible-unified-approach)
- [Modularer Ansatz](#modular-approach)
  - [Nur REST](#rest-only)
  - [Nur GraphQL](#graphql-only)
  - [Nur Streaming](#streaming-only)
  - [Nur SignalR](#signalr-only)
  - [Nur gRPC](#grpc-only)
  - [Nur OpenAPI](#openapi-only)
  - [API für Kontextverwaltung](#context-management-api)
  - [Mix und Match](#mix-and-match)
- [Mehrere Instanzen](#multiple-instances)
- [Vorteile des modularen Ansatzes](#benefits-of-modular-approach)
- [Migrationsleitfaden](#migration-guide)
- [Zusammenfassung](#summary)

---


## Rückwärtskompatibel -( , Unified Approach , ) ,

**Bestehender Code funktioniert weiterhin ohne Änderungen.**

```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();
```

**Dies erzeugt ,:'**

- `/api/mock/**` REST-Endpunkte
- `/api/mock/stream/**` SSE-Streamingendpunkte
- `/api/mock/graphql` GraphQL-Endpunkt
- `/hub/mock` SignalR-Nabe, falls hinzugefügt
- `/api/mock/contexts` SignalR-Management-API hinzugefügt

---


## Modularer Ansatz

### Nur REST

Perfekt für einfache REST API Spoting ohne zusätzliche Overheads

```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();
```

**Dies erzeugt ,:'**

- `/api/mock/**` Nur REST-Endpunkte

**Vorteile**

- Minimaler Speicherfußabdruck
- Schnellere Startzeit
- Nur umfasst RegularRequestHandler

---


### Nur GraphQL

Perfekt für GraphQL---Anwendungen

```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();
```

**Dies erzeugt ,:'**

- `/api/mock/graphql` Nur GraphQL-Endpunkt

**Vorteile**

- Nur die GraphQL---Einrichtung reinigen
- Keine unnötigen REST-Handler
- Perfekt für GraphQL Client-Tests

---


### Nur Streaming

Perfekt zum Testen von SSE-Streaming-Clients

```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();
```

**Dies erzeugt ,:'**

- `/api/mock/stream/**` Nur SSE-Streamingendpunkte

**Vorteile**

- Leichtes Streaming Nur Setup
- Perfekt für EventSource-Tests
- Kein REST-/-GraphQL Overhead

---


### Nur SignalR

Perfekt für reales Dashboard-Prototyping

```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();
```

**Dies erzeugt ,:'**

- `/hub/mock` SignalR-Nabe
- `/api/contexts` Kontextmanagement-API

**Vorteile**

- Nur Echtzeit-Einstellung
- Kein HTTP-Endpunkt Overhead
- Perfekt für WebSocket-Tests

---


### Nur gRPC

Perfekt zum Testen von gRPC-Clients mit dynamischen Proto-Definitionen

```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();
```

**Dies erzeugt ,:'**

- `/api/grpc-protos` Hochladen von /Verwalten von .Proto-Dateien
- `/api/grpc/{serviceName}/{methodName}` MSC-Methoden aufrufen

**Vorteile**

- Dynamisches Proto Upload ohne Rekompilierung
- Perfekt für gRPC-Clienttests
- LLM erzeugt realistische Protobuf-Antworten

**Beispiel für die Verwendung**

```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}'
```

---


### Nur OpenAPI

Perfekt zum Spotten vorhandener OpenAPI-/-Swagger-Spezifikationen

```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();
```

**Dies erzeugt ,:'**

- Alle Endpunkte, die in Ihrer OpenAPI-Spezifikation definiert sind `/api/petstore/pet/{petId}`)
- `/api/specs` Upload von OpenAPI-Spezifikationen dynamisch

**Vorteile**

- Alle OpenAPI-Spezifikationen automatisch verspotten
- Keine manuelle Endpunkt-Mapping erforderlich
- Unterstützt sowohl statische als auch dynamische, hochgeladene )-Spezifikationen
- Perfekt für API-Vertragstests

---


### API für Kontextverwaltung

Kontextverlauf anzeigen und modifizieren hinzufügen

```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();
```

**Dies erzeugt ,:'**

- `/api/mock/**` REST-Endpunkte
- `/api/contexts/{contextId}` Ansicht/ Ändern der Gesprächsgeschichte

**Vorteile**

- LLM-Konversationsverlauf zum Debuggen anzeigen
- Kontext ändern, um Antworten zu steuern
- Kontext löschen, um Zustand zurückzusetzen
- Perfekt zum Testen von Stateful Szenarien

---


### Mix und Match

Kombinieren Sie Protokolle, wie für Ihren Anwendungsfall erforderlich.

#### Beispiel: REST - GraphQL - kein 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();
```

**Dies erzeugt ,:'**

- `/api/mock/**` REST-Endpunkte
- `/api/mock/graphql` GraphQL-Endpunkt
- Keine Streaming-Endpunkte

---


#### Beispiel: GraphQL SignalR

```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();
```

**Dies erzeugt ,:'**

- `/api/queries/graphql` GraphQL-Endpunkt
- `/hub/realtime` SignalR-Nabe
- `/api/contexts` SignalR Management API
- Keine REST- oder SSE-Endpunkte

---


#### Beispiel: Alles mit unterschiedlichen Mustern

```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();
```

**Dies erzeugt ,:'**

- `/api/rest/**` REST-Endpunkte
- `/api/stream/stream/**` SSE-Streaming
- `/api/graphql/graphql` GraphQL-Endpunkt
- `/hub/live` SignalR-Nabe
- `/api/hub/contexts` SignalR-Verwaltung

---


#### Beispiel: REST OpenAPI Context Management

```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();
```

**Dies erzeugt ,:'**

- `/api/mock/**` REST-Endpunkte
- OpenAPI-Spezifikationsendpunkte aus konfigurierten Spezifikationen
- `/api/contexts/{contextId}` Kontextverwaltung
- Kein Streaming-,-GraphQL.,. SignalR., oder gRPC

---


#### Beispiel: GRPC-Testen von Prototypbrücken

```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();
```

**Dies erzeugt ,:'**

- `/api/grpc-protos` Verwaltung von gRPC proto
- `/api/grpc/{service}/{method}` GRPC-Aufrufe
- OpenAPI-Spezifikationsendpunkte
- Perfekt für das Testen von Protokollbrücken

---


#### Beispiel: Alles Modulare Testen des ganzen Stapels

```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();
```

**Dies erzeugt ,:'**

- `/api/rest/**` REST-Endpunkte
- `/api/stream/stream/**` SSE-Streaming
- `/api/graphql/graphql` GraphQL-Endpunkt
- `/hub/realtime` SignalR-Nabe
- `/api/hub/contexts` SignalR-Verwaltung
- `/api/external/**` OpenAPI-Spezifikationsendpunkte
- `/api/specs` OpenAPI-Verwaltung
- `/api/grpc-protos` Verwaltung von gRPC proto
- `/api/grpc/{service}/{method}` GRPC-Aufrufe
- `/api/contexts/{contextId}` Kontextverwaltung

**Perfekt für**

- Umfassende Integrationsprüfung
- Prüfung von Mikroservice-Architekturen
- API-Gateways für Multi---Protokolle
- Full---Stack-Entwicklung mit verschiedenen Clienttypen

---


## Mehrere Instanzen

Führen Sie mehrere unabhängige Mock-APIs mit verschiedenen Konfigurationen aus

```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();
```

---


## Vorteile des modularen Ansatzes

### 1. **Reduzierter Speicherfußabdruck**

Laden Sie nur die Handler, die Sie tatsächlich verwenden.

- Nur REST-Speicher
- Nur GraphQL - weniger Speicher
- Nur Streaming-Speicher

### 2. **Schnellere Inbetriebnahme**

Weniger Dienste, um schnellere App-Startups zu registrieren

### 3. **Klarere Absicht**

Code zeigt explizit an, welche Protokolle Ihre App verwendet

### 4. **Leichtere Prüfung**

Prüfprotokolle in Einzelheit - :

```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. **Keine durchbrechenden Änderungen**

Existierender Code funktioniert weiter

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

### 6. **Flexible Muster**

Protokolle an jedem Pfad montieren

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

---


## Migrationsleitfaden

### Von v.1.1.0. bis v.1.2.0.

**Keine Änderungen erforderlich** Ihr vorhandener Code funktioniert als ,- , , . ,

**Optional: MSV0-Migrieren zum modularen Ansatz für Vorteile**

**Vor dem Beginn des (-V1.1.0):**

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

**Nach dem Einsetzen des Modularen Modulars**

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

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

Beide Ansätze funktionieren identisch, aber der modulare Ansatz ist expliziter und effizienter.

---


## Zusammenfassung

### Dienstleistungen des Kernprotokolls

Methode hinzufügen Methode anzeigen Methode anzeigen Anwendung Fall verwenden
|----------|------------|------------|----------|
| **Einheit** | `AddLLMockApi()` | `MapLLMockApi()` Alle Informationen über (, REST+, RESSTM+, GraphQL, +gRPC5, rückwärtskompatibel
| **REST** | `AddLLMockRest()` | `MapLLMockRest()` Einfaches REST-Verspotten
| **SchaubildQL** | `AddLLMockGraphQL()` | `MapLLMockGraphQL()` GraphQL--Nur Anwendungen
| **Streaming** | `AddLLMockStreaming()` | `MapLLMockStreaming()` Nur SSE-Streaming
| **SignalR** | `AddLLMockSignalR()` | `MapLLMockSignalR()` Daten über die Echtzeit-Websocket-Daten
| **Öffnen der API** | `AddLLMockOpenApi()` | `MapLLMockOpenApi()` Mock aus OpenAPI, /, Swagger-Spezifikationen

### Zusätzliche Funktionen -(-No Add Methode erforderlich -)

Funktion der |, Karte Methode der |, Anwendungsfall
|---------|------------|----------|
| **gRPC-Verwaltung** | `MapLLMockGrpcManagement()` Hochladen von /Verwalten von Dateien mit .Proto
| **gRPC-Aufrufe** | `MapLLMockGrpc()` MSC-Methoden aufrufen
| **OpenAPI-Verwaltung** | `MapLLMockOpenApiManagement()` Dynamische Belastung von OpenAPI-Spezifikationen
| **Kontextverwaltung** | `MapLLMockApiContextManagement()` LLM-Gesprächsgeschichte ändern

**Anmerkungen**

- gRPC-Dienstleistungen sind in `AddLLMockApi()` aber Karte getrennt
- OpenAPI-Verwaltung ermöglicht dynamisches Laden der Specs zur Laufzeit
- Context Management funktioniert mit jedem Protokoll, das den Gesprächszustand aufrechterhält
- Alle Funktionen können nach Bedarf gemischt und aufeinander abgestimmt werden

**Wählen Sie den Ansatz, der am besten zu Ihren Bedürfnissen passt.**