# LLMApi: Modulära arkitektoniska exempel

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

# Inleiding

En av de viktigaste sakerna jag ville med LLMApi var möjligheten att den skulle vara så lätt som möjligt ( så bara simulera den apityp du vill ha ) Och vara väldigt lätt att få intp ; så du borde kunna få allt lika enkelt M SK3 Med detta i åtanke designade jag den med modularitet i ådanke ♫ ( viskar ♫

Ni kan hitta[ GitHub här ](https://github.com/scottgal/LLMApi)för projektet, all offentlig domain etc...

> NOTET: Det här är live från gitHub . Det är AI skapat

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

Ni kan hitta[ GitHub här ](https://github.com/scottgal/LLMApi)för projektet, all offentlig domain etc...

# Modulära arkitektoniska exempel

**Ny i v1.2.0+:** Komplett modularitet! Varje protocol (REST, StreamingM SK3 GraphQLMska4 SignalRM Ska5 gRPC Mska6 OpenAPI Mka7 kan nu tillsättas och kartläggas oberoende av varandra M Ska8 Plus dynamiska specifiklader Mske9 kontextuellt hantering Msaka10 och mer Mcka11

## Tabellen med innehåll

- [Kompatibelt bakåt (Ünifikt tillvägagångssätt)](#backward-compatible-unified-approach)
- [Modulära angreppssätt](#modular-approach)
  - [Bara REST](#rest-only)
  - [Bara GraphQL](#graphql-only)
  - [Bara Streaming](#streaming-only)
  - [Bara SignalR](#signalr-only)
  - [Bara gRPC](#grpc-only)
  - [Bara OpenAPI](#openapi-only)
  - [Kontextmanagement API](#context-management-api)
  - [Blanda och matcha](#mix-and-match)
- [Flera instanser](#multiple-instances)
- [Mönster av modulära metoder](#benefits-of-modular-approach)
- [Migrationsführer](#migration-guide)
- [sammanfattning](#summary)

---


## Kompatibelt bakåt (Ünifikt tillvägagångssätt)

**Den existerande koden fortsätter att fungera utan några ändringar:**

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

**Detta skapar:**

- `/api/mock/**` - REST slutpunkter
- `/api/mock/stream/**` - SSE-strömning slutpunkter
- `/api/mock/graphql` - GraphQL slutpunkt
- `/hub/mock` - SignalR hub  om tillsatt
- `/api/mock/contexts` - SignalR-drivande API om tillsatt

---


## Modulära angreppssätt

### Bara REST

Perfekt för enkel REST API mocking utan extra överhuvudtaget:

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

**Detta skapar:**

- `/api/mock/**` - endast REST slutpunkter

**Möjligheter:**

- Minimala minnesavtryck
- snabbare starttid
- Bara inkluderar RegulärAnsöksHandler

---


### Bara GraphQL

Perfekt för GraphQL

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

**Detta skapar:**

- `/api/mock/graphql` - Bara GraphQL slutpunkt

**Möjligheter:**

- Klara GraphQL- endast konfiguration
- Inga onödiga REST-handlerare
- Perfekt för GraphQL-clienttestning

---


### Bara Streaming

Perfekt för att testa SSE-strömningar hos klienter:

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

**Detta skapar:**

- `/api/mock/stream/**` - endast SSE-strömmar av slutpunkter

**Möjligheter:**

- Lite strömningar- endast konfiguration
- Perfekt för EventSource-tester
- Inget REST/GraphQL överhead

---


### Bara SignalR

Perfekt för riktiga dataskärmar

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

**Detta skapar:**

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

**Möjligheter:**

- Enlig real---tidsuppsättning
- Ingen HTTP slutpunkt överhuvudtaget
- Perfekt för WebSocket-tester

---


### Bara gRPC

Perfekt för att testa gRPC-clienter med dynamiska protodefinitioner:

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

**Detta skapar:**

- `/api/grpc-protos` - ladda upp/ sköta .proto-filer ♫ ♫  ♫ POST ♫
- `/api/grpc/{serviceName}/{methodName}` - Invokera modell gRPC metoder

**Möjligheter:**

- Dynamisk protoupplaad utan kopiering
- Perfekt för gRPC-clienttester
- LLM genererar realistiska protobuf-responser

**Användarexemplet:**

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

---


### Bara OpenAPI

Perfekt för att mocka existerande OpenAPI/Swaggerspetsar:

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

**Detta skapar:**

- Alla slutpunkter som definieras i din OpenAPI specifikation (eM SK1g., `/api/petstore/pet/{petId}`)
- `/api/specs` - ladda upp/ sköta OpenAPI-speckor dynamiskt  skicka ut , få in M SK4 avlägsna

**Möjligheter:**

- Automatiskt modellera hela OpenAPI-specs
- Ingen handlig slutpunktkartläggning krävs
- Ondersteuner både statiska (configured) och dynamiska (uploadedM SK3 specifikationer
- Perfekt för API-kontraktstest

---


### Kontextmanagement API

Lägg till kontexthistorisk syn och modifiering:

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

**Detta skapar:**

- `/api/mock/**` - REST slutpunkter
- `/api/contexts/{contextId}` - Se

**Möjligheter:**

- Se LLM konversation historia för att lösa problem
- Modifiera sammanhanget för att styra reaktioner
- Klara kontext för att återställa tillståndet
- Perfekt för att testa statefulla scenarior

---


### Blanda och matcha

Kombinera protokoll som behövs för ditt användandecase:

#### Till exempel 1: REST + GraphQL | ( | Ingen strömning

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

**Detta skapar:**

- `/api/mock/**` - REST slutpunkter
- `/api/mock/graphql` - GraphQL slutpunkt
- Inga strömmar ändepunkter

---


#### Exempla 2: GraphQL + SignalR | ( | Nej Reset

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

**Detta skapar:**

- `/api/queries/graphql` - GraphQL slutpunkt
- `/hub/realtime` - SignalR hub
- `/api/contexts` - SignalR management API
- Inga REST eller SSE slutpunkter

---


#### exempel 3: Allt med olika mönster

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

**Detta skapar:**

- `/api/rest/**` - REST slutpunkter
- `/api/stream/stream/**` - SSE-strömningar
- `/api/graphql/graphql` - GraphQL slutpunkt
- `/hub/live` - SignalR hub
- `/api/hub/contexts` - SignalR management

---


#### exempel 4: REST + OpenAPI + Kontextmanagement

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

**Detta skapar:**

- `/api/mock/**` - REST slutpunkter
- OpenAPI-spec slutpunkter ( från konfigurerade specifikationer)
- `/api/contexts/{contextId}` - Kontextmanagement
- Ingen strömning , GraphQL, SignalRM SK2 eller gRPC

---


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

**Detta skapar:**

- `/api/grpc-protos` - gRPC protomanagement
- `/api/grpc/{service}/{method}` - gRPC ringer
- OpenAPI-specifika slutpunkter
- Perfekt för att testa protokollbrücker/öppningsvägar

---


#### exempel 6: Allt modulärt (Full Stack Testing

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

**Detta skapar:**

- `/api/rest/**` - REST slutpunkter
- `/api/stream/stream/**` - SSE-strömningar
- `/api/graphql/graphql` - GraphQL slutpunkt
- `/hub/realtime` - SignalR hub
- `/api/hub/contexts` - SignalR management
- `/api/external/**` - OpenAPI-specifika slutpunkter
- `/api/specs` - OpenAPI-styrning
- `/api/grpc-protos` - gRPC protomanagement
- `/api/grpc/{service}/{method}` - gRPC ringer
- `/api/contexts/{contextId}` - Kontextmanagement

**Perfekt för:**

- Kompleks integrationstest
- Att testa mikrotjänster
- Multi-protocol API grindvägar
- Full-stackutveckling med olika klienttyper

---


## Flera instanser

Runna flera oberoende modellAPIs med olika konfigurationer:

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

---


## Mönster av modulära metoder

### 1. **Reduced Memory Footprint**

Bara ladda de handler du faktiskt använder:

- Bara REST : ~30% mindre minne
- GraphQL bara : ~40% mindre minne
- Streaming bara: ~40% mindre minne

### 2. **snabbare uppstartning**

Mindre tjänster att registrera = snabbare appstart

### 3. **En tydligare intention**

Kod visar tydligt vilka protokoller din app använder

### 4. **Makare tester**

Testprotokoll i isolering:

```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. **Ingen brytande förändring**

Existerande kod fortsätter att fungera:

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

### 6. **Flexibla mönster**

Mounta protokoll vid vilken väg som helst:

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

---


## Migrationsführer

### Från v1.1.0 till v 1.2.0

**Inga ändringar krävs!** Din existerande kod fungerar som-is.

**Optionellt: Migra till modulära metoder för nytta**

**Innan (vM SK1**

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

**Efter (v1.2.0 - Modular**

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

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

Båda tillvägagångssätten fungerar identiskt, men modulära metoderna är mer tydliga och effektiva.

---


## sammanfattning

### Kernprotokolltjänster

| tillvägagångspunkt | | | Methoden för att lägga till || | Karteringsmetoden |
|----------|------------|------------|----------|
| **Förenad** | `AddLLMockApi()` | `MapLLMockApi()` | Allt (RESTM SK2Streaming+GraphQLMska4gRPCM Ska5 bakåtkompatibel mska6
| **REST** | `AddLLMockRest()` | `MapLLMockRest()` | Enkel REST mocking |
| **GraphQL** | `AddLLMockGraphQL()` | `MapLLMockGraphQL()` | GraphQL
| **Streaming** | `AddLLMockStreaming()` | `MapLLMockStreaming()` | endast SSE-strömningar |
| **SignalR** | `AddLLMockSignalR()` | `MapLLMockSignalR()` | Verklig-tids-WebSocketdata  |
| **OpenAPI** | `AddLLMockOpenApi()` | `MapLLMockOpenApi()` | Mock från OpenAPI/Swaggerspetsar |

### Aditionella kännetecken ( Inga sätt att lägga till är nödvändigt )

| Funktion | Karteringsmetod | | | Användarfall |
|---------|------------|----------|
| **gRPC Management** | `MapLLMockGrpcManagement()` | ladda upp/ sköta .proto-filer |
| **gRPC In ហៅ** | `MapLLMockGrpc()` | Invokera modell gRPC-metoder |
| **OpenAPI-Management** | `MapLLMockOpenApiManagement()` | Dynamiskt ladda OpenAPI specifikationer |
| **Kontextstyrning** | `MapLLMockApiContextManagement()` | Se / Modifiera LLM konversationshistorien |

**Märkter:**

- gRPC-tjänsterna är inkluderade i `AddLLMockApi()` men kartlägg det separat
- OpenAPI-behandlingar tillåter dynamiskt dragning av specifikationer vid starttid
- Kontextstyrning fungerar med vilket protocol som håller konversationstillstånd som helst
- Alla egenskaper kan blandas och matchas när det behövs

**Välj den strategi som passar ditt behov bäst!**