# LLMApi: Modular Architecture Voorbeelden

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

# Inleiding

Een van de belangrijkste dingen die ik wilde met LLMApi was de mogelijkheid om het zo licht mogelijk te zijn (dus simuleer gewoon het api type dat je wilt) EN super gemakkelijk te krijgen intp; dus je moet in staat zijn om alles net zo gemakkelijk te krijgen.

Met dit in gedachten heb ik het ontworpen met modulariteit in het achterhoofd (fluistert... in de toekomst wil ik dat je in staat bent om 'plugins' toe te voegen die nog meer mogelijk maken).[Hier is het artikel over hoe tha tarchitectuur werkt en alles wat het is ins en outs.](https://github.com/scottgal/LLMApi)U kunt de

> GitHub hier

[![voor het project, alle publieke domein, enz...](https://img.shields.io/nuget/v/mostlylucid.mockllmapi.svg)](https://www.nuget.org/packages/mostlylucid.mockllmapi)
[![OPMERKING: Dit is de live van gitHub.](https://img.shields.io/nuget/dt/mostlylucid.mockllmapi.svg)](https://www.nuget.org/packages/mostlylucid.mockllmapi)

Het is AI gegenereerd.[NuGet](https://github.com/scottgal/LLMApi)NuGet

# U kunt de

**GitHub hier**voor het project, alle publieke domein, enz...

## Modular Architecture Voorbeelden

- [Nieuw in v1,2.0+:](#backward-compatible-unified-approach)
- [Complete modulariteit!](#modular-approach)
  - [Elk protocol (REST, Streaming, GraphQL, SignalR, gRPC, OpenAPI) kan nu onafhankelijk worden toegevoegd en in kaart gebracht.](#rest-only)
  - [Plus dynamisch spec laden, context management, en nog veel meer!](#graphql-only)
  - [Inhoudstabel](#streaming-only)
  - [Achterwaarts compatibel (Unified Approach)](#signalr-only)
  - [Modulaire benadering](#grpc-only)
  - [Alleen REST](#openapi-only)
  - [Alleen GraphQL](#context-management-api)
  - [Alleen streamen](#mix-and-match)
- [Alleen SignalR](#multiple-instances)
- [Alleen gRPC](#benefits-of-modular-approach)
- [Alleen openAPI](#migration-guide)
- [Contextbeheer API](#summary)

---


## Mix en match

**Meervoudige instanties**

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

**Voordelen van een modulaire aanpak**

- `/api/mock/**`Migratiegids
- `/api/mock/stream/**`Samenvatting
- `/api/mock/graphql`Achterwaarts compatibel (Unified Approach)
- `/hub/mock`Bestaande code blijft werken zonder enige wijzigingen:
- `/api/mock/contexts`Dit creëert:

---


## - REST eindpunten

### - SSE streaming eindpunten

- GraphQL eindpunt

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

**- SignalR hub (indien toegevoegd)**

- `/api/mock/**`- SignalR management API (indien toegevoegd)

**Modulaire benadering**

- Alleen REST
- Perfect voor eenvoudige REST API spotten zonder extra overhead:
- Dit creëert:

---


### - REST eindpunten

Voordelen:

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

**Minimale geheugenvoetafdruk**

- `/api/mock/graphql`Snellere opstarttijd

**Omvat alleen RegularRequestHandler**

- Alleen GraphQL
- Perfect voor alleen GraphQL-toepassingen:
- Dit creëert:

---


### - GraphQL eindpunt

Voordelen:

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

**Alleen GraphQL-instellingen opruimen**

- `/api/mock/stream/**`Geen onnodige REST-afhandelaars

**Perfect voor het testen van de GraphQL-client**

- Alleen streamen
- Perfect voor het testen van SSE streaming clients:
- Dit creëert:

---


### - SSE streaming eindpunten

Voordelen:

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

**Lightweight streaming-only setup**

- `/hub/mock`Perfect voor EventSource testen
- `/api/contexts`Geen REST/GraphQL-overhead

**Alleen SignalR**

- Perfect voor real-time dashboard prototyping:
- Dit creëert:
- - SignalR hub

---


### - Context management API

Voordelen:

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

**Alleen real-time setup**

- `/api/grpc-protos`Geen HTTP-eindpunt overhead
- `/api/grpc/{serviceName}/{methodName}`Perfect voor WebSocket testen

**Alleen gRPC**

- Perfect voor het testen van gRPC clients met dynamische proto definities:
- Dit creëert:
- - Uploaden/beheer .proto bestanden (POST, GET, DELETE)

**- Roep mock gRPC-methoden op**

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

---


### Voordelen:

Dynamisch proto uploaden zonder recompilatie

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

**Perfect voor gRPC client testen**

- LLM genereert realistische protobuf-responsen`/api/petstore/pet/{petId}`)
- `/api/specs`Gebruiksvoorbeeld:

**Alleen openAPI**

- Perfect voor het bespotten van bestaande OpenAPI/Swagger specificaties:
- Dit creëert:
- Alle eindpunten gedefinieerd in uw OpenAPI-spec (bijv.:
- - Upload/beheer OpenAPI specs dynamisch (POST, GET, DELETE)

---


### Voordelen:

Automatisch hele OpenAPI-specs bespotten

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

**Geen handmatige endpoint mapping vereist**

- `/api/mock/**`Ondersteunt zowel statische (geconfigureerde) als dynamische (geuploade) specificaties
- `/api/contexts/{contextId}`Perfect voor API contract testen

**Contextbeheer API**

- Contextgeschiedenis bekijken en wijzigen toevoegen:
- Dit creëert:
- - REST eindpunten
- - Conversatiegeschiedenis weergeven/wijzigen

---


### Voordelen:

LLM-gespreksgeschiedenis tonen voor debuggen

#### Context aanpassen om reacties te sturen

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

**Wis de context om status te resetten**

- `/api/mock/**`Perfect voor het testen van stateful scenario's
- `/api/mock/graphql`Mix en match
- Combineer protocollen zoals nodig voor uw use case:

---


#### Voorbeeld 1: REST + GraphQL (No Streaming)

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

**Dit creëert:**

- `/api/queries/graphql`- REST eindpunten
- `/hub/realtime`- GraphQL eindpunt
- `/api/contexts`Geen streaming eindpunten
- Voorbeeld 2: GraphQL + SignalR (No REST)

---


#### Dit creëert:

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

**- GraphQL eindpunt**

- `/api/rest/**`- SignalR hub
- `/api/stream/stream/**`- SignalR management API
- `/api/graphql/graphql`Geen REST- of SSE-eindpunten
- `/hub/live`Voorbeeld 3: Alles met verschillende patronen
- `/api/hub/contexts`Dit creëert:

---


#### - REST eindpunten

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

**- SSE-streaming**

- `/api/mock/**`- GraphQL eindpunt
- - SignalR hub
- `/api/contexts/{contextId}`- SignalR management
- Voorbeeld 4: REST + OpenAPI + Context Management

---


#### Dit creëert:

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

**- REST eindpunten**

- `/api/grpc-protos`OpenAPI spec eindpunten (van geconfigureerde specificaties)
- `/api/grpc/{service}/{method}`- Context management
- Geen streaming, GraphQL, SignalR of gRPC
- Voorbeeld 5: gRPC + OpenAPI (Protocol Bridge Testing)

---


#### Dit creëert:

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

**- gRPC proto management**

- `/api/rest/**`- gRPC-gesprekken
- `/api/stream/stream/**`OpenAPI-spec eindpunten
- `/api/graphql/graphql`Perfect voor het testen van protocolbruggen/poorten
- `/hub/realtime`Voorbeeld 6: Alles modulaire (Full Stack Testing)
- `/api/hub/contexts`Dit creëert:
- `/api/external/**`- REST eindpunten
- `/api/specs`- SSE-streaming
- `/api/grpc-protos`- GraphQL eindpunt
- `/api/grpc/{service}/{method}`- SignalR hub
- `/api/contexts/{contextId}`- SignalR management

**- OpenAPI spec eindpunten**

- - OpenAPI management
- - gRPC proto management
- - gRPC-gesprekken
- - Context management

---


## Perfect voor:

Uitgebreide integratietests

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

---


## Testen van microservicearchitecturen

### 1. **Multiprotocol API gateways**

Full-stack ontwikkeling met verschillende client types

- Meervoudige instanties
- Voer meerdere onafhankelijke mock API's uit met verschillende configuraties:
- Voordelen van een modulaire aanpak

### 2. **Verlaagde geheugenvoetafdruk**

Laad alleen de handlers die u daadwerkelijk gebruikt:

### 3. **Alleen REST: ~30% minder geheugen**

GraphQL alleen: ~40% minder geheugen

### 4. **Alleen streamen: ~40% minder geheugen**

Sneller opstarten

```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. **Minder diensten om te registreren = sneller opstarten van app**

Duidelijkere intent

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

### 6. **Code geeft expliciet aan welke protocollen uw app gebruikt**

Gemakkelijker testen

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

---


## Testprotocollen in afzondering:

### Geen Breaking Changes

**Bestaande code blijft werken:**Flexibele patronen

**Aankoppelen van protocollen op elk pad:**

**Migratiegids**

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

**Van v1.1.0 tot v1.2.0**

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

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

Geen veranderingen nodig!

---


## Uw bestaande code werkt als-is.

### Facultatief: Migreren naar modulaire aanpak voor voordelen

Vóór (v1/1.0):
|----------|------------|------------|----------|
| **Na (v1,2.0 - Modular):** | `AddLLMockApi()` | `MapLLMockApi()`Beide benaderingen werken identiek, maar de modulaire aanpak is explicieter en efficiënter.
| **Samenvatting** | `AddLLMockRest()` | `MapLLMockRest()`Kernprotocoldiensten
| **Toevoegen methode Kaart Methode Gebruik geval** | `AddLLMockGraphQL()` | `MapLLMockGraphQL()`Unified
| **Alles (REST+Streaming+GraphQL+gRPC), achterwaarts compatibel** | `AddLLMockStreaming()` | `MapLLMockStreaming()`REST
| **Eenvoudige REST spotten** | `AddLLMockSignalR()` | `MapLLMockSignalR()`GraphQL
| **GraphQL-alleen-apps** | `AddLLMockOpenApi()` | `MapLLMockOpenApi()`Streaming

### Alleen SSE-streaming

SignaalR
|---------|------------|----------|
| **Real-time WebSocket-gegevens** | `MapLLMockGrpcManagement()`OpenAPI
| **Mock van OpenAPI/Swagger specs** | `MapLLMockGrpc()`Extra functies (Geen methode vereist)
| **Kenmerk van de kaartmethode Gebruik koffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .** | `MapLLMockOpenApiManagement()`gRPC-beheer
| **Uploaden/beheren .proto bestanden** | `MapLLMockApiContextManagement()`gRPC-oproepen

**Roep mock gRPC-methoden op.**

- OpenAPI-beheer`AddLLMockApi()`OpenAPI specs Dynamisch laden
- Contextbeheer
- LLM-gespreksgeschiedenis weergeven/wijzigen
- Opmerkingen:

**gRPC-diensten zijn inbegrepen in**