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 för projektet, all offentlig domain etc...

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

Ni kan hitta GitHub här 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)
• Modulära angreppssätt
  • Bara REST
  • Bara GraphQL
  • Bara Streaming
  • Bara SignalR
  • Bara gRPC
  • Bara OpenAPI
  • Kontextmanagement API
  • Blanda och matcha
• Flera instanser
• Mönster av modulära metoder
• Migrationsführer
• sammanfattning

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

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

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:

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

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:

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

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:

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:

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

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:

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

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

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

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

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)

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

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:

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:

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

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

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

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

Efter (v1.2.0 - Modular

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

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

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!