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 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

Vous pouvez trouver le GitHub ici 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)
• Approche modulaire
  • REST seulement
  • GraphQL seulement
  • S'acheminant seulement
  • SignalR seulement
  • gRPC seulement
  • OpenAPI seulement
  • Context Management API
  • Mélanger et correspondre
• Instances multiples
• Avantages de l'approche modulaire
• Guide des migrations
• Résumé

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

Le code existant continue de fonctionner sans changements:

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:

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:

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:

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.

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:

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:

# 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:

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:

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)

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

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

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

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)

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

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:

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:

// 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:

// 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:

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

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

Après (vM SK1 - Modulaire):

// 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

Caractéristiques additionnelles (No Add Method Required)

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!