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 für das Projekt – alle öffentlichen Bereiche usw. –

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

Sie können die GitHub hier 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 , ) ,
• Modularer Ansatz
  • Nur REST
  • Nur GraphQL
  • Nur Streaming
  • Nur SignalR
  • Nur gRPC
  • Nur OpenAPI
  • API für Kontextverwaltung
  • Mix und Match
• Mehrere Instanzen
• Vorteile des modularen Ansatzes
• Migrationsleitfaden
• Zusammenfassung

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

Bestehender Code funktioniert weiterhin ohne Änderungen.

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

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

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

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

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

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

# 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

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

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

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

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

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

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

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

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

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

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

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

6. Flexible Muster

Protokolle an jedem Pfad montieren

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

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

Nach dem Einsetzen des Modularen Modulars

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

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.