# LLMApi: Modulaarinen arkkitehtuuriesimerkkejä

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

# Johdanto

Yksi avainasioista, jonka halusin LLMApilta, oli kyky olla mahdollisimman kevyt (joten vain simuloikaa haluamaanne api-tyyppiä) ja olla superhelppo saada intc; niin sinun pitäisi pystyä saamaan kaikki mahdollisimman helposti.

Tämän vuoksi suunnittelin sen modulaarisuus mielessäni (whispers.. tulevaisuudessa haluan, että voit lisätä "plugins", joka mahdollistaa vielä enemmän).[Tässä on artikkeli siitä, miten tha tarchitecture toimii ja mitä kaikkea se on.](https://github.com/scottgal/LLMApi)Voit löytää

> GitHub tässä.

[![projektia varten kaikki julkisuus ym....](https://img.shields.io/nuget/v/mostlylucid.mockllmapi.svg)](https://www.nuget.org/packages/mostlylucid.mockllmapi)
[![HUOMAUTUS: Tämä on suora lähetys GitHubilta.](https://img.shields.io/nuget/dt/mostlylucid.mockllmapi.svg)](https://www.nuget.org/packages/mostlylucid.mockllmapi)

Se on tekoälyä.[NuGet](https://github.com/scottgal/LLMApi)NuGet

# Voit löytää

**GitHub tässä.**projektia varten kaikki julkisuus ym....

## Moduuliarkkitehtuuriesimerkkejä

- [Uusi v1.2.0+:](#backward-compatible-unified-approach)
- [Täydellinen modulaarisuus!](#modular-approach)
  - [Jokainen protokolla (REST, Streaming, GraphQL, SignalR, gRPC, OpenAPI) voidaan nyt lisätä ja kartoittaa itsenäisesti.](#rest-only)
  - [Lisäksi dynaamista spek-latausta, kontekstin hallintaa ja muuta!](#graphql-only)
  - [Sisällys](#streaming-only)
  - [Taaksepäin yhteensopiva (yhtenäinen lähestymistapa)](#signalr-only)
  - [Modulaarinen lähestymistapa](#grpc-only)
  - [Vain REST](#openapi-only)
  - [Vain kaavioQL](#context-management-api)
  - [Vain virtaviivaista](#mix-and-match)
- [Vain signaalit](#multiple-instances)
- [Vain gRPC](#benefits-of-modular-approach)
- [Vain OpenAPI](#migration-guide)
- [Kontekstinhallinnan API](#summary)

---


## Sekoita ja täsmää

**Useita oikeusasteita**

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

**Moduulilähestymistavan edut**

- `/api/mock/**`Maahanmuutto-opas
- `/api/mock/stream/**`Yhteenveto
- `/api/mock/graphql`Taaksepäin yhteensopiva (yhtenäinen lähestymistapa)
- `/hub/mock`Nykyinen koodi toimii edelleen ilman muutoksia:
- `/api/mock/contexts`Näin syntyy:

---


## - REST- päätetapahtumat

### - SSE: n virtauksen päätetapahtumat

- GrafQL- päätetapahtuma

```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-keskus (jos lisätty)**

- `/api/mock/**`- SignalR-hallinta API (jos lisätty)

**Modulaarinen lähestymistapa**

- Vain REST
- Täydellinen yksinkertaiseen REST API-pilkkuun ilman lisäkuluja:
- Näin syntyy:

---


### - Vain REST- päätetapahtumat

Hyödyt:

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

**Minimaalinen muistijalanjälki**

- `/api/mock/graphql`Nopeampi käynnistysaika

**Sisältää vain RegularRequestHandlerin**

- Vain kaavioQL
- Täydellinen vain GraphQL-sovelluksille:
- Näin syntyy:

---


### - Vain GrafQL- päätetapahtuma

Hyödyt:

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

**Puhdista vain GraphQL-asetukset**

- `/api/mock/stream/**`Ei tarpeettomia REST-käsittelijöitä

**Täydellinen GraphQL-asiakastestaukseen**

- Vain virtaviivaista
- Täydellinen SSE-suoratoistoasiakkaiden testaamiseen:
- Näin syntyy:

---


### - Vain SSE:n suoratoistopäätteet

Hyödyt:

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

**Kevyt suoratoistoasetus**

- `/hub/mock`Täydellinen tapahtumalähdetestaukseen
- `/api/contexts`Ei REST/GraphQL-ylijäämää

**Vain signaalit**

- Täydellinen reaaliaikaiseen kojelautaprototyyppiin:
- Näin syntyy:
- - SignalR-keskus

---


### - Kontekstinhallinnan API

Hyödyt:

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

**Reaaliaikainen vain asetukset**

- `/api/grpc-protos`Ei HTTP:n päätetapahtumaa yleisellä tasolla
- `/api/grpc/{serviceName}/{methodName}`Täydellinen WebSocket-testaukseen

**Vain gRPC**

- Täydellinen testaamaan gRPC-asiakkaita, joilla on dynaamiset proto-määritelmät:
- Näin syntyy:
- - Lataa/johtaa .prototiedostoja (POST, GET, DELETE)

**- Invoke mock gRPC methods**

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

---


### Hyödyt:

Dynaaminen proto-lataus ilman uudelleenlaatimista

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

**Täydellinen gRPC-asiakastestaukseen**

- LLM tuottaa realistisia protobuf-vasteita`/api/petstore/pet/{petId}`)
- `/api/specs`Käyttöesimerkki:

**Vain OpenAPI**

- Täydellinen nykyisten OpenAPI/Swagger-spektien pilkkaamiseen:
- Näin syntyy:
- Kaikki OpenAPI-spekteissä määritellyt päätetapahtumat (esim.
- - Lataa/hallitse OpenAPIa dynaamisesti (POST, GET, DELETE)

---


### Hyödyt:

Pilkkaa automaattisesti koko OpenAPI:n spesifikaatiot

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

**Manuaalista päätetapahtumakartoitusta ei tarvita**

- `/api/mock/**`Tukee sekä staattisia (konfiguroituja) että dynaamista (laajennettuja) speksejä
- `/api/contexts/{contextId}`Täydellinen API-sopimustestaukseen

**Kontekstinhallinnan API**

- Lisää kontekstihistorian katselu ja muokkaus:
- Näin syntyy:
- - REST- päätetapahtumat
- - Näytä/muokkaa keskustelun historiaa

---


### Hyödyt:

Näytä LLM-keskusteluhistoriaa vianetsintää varten

#### Muokkaa kontekstia ohjaamaan vastauksia

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

**Selkeä konteksti tilan nollaamiseksi**

- `/api/mock/**`Täydellinen stateististen skenaarioiden testaamiseen
- `/api/mock/graphql`Sekoita ja täsmää
- Yhdistä protokollat tarpeen mukaan käyttökoteloosi:

---


#### Esimerkki 1: REST + GrafQL (ei virtauksia)

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

**Näin syntyy:**

- `/api/queries/graphql`- REST- päätetapahtumat
- `/hub/realtime`- GrafQL- päätetapahtuma
- `/api/contexts`Ei virtauksen päätetapahtumia
- Esimerkki 2: GrafQL + SignalR (ei REST)

---


#### Näin syntyy:

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

**- GrafQL- päätetapahtuma**

- `/api/rest/**`- SignalR-keskus
- `/api/stream/stream/**`- SignalR-hallinta API
- `/api/graphql/graphql`Ei REST- tai SSE-päätetapahtumia
- `/hub/live`Esimerkki 3: Kaikki, missä on erilaisia kuvioita
- `/api/hub/contexts`Näin syntyy:

---


#### - REST- päätetapahtumat

```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:n suoratoisto**

- `/api/mock/**`- GrafQL- päätetapahtuma
- - SignalR-keskus
- `/api/contexts/{contextId}`- SignalR:n johto
- Esimerkki 4: REST + OpenAPI + Context Management

---


#### Näin syntyy:

```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- päätetapahtumat**

- `/api/grpc-protos`OpenAPI-spektit päätetapahtumat (määritellyistä spekseistä)
- `/api/grpc/{service}/{method}`- Kontekstin hallinta
- Ei suoratoistoa, GrafQL, SignalR tai gRPC
- Esimerkki 5: gRPC + OpenAPI (pöytäkirjan siltatestaus)

---


#### Näin syntyy:

```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-protojohtaminen**

- `/api/rest/**`- GRPC kutsuu
- `/api/stream/stream/**`OpenAPI-spektimuuttujat
- `/api/graphql/graphql`Täydellinen protokollasiltojen/porttien testaamiseen
- `/hub/realtime`Esimerkki 6: Kaikki modulaariset (täysi pinon testaus)
- `/api/hub/contexts`Näin syntyy:
- `/api/external/**`- REST- päätetapahtumat
- `/api/specs`- SSE:n suoratoisto
- `/api/grpc-protos`- GrafQL- päätetapahtuma
- `/api/grpc/{service}/{method}`- SignalR-keskus
- `/api/contexts/{contextId}`- SignalR:n johto

**- OpenAPI spec - päätetapahtumat**

- - OpenAPIn johto
- - gRPC-protojohtaminen
- - GRPC kutsuu
- - Kontekstin hallinta

---


## Täydellinen:

Kokonaisvaltainen integraatiotesti

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

---


## Mikropalveluarkkitehtuurien testaus

### 1. **Usean protocolin API-väylät**

Täysosuman kehitys eri asiakastyypeillä

- Useita oikeusasteita
- Suorita useita riippumattomia valerajapintoja eri asetuksilla:
- Moduulilähestymistavan edut

### 2. **Jalanjäljen väheneminen**

Lastaa vain käyttämäsi käsittelijät:

### 3. **Vain REST: ~30 % vähemmän muistia**

Vain GrafQL: ~40 % vähemmän muistia

### 4. **Vain virtaviivaistaminen: ~40 % vähemmän muistia**

Nopeampi käynnistys

```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. **Vähemmän rekisteröitäviä palveluita = nopeampaa sovelluskäynnistystä**

Selkeämpi intendentti

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

### 6. **Koodi selvästi näyttää, mitä protokollia sovelluksesi käyttää**

Helpompi testaus

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

---


## Testiprotokollat eristyksissä:

### Ei murtuvia muutoksia

**Nykyinen koodi toimii edelleen:**Joustavat kuviot

**Asenna protokollia millä tahansa polulla:**

**Maahanmuutto-opas**

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

**Tullattaessa v1.1.0–1.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");
```

Muutosta ei tarvita!

---


## Nykyinen koodisi toimii sellaisenaan.

### Valinnainen: Muuttakaa modulaariseen lähestymistapaan etuuksien saamiseksi

Ennen (v1.1.0):
|----------|------------|------------|----------|
| **Jälkeen (v1.2.0 - Modulaarinen):** | `AddLLMockApi()` | `MapLLMockApi()`Molemmat lähestymistavat toimivat samalla tavalla, mutta modulaarinen lähestymistapa on selkeämpi ja tehokkaampi.
| **Yhteenveto** | `AddLLMockRest()` | `MapLLMockRest()`Perusprotokollan mukaiset palvelut
| **Add Method Map Method Use Case Add Method Add Method Map Method Use Case Case Add Method Add Method Add Method Add Method Add Method Add Method Add Method Add Method Add Method Add Method Add Method Add Method Add Method Add Add Method Add Method Add Add Method Add Method Add Add Method Add Add Method Add Add Method Add Method Add Method Add Add Add Method Add Method Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add Add A** | `AddLLMockGraphQL()` | `MapLLMockGraphQL()`Yhdistetty
| **Kaikki (REST+Streaming+GraphQL+gRPC), takaperin yhteensopiva** | `AddLLMockStreaming()` | `MapLLMockStreaming()`REST
| **"Yksinkertaisen restin pilkkaaminen"** | `AddLLMockSignalR()` | `MapLLMockSignalR()`GrafQL
| **GrafQL-sovellukset** | `AddLLMockOpenApi()` | `MapLLMockOpenApi()`Virtaus

### SSE:n suoratoisto vain

SignaaliR
|---------|------------|----------|
| **Reaaliaikaiset WebSocket-tiedot** | `MapLLMockGrpcManagement()`OpenAPI
| **Mock OpenAPI:n ja Swaggerin spekseistä** | `MapLLMockGrpc()`Lisäominaisuuksia (ei lisättävää menetelmää)
| **Ominaisuus Karttamenetelmä Käyttö Tapaus** | `MapLLMockOpenApiManagement()`gRPC-hallinta
| **Lataa/hallitse .proto-tiedostoja** | `MapLLMockApiContextManagement()`gRPC kutsuu

**"Invoke mock gRPC methods"**

- OpenAPI-hallinta`AddLLMockApi()`Lataa OpenAPI-tiedot dynaamisesti
- Kontekstin hallinta
- Näytä/muokkaa LLM:n keskusteluhistoriaa
- Huomautukset:

**gRPC-palvelut sisältyvät**