LLMApi: Att använda lokala LLM för att automatiskt simulera API i ASP (Svenska (Swedish))

LLMApi: Att använda lokala LLM för att automatiskt simulera API i ASP

Sunday, 02 November 2025

//

54 minute read

Comments Raw Edit
AI API ASP.NET Core LLM LLMApi mockllmapi Nuget

Inleiding

En av mina ständiga besattelser är provdata. I kombination med min nuvarande kärlek till 'AI hjälpte ' att koda slumpmässiga idéer, det ♫ ' ♫ ledde till att en liten LLM-aktiverad testdatagenerator tillsammans med ett nugetpaket med en mellanprogram som kan generera simulerade API-responser med hjälp av API ♫

NuGet NuGet

Ni kan hitta GitHub här för projektet, all offentlig domain etc...

Koncept

Som med många "AI Assisted" kodende idéer började det med en idé om att simulera utgången med hjälp av LLMsLucidForums, ett häpnadsväckande dysfunktionellt självbefolkande LLM-baserat forumexperiment ) och LLMs är riktigt bra ( om de är lite långsamma ) på att generera proverdata så tänk om Jag kunde använda dem för att simulera vilken API som helst

Benötningar

  1. Det borde vara enkelt att implementera i en ASP
  2. Data borde vara ganska realistiska.
  3. Datan borde vara slumpmässigt
  4. Den kan acceptera JSON ' former ' som säger till LLM hur svaret ska vara.
  5. Den kan använda lokala Open Source LLMs
  6. Det borde vara gratis att använda Nuget control

Det här är vad jag kom på med.

Framtidens tillämpningar kommer troligen att inkludera kakning ifall du vill ha snabbare perf.

Här är readme för paketet ( tagits in automatiskt

mestlucid.mockllmapi

Vad gör den: En produktionsplattform för att skapa realistiska modell-API-responser med hjälp av LLM.

Varför använder du det? Lägg till intelligenta modell-finningspunkter i vilket projekt som helst med bara 2 koder

NuGet NuGet GitHub-utsläpp Licensen : Olicenctioner

Kompanionspaket: mestlucid.mockllmapi.Testing - Testverktyg med flytande HttpClient integration

Hur man läser denna README

Det här README är komplettt av design. Välj din väg:

Vad är nytt?

Den senaste: AutoShape (Shape Memory) - Automatisk JSON strukturkonsistens över ändepunktsändningar v2.5.0: säkerhets förbättringar , AOT/ stöd för att trimma genom att ta bort serialiserings beroenden v2.3.0: Full content type support - form bodies , file uploads v2.2.0: Pluggbara verktyg för API integration v2.1.0: Begränsning av hastigheten , slagning , n- färdigheter med flera utdragsstrategier

Click for detailed v2.5.0 feature breakdown

Version 2.5.0 detaljer

Fokus: säkerhets förbättringar och AOT / stöd för trimning genom att ta bort serialiserings beroenden. fullt bakåtkompatibel med vM SK3

1. AOT - Avlägsna alla reflektioner -baserade serialiserings beroenden

  • Avskaffad System.Text.Json användande av reflektion
  • Handlig JSONkonstruktion genom hela kodexbasen
  • Fullkompatibilitet med .NET 8.0+ AOT och trimning
  • Inget löst problem med starttidstyp
  • Mindre binära storlek och förbättrad uppstartprestential

2. Förhöjt säkerhet - Kompleksa säkerhets förbättringar :

  • Removed all reflection-based serialization that could expose type information
  • Avlägsna potentiella inferens sårbarheter
  • Säkerare handling av JSON med explicita typbegränsningar
  • Reduktion av attack ytan för serialiserings-based exploiter
  • Bättre skydd mot deserialiserade attacker

3. Performanceoptimeringar - Förhöjt körtidsprestential

  • snabbare JSONkonstruktion utan reflektion överhuvudtaget
  • Reduzerade minnesfördelningar
  • Bättre kaslokalitet
  • Tillförlitlig starttid för trimmerade applikationer
  • lägre minnesavtryck

4. .NET | | Kompatibilitet - Hela stödet för .NET | 10 | preview builds

  • Handlig JSONkonstruktion genom hela tiden för att undvika reflektioner
  • Alla egenskaper som testats och fungerade på .NET 10 preview builds
  • Inga brytande ändringar i den existerande funktionaliteten

5. Test förbättringar - Förhöjt utsätt för tester

  • Aditionella tester för AOT/tringscenarier
  • Sicherheit-fokussed unit tests
  • Performance benchmarking-tester
  • 100% klarande med alla nya tester

Se TEST_SUMMARYM SK1md och IMPLEMENTATION_SUMmARY .md för detaljer

Click for detailed v2.3.0 feature breakdown

Version 2.3.0 detaljer

Fokus: Komplett innehållstypssupport för alla vanliga HTTP-ansöksformat . Fully backward compatible with v2.2.0.

1. Formularskroppsstöd - Full support for application/x-www-form-urlencoded innehållstyp. Enkela och flervärdiga värden , automatisk JSON-konvertering, handbyggande för M SK3 NET | 10 kompatibilitetMska5 Perfekt för att testa HTML-former och traditionella webbappsMske6

2. Support för att ladda upp files - Full support for multipart/form-data inklusive att ladda upp plikter. minnen - trygga strömningar M SK2 KB buffer ), extraktion av metadata MSC4 filename M SK5 storlek MST6 innehållstyp M ST7 blandformsfällor och plier M st 8 innehållet dumpas för att undvika minnesblödning M S ST9

3. godtyckliga väglängder - stöd för djupgående nätting via {**path} få tag-all routing . Testat med 9-segment djupgående vägar och komplexa query-strängar

4. Kompleks testsuite - 228 tester | | (37 | ny | ) | som täcker alla egenskaper | МSK4 | formkroppsanalys |(12 | tester ♫ ), | JSON-behandling |

5. .NET | | Kompatibilitet - Handlig JSONkonstruktion genom hela tiden för att undvika reflektioner -baserade serialiseringsproblem . Alla egenskaper testerade och arbetade på |

Se TEST_SUMMARYM SK1md och IMPLEMENTATION_SUMmARY .md för detaljer

Click for detailed v2.2.0 feature breakdown

Version 2.2.0 detaljer

Fokus: Pluggbara verktyg för API-integrationen , förinlägsna- konfigurerade REST-APIs M SK3 och intelligent kontextminnet . fullt bakåtkompatibelt med vM SK5

1. Pluggable Tools & Actions System - Koppla in externa REST APIs eller kedjans mock slutpunkter för att skapa realistiska arbetsflöden och beslutsträd. Hela dokument →

2. Pre-Konfigurerade REST APIs - Definiera kompletta API-konfigurationer en gång , ringning genom namn . Begrepp om form eller OpenAPI-specreferens appsettings.Full.json för fulla exempel på 8

3. Dynamisk kontextmedvetenhetshantering - Kontexter slutar nu efter | 15 | minuter av inactivitet ♫ | konfigurierbart ♫5-1440 | minutes ♫

4. Intelligent gemensam datautvinning - Extraherar automatiskt ALLE fält från reaktioner på vilket än betingsnivån . Nesterade objekt M SK2 Array tracking , första elementdata

5. Förstärkt dokumentation - Nya omfattande vägledningar för verktyg & Aksier, Limitering av hastighet, och API Kontexter.

Se RELEASE_NOTES.md för detaljer

---

Tabellen med innehåll

Kernkoncepter

Protokoll & egenskaper

avancerad & arkitektur

Arkitektur överblick

Ett motor , flera protokoller, gemensam infrastruktur Alla egenskaper delar samma generation, kontext , och styrsystem— som ger en konsekvent beteende över RESTM SK3 GraphQLMska4 SSEMske5 SignalRM Ska6 OpenAPIMka7 och gRPCMsaka8

graph LR
    Client[Client] -->|HTTP Request| API[LLMApi<br/>Minimal API]
    API -->|Chat Completion| Ollama[Ollama API<br/>localhost:11434]
    Ollama -->|Inference| Model[llm-model Model]
    Model -->|Response| Ollama
    Ollama -->|JSON/Stream| API
    API -->|JSON/SSE| Client

    API -.->|uses| Helper[AutoApiHelper]

    style API fill:#4CAF50
    style Helper fill:#2196F3
    style Model fill:#FF9800

Nyckelkomponenter:

  • Enkel LLM-klient: Alla protokoll använder samma LLM-integration med motståndskraftspolitiker
  • Samlad Kontextminne: API-kontexter fungerar över REST
  • De vanliga egenskaperna: Begränsning av hastigheten , kakning M SK2 felsimulation , och tokenshantering gäller alla
  • Modulära design: Använd vilken kombination som helst

Se detaljerade arkitekturdiagramer لاندې för begäranström och formkontroll.

Mönster

Paketet erbjuder sex oberoende egenskaper - använda vilken kombination som helst du behöver Modulära exempel för protokoll-specifika konfigurationer):

1. REST API Mocking

  • Väldigt enkelt: AddLLMockApi() + MapLLMockApi("/api/mock") = direkt modell API
  • Formkontroll: Specifiera den exakta JSON-strukturen via header
  • Alla HTTP-metoder: stödjer GET, POST, PUTMSC3 DELETEM SK4 PATCH
  • Wildcard-Roting: Vilken väg som helst under din väljade slutpunkt som fungerar
  • Komplett innehållstyp stöd (NEW i vM SK1
    • JSON (application/json) - Standard JSON-ansöksorgan
    • Formkroppar (application/x-www-form-urlencoded) - HTML-formulär
    • Att ladda upp filen (multipart/form-data) - Uploader data med extraktion av metadata
    • minne-säkra: Att strömma och dumpa innehållet i filen | ( | bara metadata bevarad
  • godtyckliga väglängder: Den djupgående myggnätet stöds fullt (/api/mock/v1/api/products/electronics/computers/laptops/gaming/...)

2. GraphQL API Mocking

  • Infödda GraphQL Support: POST till /api/mock/graphql med vanliga GraphQL-sökningar
  • Fråga-Atdrivna former: GraphQL-frågan definierar själva svarets struktur
  • Variabla & Operationer: Hela stöd för variabler , operationsnimer , och fragment
  • Rättvis korrekt hantering av fel: Ge tillbaka GraphQL -formaterade fel med data och errors fält

3. Server

  • Fortskridande Streaming: SSE-stöd med progressiv JSON-generation
  • Aktualiseringar av realtid: Datentoken från strömmen
  • Det fungerar ensam: No REST API setup required
  • kompletta SSE Guide | Kontinuösa strömningar

4. SignalR Real-Time Streaming

  • WebSocket Streaming: Kontinuösa verkliga data över SignalR
  • Flera sammanhang: kör flera oberoende dataflöden samtidigt
  • Livkedjanshantering: Start/stoppa kontexter dynamiskt med administrationsAPI
  • Det fungerar ensam: No REST API setup required
  • SignalR Demo Guide

5. OpenAPI / Swagger Mock Generation

  • Automatisk Endpoint Generation: Punktera på vilken OpenAPI som helst /Swaggerspecifikation | ( | URL eller file
  • Alla operationer togs bort: Varje väg och metod från spec blir en direkt slutpunkt
  • Schema-driven data: LLM genererar realistiska data som matchar dina schema
  • Flera Speser: Lade och monterade flera API-spetsar samtidigt
  • Det fungerar ensam: No REST API setup required
  • OpenAPI Features Guide

6. gRPC Service-Mocking (NEW i v1.7.0)

  • Proto-filer ladda upp: ladda upp .proto-filer för att generera gRPC-servmodeller
  • Dual Protocol Support: JSON över HTTP för testning , binär Protobuf för produktion
  • Dinamisk serialisering: Runtime Protobuf-kodering utan kod generering
  • LLM-Spowered Data: Realistiska svar som matchar dina protosignaldefinitioner
  • Det fungerar ensam: No REST API setup required
  • gRPC Support Guide

De vanliga egenskaperna

  • Konfigurerad: appsettings . json eller inline konfiguration
  • Högst variabela data: Varje begäran /update genererar helt olika realistiska data
  • NuGet-paket: Lika att lägga till till existerande projekt
  • Auto-forma (Forma minnet): Automatiskt minns JSON-strukturen från första svaret , vilket ger konsekventa schema över alla efterföljande begärningar till samma slutpunkt Se AutoShape Guide
  • API Kontexter: bibehålla en jämlikhet mellan de förknippade begäran komplett vägledning
  • Fehlersimulation: Omgripande feltestning med | 4|xx|/5|xx statuskoder | МSK3|passerade meddelanden | ,| och flera konfigurationsmetoder
  • Testing Utilities: Kompanionspaket mostlylucid.mockllmapi.Testing för enkel HttpClient integration i tester - Se tester i sektionen

icke-mål & gränser

Vad är detta?

  • Ett utvecklings- och prototypverktyg för realistiska modelldatagenerering
  • Perfekt för framsidans utveckling, ,, API design, ,, demoer och tester
  • Noll- underhållsalternativ till hårdkoderade fixeringar och databasen -bevarade modeller

Vad detta inte är

  • Inte en produktionsdatakälla - Genererade data är realistiska men syntetiska
  • Inte en ersättning för kontraktstest - Använd detta för utvecklingen; validera riktiga APIs separat
  • Inte för ovaliderad produktionstrafik - Användar-input går direkt till LLM-intryckningar.
  • Det är inte en databas eller ett hållbart lager - Inga tillstånd upprätthållits mellan begäran except optionella API-kontexter
  • Inte en lösning på den riktiga backendlogiken - företagsregler , bekräftelse, , och arbetsflöden förblir förenklada

När man ska använda den:

  • Att utveckla framsteg innan baksteg är redo
  • Att skapa realistiska demonstrationer utan tillgång till produktionsdata
  • Att testa UI-komponenter med olika datascenarier
  • Prototypering av API-designer och experiment med reaktionsformer
  • Att lära sig LLM integrationsmönster i .NET

När inte använda den:

  • I produktionsmiljöer som tjänar riktiga användare
  • För att testa autentisering
  • När data måste följa strikta affärsregler eller validering
  • För att lada och testa den faktiska backend prestationen
  • När deterministiska data, ,, som kan reproduceras mellan testrunner är nödvändiga

Feature Dokumentation

För detaljerade vägledningar med arkitekturdiagramer

  • Docker-användningsguidet - Komplett Konfiguration och användning av Docker

    • Vinnigstart med Docker Compose + Ollama
    • Slut exempel med llm
    • Konfigurationsmetoder (env varsM SK1 volym kartläggning, . env-filerMSC4
    • GPU support , multi- baksida
    • Tillverkningsuppfattningar och problemlösning

  • Referencen till Backend API - Complete management endpoint documentation

    • OpenAPI-drivande slutpunkter
    • API: s kontextstyrning
    • gRPC-proto-management
    • SignalR-huber
    • Full request/respons exempel

  • Multiple LLM Backends Guide - Multiple provider support

    • Anslut till Ollama, OpenAI, och LM Studio samtidigt
    • Per-skräv backend-selection via opskrifte /sklära paramer
    • Komplett bakåt-kompatibilitet med gamla konfigurationer
    • Tillhandahållare- specifika exempel och bästa metoder

  • API Kontextführer - NEWM SK1

    • Samlad minne över requester för konsekventa multi-step-Workflows
    • E- kommersiella influenser , stock tickers , spelsituations exempel
    • Tokenshantering och intelligent uttackning
    • Mermaids arkitekturdiagram

  • Limitering av hastighet & Batching Guide - NOWE i vM SK1

    • N-kompletionsstöd för att generera flera reaktionsvarianter
    • Per- slutpunktsstatistiker följd med rörliga medel
    • Tre slagstrategier (Sekvämt,ParallellM SK2 Streaming )
    • detaljerade timingsголовer för prestationstester
    • Perfekt för att testa backoff-strategier och avbrottsscenarier

  • Pluggable Tools & Actions Guide - NOWE i vM SK1

    • MCP-kompatibel arkitektur för utvidgbar verktygsintegration
    • HTTP-verktyg för att kalla externa APIs med autentisering
    • Mock verktyg för att skapa beslutsträd och arbetsflöden
    • Template-substitutioner med stöd för miljövariabler
    • Att spåra verktyg med säkerhetsgränser och att kaska resultat
    • Fasen 1 (Explicit), Fasen

  • gRPC Support Guide - NOWE i vM SK1

    • Uploada .proto-filer för automatisk gRPC-serv mocking
    • Dual support: JSON över HTTP och binär Protobuf
    • LLM-driven realistisk responsgenerering
    • kompletta implementeringsdetails och teststrategier

  • OpenAPI Features Guide

    • Dynamiskt dragning av specifikationer från URLs, filen, eller inline JSON
    • Automatisk slutpunkt generering med vägparameter
    • Om du vill svara på ett exempel med Petstore API
    • SignalR-integration för realen

  • Modulära arkitektoniska exempel

    • REST-omnär, GraphQL-omNur, SignalRM SK4only konfigurationer
    • Optimeringsstrategier
    • Blanda och matcha protokoll

  • SignalR Demo Guide

    • Real-tidsdataströmuppsättning
    • Kontextlivskedjans hantering
    • Clientuppkopplingsexempler

  • Release Notes

    • kompletta versionshistoria
    • Breka förändringar ( ingen sedan vM SK1
    • Migrationsführer

  • Testuppfattning - NOWE i vM SK1

    • Den kompletta dokumentationen
    • 228 tester med detaljerad brytning
    • Performance mätningar och validering
    • Alla kategorier förklarade

  • Implementeringsförteckning - NOWE i vM SK1

    • Formularskropp och upplaad implementeringsdetailer
    • Handlig JSONkonstruktion för .NET 10
    • Memory-säkra file handlingsarchitektur
    • kompletta kodförändringar och logik

Vinnig Start

Installation

huvudpaket:

dotnet add package mostlylucid.mockllmapi

Testverktyg (Optionellt):

dotnet add package mostlylucid.mockllmapi.Testing

Erfordrar flytande API för enkel HttpClient konfiguration i tester. Se tester i sektionen för detaljer.

Vinnig Start med Docker (Empfohlend)

Det snabbaste sättet att starta - inga . NET eller Ollama installering krävs

# Clone the repository
git clone https://github.com/scottgal/LLMApi.git
cd LLMApi

# Start everything with Docker Compose (includes Ollama + llm-model)
docker compose up -d

# Wait for model download (first run only, ~4.7GB)
docker compose logs -f ollama

# Test the API
curl "http://localhost:5116/api/mock/users?shape={\"id\":0,\"name\":\"\",\"email\":\"\"}"

Det är det. APIn körs på: http://localhost:5116 med Ollama baksida.

Se den kompletta Dockerführer för:

  • Konfigurationsoptioner (env vars, volym kartläggningM SK2
  • Med hjälp av olika modeller (gemma3:4bM SK2 mistral
  • GPU: s stöd
  • Tillverkning
  • Troubleshooting

Förberedelser ( Lokal utveckling)

Om du inte använder Docker:

  1. Installera .NET 8.0 SDK eller senare
  2. Installera Ollama och dra en modell: 
    ollama pull ministral-3:3b

Att välja en LLM-modell

Paketet var utvecklats och testat med ministral-3:3b (3B-parametern ), som ger utmärkta resultat för alla egenskaper med väldigt snabb hastighetM SK2 men ändå, det fungerar med alla Ollamas systemMska4kompatibla modellerM Ska5

Rekomenderade modeller

Modell Storleken Rymden МSK3 Kwaltern
ministral-3:3b (default) 3B 4 V 5 Fast 6 Utmärkt 7 8 K 9 KILLER för JSON! snabb , korrekt, stor kontext
gemma3:4b 4 B 2 Fast 3 Bra 4 5 6 Alternativ för lägre 7 slutmaskiner 8
llama3 8B Mediell ♫ Mycket bra ♫
mistral-nemo 12B långsammare SSK3 Utmärkt SSK4 5 K Hög kvalitet, massiva datamängder
mistral:7b 7 B 2 Mittel 3 Mycket bra 4 5 K 6 Alternativ till llm 7 modell 8
phi3 3.8B snabba МSK3 bra
tinyllama 1.1B Väldigt snabbt SSK3 Grundmässigt SSK4 2 K Ultraresurser SSK7 begränsad

REKOMENDAD: Qwen M SK1 Koder (3B) - Perfekt för utveckling

Qwen 2.5 Koder är KILLER för generation JSON - ultra

ollama pull ministral-3:3b

{
  "MockLlmApi": {
    "ModelName": "ministral-3:3b",
    "Temperature": 1.2,
    "MaxInputTokens": 8192
  }
}

Varför är det bra?

  • Exceptionellt snabbt på vilket hårdvara som helst (3-4GB RAM)
  • Högst noggrann generation av JSON i klass -
  • 256K kontextfenster ( hanterar komplexa inbäddade strukturer
  • Speciellt tränad för kod/strukturerade data
  • Perfekt för CI/CD Pipelines och utveckling
  • Minimala hallucinationer jämfört med vanliga modeller

PRODUKTION: MistralM SK1Nemo - Högst kvalitet & Massiva sammanhang

För produktionen-liknande tester med komplexa schemat:

ollama pull mistral-nemo

{
  "MockLlmApi": {
    "ModelName": "mistral-nemo",
    "Temperature": 1.2,
    "MaxInputTokens": 8000
  }
}

Varför är det bra?

  • Högst kvalitet och realistisk datagenerering
  • 128K kontextfenster ( kräver Ollama-konfiguration)
  • Det bästa för komplexa nesterade strukturer och stora datasamlingar
  • Mer kreativ variation i genererade data
  • Beteckning: kräver fler resurser

Modell-Specific Konfiguration

För ministern-3:3b (Empfohlend - avvikelseM SK3

{
  "ModelName": "ministral-3:3b",
  "Temperature": 1.2,
  "MaxContextWindow": 262144   // 256K context window
}

För gemma3:4b eller llama3:

{
  "ModelName": "llm-model",     // or "mistral:7b"
  "Temperature": 1.2,
  "MaxContextWindow": 8192   // Set to model's context window size
}

För mistralt-nemo ( Högt -kvalitetsproduktionM SK3

{
  "ModelName": "mistral-nemo",
  "Temperature": 1.2,
  "MaxContextWindow": 32768, // Or 128000 if configured in Ollama
  "TimeoutSeconds": 120      // Longer timeout for large contexts
}

Nota: Mistral-nemo kräver Ollamas kontextkonfiguration för 128K kontexter.

Var man hittar MaxContextWindow:

# Check model info
ollama show {model-name}

# Look for "context_length" or "num_ctx" parameter
# Example output: "context_length": 8192

För mindre modeller (phi3, tinyllamaM SK2

{
  "ModelName": "tinyllama",
  "Temperature": 0.7         // Lower temperature for stability
}

Varför temperaturen spelar roll:

  • Större modeller (7BM SK1 kan hantera höga temperaturer (1.0-1.5) samtidigt som man håller på med den kehtiva JSON
  • Mindre modeller (<4BM SK1 behöver lägre temperaturer (0.6-0.8) för att undvika
    • Invalid JSON syntax (missing quotes, brackets )
    • Förkortade svar med ellips ("...")
    • Hallucinationer med fält namn eller strukturer
  • lägre temperatur = mer förutsägbar utgång , mindre mångfald
  • Högare temperatur = mer kreativt utgång , mer mångfald ♫ ( ♫ men mer riskfyllda för små modeller ♫

Installation

# RECOMMENDED for development (fastest, most accurate JSON)
ollama pull ministral-3:3b

# Alternative options
ollama pull gemma3:4b       # Good for low-end machines
ollama pull llama3          # General purpose, good balance
ollama pull mistral-nemo    # Highest quality (requires more RAM)

# Alternative options
ollama pull mistral:7b
ollama pull phi3

viktiga begränsningar:

  • Mindre modeller (tinyllama, phi3) fungerar men kan
    • Generera enklare data utan /
    • Kämpa med komplexa GraphQL-sökningar
    • Man behöver fler försök
    • Fungera bäst med enkla frågor och små responsstorlekar
  • Alla modeller kan kämpa med:
    • Väldigt komplexa/ djupt inbäddade GraphQL frågor (>5 djupa nivåer
    • Många fält per objekt (>10 fält
    • Large array requests - Begränsning till 2-5 föremål för säkerhet
  • Om man ser fel om truncated JSON ("...") eller kommentarer ("//"):
    • lägre temperatur till 0.8 eller lägre
    • Förenkla din GraphQL-sökning (färre fält, mindre betingM SK2
    • Föröka MaxRetryAttempts till 5 eller mer

Grundanvändning

Programm .cs:

using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Add LLMock API services (all protocols: REST, GraphQL, SSE)
builder.Services.AddLLMockApi(builder.Configuration);

var app = builder.Build();

// Map mock endpoints at /api/mock (includes REST, GraphQL, SSE)
app.MapLLMockApi("/api/mock");

app.Run();

appsettings.json:

{
  "mostlylucid.mockllmapi": {
    "BaseUrl": "http://localhost:11434/v1/",
    "ModelName": "ministral-3:3b",
    "Temperature": 1.2
  }
}

Det är ', det är , "!, nu frågar vi alla /api/mock/** ge tillbaka intelligenta modelldata.

Auto-forma (Forma minnet)

Att automatiskt upprätthålla konsekventa JSON-strukturer över applikationer till samma slutpunkt

Vad det gör

AutoShape minns JSON-strukturen från första svaret på en ändepunkt och applicerar den automatiskt på alla efterföljande begärningar till samma ändapunkt. (med olika ID' s

  • Konsistenta responsskemas över flera inmatningar
  • Ingen drift i schemat under utvecklingen
  • Förutsägbart API-beteende för tester

Ett snabbt exempel

# First request - generates free-form response
GET /api/mock/users/123
Response: {"id": 123, "name": "Alice", "email": "[email protected]", "role": "admin"}

# Second request - automatically uses same structure
GET /api/mock/users/456
Response: {"id": 456, "name": "Bob", "email": "[email protected]", "role": "user"}

# All subsequent requests use the same schema!
GET /api/mock/users/789
Response: {"id": 789, "name": "Carol", "email": "[email protected]", "role": "manager"}

Konfiguration

Aktiverat standardmässigt i appsettings.json:

{
  "MockLlmApi": {
    "EnableAutoShape": true,              // Default: true
    "ShapeExpirationMinutes": 15          // Default: 15
  }
}

Per-Ansökskontroll

Deaktivera specifika begäran:

GET /api/mock/users/special?autoshape=false

Förnya en dålig form:

# If first response was incomplete, renew it:
GET /api/mock/users/1?renewshape=true
# New response replaces old shape template

Path Normalisering

Alla dessa begäran delar samma form ( som normaliserat till /api/mock/users/{id}):

GET /api/mock/users/123                  # Numeric ID
GET /api/mock/users/abc-456              # Alphanumeric ID
GET /api/mock/users/550e8400-e29b...     # UUID

Nyckliga egenskaper

  • ✅ Aktiverat standardmässigt - Fungerar ur lådan
  • 🔄 Förnyelse av form - Fixera dåliga former med ?renewshape=true
  • ⏱️ Automatiskt-dröjning - Former dröjer efter inactivitet (konfigurerbar)
  • 🎯 Smart normalisering - Skillnade IDs till samma slutpunktsdelensformer
  • 🚫 Uppridda explicit - Erfordra explicit form via query
  • ✨ Fungerar överallt - REST, StreamingM SK2 och GraphQL slutpunkter

När man ska använda

Perfekt för:

  • Frontend utveckling som behöver konsekventa modelldatastrukturer
  • Integrationstest som kräver förutsägbara schema
  • Demonstrationer där datastrukturen inte ska förändras mellan begäran
  • API-prototyper med utvecklande men konsekventa former

Inte nödvändigt när:

  • Med explicita former (somhelst tar precedens
  • Vill ha maximal mångfald i varje respons
  • Testa schema-evolutionsscenarier

Troubleshooting

Former som inte används?

  1. Kontroller EnableAutoShape: true i konfiguration
  2. Bevestig ingen specifik form som är tillhandahållen (fråga/headerM SK2kropp )
  3. Check expiration time (default 15 minutesM SK2

Man måste ändra formen?

GET /api/mock/users/1?renewshape=true

Lösa alla former programmerat:

// Inject AutoShapeManager
autoShapeManager.ClearAllShapes();

För den kompletta dokumentationen, se CLAUDE.md AutoShape sektion.

Testbeläggning: 39 tester som täcker alla självformsfunktioner ✅

Konfigurationsoptioner

📘 Komplett konfigurationsreferens Se Konfigurationsreferensführer för alla alternativ 📄 Hela exempel Se appsettings.Full.json - demonstrerar varenda dag Konfigurationsoption

Genom applikationer.json

{
  "mostlylucid.mockllmapi": {
    "BaseUrl": "http://localhost:11434/v1/",
    "ModelName": "ministral-3:3b",
    "Temperature": 1.2,
    "TimeoutSeconds": 30,
    "EnableVerboseLogging": false,
    "CustomPromptTemplate": null,

    // Token Management (NEW in v1.5.0)
    "MaxInputTokens": 8192,  // Ministral has 256K context

    // Resilience Policies (enabled by default)
    "EnableRetryPolicy": true,
    "MaxRetryAttempts": 3,
    "RetryBaseDelaySeconds": 1.0,
    "EnableCircuitBreaker": true,
    "CircuitBreakerFailureThreshold": 5,
    "CircuitBreakerDurationSeconds": 30
  }
}

Modell- Spesifika tokensgränser: Se LLMApi/appsettings.json för konfigurationsexempler för olika modeller (Llama 3, TinyLlama, MistralMSC3 etcM SK4 Varje modell har olika kontextuella vensterstorlekar | - | justera MaxInputTokens entsprechend.

API Kontexter: För detaljerad information om att använda kontexter för att upprätthålla konsistens mellan begäran API Kontextführer.

Robusthetspolitiker

Ny i v1.2.0: Inbyggt- i Polly resilience-policyr skyddar din application från LLM-serverolyckor

Paketet består av två rädslapatron som är aktiverade standardmässigt:

Exponential Backoff

  • Automatiskt återkommande misslyckade LLM- begäran med exponentiella fördröjningar (1s,
  • Inbegriper kvävningar för att förhindra tundrande hjordproblem
  • Handler kopplingsfehler, tidutbrott , och icke-success statuskoder
  • Default: M SK1 försök med 1 andra basverzögerung

Serkretsbrytare

  • Öffnar efter flera misslyckanden för att förhindra kaskader av misslyckande
  • Blir öppen i en konfigurerad tid innan man tillåter testerbehov
  • Tre tillstånd : Spända ( normalt M SK2 öppet ( avvisande Mska4 halva M Ska5 öppet
  • Default: Öffnar efter 5 kontinuerliga misslyckanden M SK2 stannar öppen i 30 sekunder

Konfiguration:

{
  "mostlylucid.mockllmapi": {
    // Enable/disable retry policy
    "EnableRetryPolicy": true,
    "MaxRetryAttempts": 3,
    "RetryBaseDelaySeconds": 1.0,  // Actual delays: 1s, 2s, 4s (exponential)

    // Enable/disable circuit breaker
    "EnableCircuitBreaker": true,
    "CircuitBreakerFailureThreshold": 5,  // Open after 5 consecutive failures
    "CircuitBreakerDurationSeconds": 30   // Stay open for 30 seconds
  }
}

Logging:

Resilienspolitiken registrerar alla försök att prova igen och omkretsbrytares tillståndsförändringar.

[Warning] LLM request failed (attempt 2/4). Retrying in 2000ms. Error: Connection refused
[Error] Circuit breaker OPENED after 5 consecutive failures. All LLM requests will be rejected for 30 seconds
[Information] Circuit breaker CLOSED. LLM requests will be attempted normally

När man ska justera

  • långsamt LLM? Föröka MaxRetryAttempts eller RetryBaseDelaySeconds
  • Aggressiv återhämtning? Reda CircuitBreakerDurationSeconds
  • Många tillfälliga fel? Föröka CircuitBreakerFailureThreshold
  • Deaktivera för lokala tester? Se båda EnableRetryPolicy och EnableCircuitBreaker till false

Genom kod

builder.Services.Addmostlylucid.mockllmapi(options =>
{
    options.BaseUrl = "http://localhost:11434/v1/";
    options.ModelName = "mixtral";
    options.Temperature = 1.5;
    options.TimeoutSeconds = 60;
});

Customa slutpunktsmönster

// Default: /api/mock/** and /api/mock/stream/**
app.Mapmostlylucid.mockllmapi("/api/mock");

// Custom pattern
app.Mapmostlylucid.mockllmapi("/demo");
// Creates: /demo/** and /demo/stream/**

// Without streaming
app.Mapmostlylucid.mockllmapi("/api/mock", includeStreaming: false);

Till exempel:

Grundkrav

curl http://localhost:5000/api/mock/users?limit=5

Ge tillbaka realistiska användardata som genererats av LLM.

Formular med kroppsuppgifter (NEW i v2.3.0)

HTML-lomagesinlägg:

curl -X POST http://localhost:5000/api/mock/users/register \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "username=john_doe&[email protected]&age=30"

Formulardata konverteras automatiskt till JSON och skickas till LLM för att skapa realistisk respons

Formular med flera värder:

curl -X POST http://localhost:5000/api/mock/posts \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "title=My Post&tags=tech&tags=programming&tags=llm"

Flera värden för samma fält namn konverteras till skivor automatiskt.

Upload requests (NEW i v2.3.0)

Att ladda upp en enda file:

curl -X POST http://localhost:5000/api/mock/photos/upload \
  -F "title=My Photo" \
  -F "description=Beautiful sunset" \
  -F "[email protected]"

Flera filer med formdata:

curl -X POST http://localhost:5000/api/mock/documents/bulk \
  -F "title=Multiple uploads" \
  -F "[email protected]" \
  -F "[email protected]"

Hur file Uploads fungerar:

  • Att innehållet är strömmade genom en 8KB buffer och dumped ( inte lagd i minnet)
  • Bara metadata är bevarade: filename , innehållstyp
  • LLM får file-metadata och genererar ett lämpligt svar
  • minnet-säkra för stora filer (testat med 100MBM SK3

Ett exempel på svaret:

{
  "message": "Files uploaded successfully",
  "uploads": [
    {
      "fieldName": "image",
      "fileName": "photo.jpg",
      "contentType": "image/jpeg",
      "size": 524288,
      "processed": true
    }
  ]
}

Deep Path Nesting (NEW i v2.3.0)

komplexa Nested Paths:

curl "http://localhost:5000/api/mock/v1/api/products/electronics/computers/laptops/gaming/high-end/2024/details?brand=Dell&model=XPS15"

LLM integrerar alla vägsegmenter och sökparameter i en realistisk responsgeneration. Inga praktiska gränser för vägdjupet

Med API-kontext (NEW i v1.5.0)

Använd kontexter för att bibehålla konsistens över flera tillknippade pyyntör:

# Step 1: Create a user
curl "http://localhost:5000/api/mock/users?context=checkout-flow"

# Step 2: Create order for that user (LLM references user from context)
curl "http://localhost:5000/api/mock/orders?context=checkout-flow"

# Step 3: Add payment (LLM references both user and order)
curl "http://localhost:5000/api/mock/payments?context=checkout-flow"

Varje applikation i samma kontext ser de tidigare applikationerna, som garanterar konsekventa IDs , namn M SK2 och datarelationer . Perfekt för flera- stegverk API Kontextführer för kompletta exempel.

Med formkontroll

curl -X POST http://localhost:5000/api/mock/orders \
  -H "X-Response-Shape: {\"orderId\":\"string\",\"total\":0.0,\"items\":[{\"sku\":\"string\",\"qty\":0}]}" \
  -H "Content-Type: application/json" \
  -d '{"customerId":"cus_123"}'

LLM genererar data som matchar din exakta form specifikation.

Streaming (SSE - Server

SSE-strömningar är en del av REST APIn. - gör det bara när man kartlägger slutpunkter

// SSE streaming is automatically available at /api/mock/stream/**
app.MapLLMockApi("/api/mock", includeStreaming: true);

Användning:

curl -N http://localhost:5000/api/mock/stream/products?category=electronics \
  -H "Accept: text/event-stream"

Ge tillbaka Servern-Sent händelser som JSON genereras som token-avM SK2token :

data: {"chunk":"{","done":false}
data: {"chunk":"\"id\"","done":false}
data: {"chunk":":","done":false}
data: {"chunk":"123","done":false}
...
data: {"content":"{\"id\":123,\"name\":\"Product\"}","done":true,"schema":"{...}"}

Ett exempel från JavaScript:

const eventSource = new EventSource('/api/mock/stream/users?limit=5');

eventSource.onmessage = (event) => {
    const data = JSON.parse(event.data);

    if (data.done) {
        console.log('Complete:', data.content);
        eventSource.close();
    } else {
        console.log('Chunk:', data.chunk);
    }
};

Med formkontroll:

curl -N "http://localhost:5000/api/mock/stream/orders?shape=%7B%22id%22%3A0%2C%22items%22%3A%5B%5D%7D"

Den stromande slutpunkten supporterar alla samma egenskaper som vanliga slutpunkter:

  • Formkontroll ( sökparm , nagłównM SK2 eller kroppen)
  • JSON-schema stöd
  • Passformsproppar
  • Alla HTTP-metoder (GET

GraphQL API-mocking

Ny i v1.2.0: Native GraphQL support med query-driven mock data generation

LLMock API inkluderar byggt-in GraphQL-finningspunkts stöd. Till skillnad från REST-finningpunkter där du specifikerar former separat , GraphqL-frågan definierar naturligt den exakta strukturen de förväntar sig M SK3 frågan är formen

En snabb start med GraphQL

GraphQL: s slutpunkt är automatiskt tillgänglig när du kartlägger LLMock API:

app.MapLLMockApi("/api/mock", includeGraphQL: true); // GraphQL enabled by default

Detta skapar en GraphQL slutpunkt vid /api/mock/graphql.

Grundanvändning

Enkel fråga:

curl -X POST http://localhost:5000/api/mock/graphql \
  -H "Content-Type: application/json" \
  -d '{"query": "{ users { id name email role } }"}'

Svaret:

{
  "data": {
    "users": [
      { "id": 1, "name": "Alice Johnson", "email": "[email protected]", "role": "admin" },
      { "id": 2, "name": "Bob Smith", "email": "[email protected]", "role": "user" }
    ]
  }
}

Med variabeler

curl -X POST http://localhost:5000/api/mock/graphql \
  -H "Content-Type: application/json" \
  -d '{
    "query": "query GetUser($userId: ID!) { user(id: $userId) { id name email } }",
    "variables": { "userId": "12345" },
    "operationName": "GetUser"
  }'

Insatta frågor

GraphQL's kraft strålar med inbäddade data

{
  company {
    name
    employees {
      id
      firstName
      lastName
      department {
        name
        location
      }
      projects {
        id
        title
        status
        milestones {
          title
          dueDate
          completed
        }
      }
    }
  }
}

LLM genererar realistiska data som matchar din exakta querystruktur - inklusive alla nesterade förhållanden.

Ett exempel på JavaScript-client

async function fetchGraphQL(query, variables = {}) {
    const response = await fetch('/api/mock/graphql', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ query, variables })
    });

    const result = await response.json();

    if (result.errors) {
        console.error('GraphQL errors:', result.errors);
    }

    return result.data;
}

// Usage
const data = await fetchGraphQL(`
    query GetProducts($category: String) {
        products(category: $category) {
            id
            name
            price
            inStock
            reviews {
                rating
                comment
            }
        }
    }
`, { category: 'electronics' });

Fehler i hantering

GraphQL fel kommer tillbaka i standardformat:

{
  "data": null,
  "errors": [
    {
      "message": "Invalid GraphQL request format",
      "extensions": {
        "code": "INTERNAL_SERVER_ERROR"
      }
    }
  ]
}

Hur det fungerar

  1. Föreläsning av begäran: Abstrahera GraphQL-frågan , variabeler M SK2 och operations namn
  2. Att bygga fort: Senda sökstrukturen till LLM med instruktioner för att generera matchande data
  3. Generera data: LLM skapar realistiska data som exakt matchar sökfält
  4. Räckande respons: Ge tillbaka data i GraphQL format { "data": {...} }

Nyckliga fördelar

  • Ingen formspecifikation behövs: GraphQL-frågan definierar strukturen
  • Typ säkerhets: frågar eksplicitt efter namn efter sökfällor
  • Inbäddade relationer: Naturligt stöd för komplexa, inbäddade datastrukturer
  • Standardformat: Fungerar med vilken GraphQL klientbibliotek som helst
  • Realistiska data: LLM genererar kontextuellt lämpliga data för varje fält

Att testa GraphQL

Använd det inkluderade LLMApi.http file som innehåller 5 ready-toM SK2använda GraphQL exempel :

  • Enkel användarens fråga
  • Fråga med variabler
  • Nesterade fält med rader
  • E-handelskatalog
  • Kompleksa organisationella data

Se den GraphQL exempel i LLMApi.http för kompletta arbetsexempler.

GraphQL Konfiguration

Symbolgränser och modellselektion

GraphQL-responser kan bli stora med djupt inbäddade queryr. För att förhindra JSON-avvikningsfehler GraphQLMaxTokens alternativ:

{
  "MockLlmApi": {
    "GraphQLMaxTokens": 300  // Recommended: 200-300 for reliability
  }
}

Tokengränsregler:

Modell Recommended Max Tokens МSK2 Notar
llm-modell 300-500 ♫ ♫ Den bästa balansen mellan hastighet och komplexitet ♫
mistral:7b 300-500 ♫ ♫ ♫ Handler inbäddade strukturer bra ♫
phi3 200-300 ♫ ♫ ♫ Säg frågorna enkla ♫
tinyllama ♫ 150-200 ♫ ♫ ♫ Använd bara grunda frågor ♫

Varför är lägre bättre:

  • Det genast prioriterar korrekthet över längd
  • lägre gränser tvingar LLM att generera enklare, komplett JSON
  • Högare gränser innebär att risken för kortkortade svar är större. (invalid JSONM SK1
  • Om du ser "Invalid JSON från LLM minska GraphQLMaxTokens

För komplexa nestede frågor:

  1. Använd större modeller (llm -modell, mistralMSC3bM SK4
  2. öka GraphQLMaxTokens till 500-1000
  3. Säg uppsättnings storlekar små (2 items max som standard
  4. Titta på logerna för avvikningsvaror

Ett exempel på konfiguration för komplexa frågor:

{
  "MockLlmApi": {
    "ModelName": "llm-model",           // Larger model
    "GraphQLMaxTokens": 800,          // Higher limit for nested data
    "Temperature": 1.2
  }
}

SignalR Real-Time Data Streaming

LLMock API inkluderar optional SignalR support för kontinuerligt, verkligt - tidlik modelldata generering

  • Tavlansprototyper som kräver live-updater
  • Att testa real-time UI-komponenter
  • Demon med konstant ändrade data
  • WebSocket/SignalR integrationstest

Vinnig Start med SignalR

SignalR fungerar oberoende av varandra - du behöver inte ' behöver inte REST API slutpunkter för att använda SignalR-strömningar

1. Minimal SignalR-only setupM SK2

using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Add SignalR services (no REST API needed!)
builder.Services.AddLLMockSignalR(builder.Configuration);

var app = builder.Build();

app.UseRouting();

// Map SignalR hub and management endpoints
app.MapLLMockSignalR("/hub/mock", "/api/mock");

app.Run();

Optionellt: Lägg till REST API också

Om du också vill ha REST API: s slutpunkter, så kan du lägga till dessa linjer

// Add core LLMock API services (optional)
builder.Services.AddLLMockApi(builder.Configuration);

// Map REST API endpoints (optional)
app.MapLLMockApi("/api/mock", includeStreaming: true);

2. Konfigurera i appsettings

{
  "MockLlmApi": {
    "BaseUrl": "http://localhost:11434/v1/",
    "ModelName": "ministral-3:3b",
    "Temperature": 1.2,

    "SignalRPushIntervalMs": 5000,
    "HubContexts": [
      {
        "Name": "weather",
        "Description": "Weather data with temperature, condition, humidity, and wind speed"
      },
      {
        "Name": "stocks",
        "Description": "Stock market data with symbol, current price, change percentage, and trading volume"
      }
    ]
  }
}

3. Anslut från klient

// Using @microsoft/signalr
const connection = new signalR.HubConnectionBuilder()
    .withUrl("/hub/mock")
    .withAutomaticReconnect()
    .build();

// Subscribe to a context
connection.on("DataUpdate", (message) => {
    console.log(`${message.context}:`, message.data);
    // message.data contains generated JSON matching the shape
    // message.timestamp is unix timestamp in ms
});

await connection.start();
await connection.invoke("SubscribeToContext", "weather");

Hub Kontext Konfiguration

Varje hubkontext simulerar en komplett API-ansökning och genererar data kontinuerligt:

{
  "Name": "orders",                 // Context name (SignalR group identifier)
  "Description": "Order data..."    // Plain English description (LLM generates JSON from this)
  // Optional:
  // "IsActive": true,              // Start in active/stopped state (default: true)
  // "Shape": "{...}",              // Explicit JSON shape or JSON Schema
  // "IsJsonSchema": false           // Auto-detected if not specified
}

Recommended: Använd enkla engelska förklaringar

Låt LLM automatiskt generera lämpliga JSON strukturer:

{
  "Name": "sensors",
  "Description": "IoT sensor data with device ID, temperature, humidity, battery level, and last reading timestamp"
}

LLM genererar automatiskt ett lämpligt JSON-skema från din beskrivning. - inga manuala Former behövs.

Dynamiska Kontextkreationer API

Att skapa och administrera SignalR-kontexter vid starttid med hjälp av administration API:

Att skapa ett sammanhang

POST /api/mock/contexts
Content-Type: application/json

{
  "name": "crypto",
  "description": "Cryptocurrency prices with symbol, USD price, 24h change percentage, and market cap"
}

Svaret:

{
  "message": "Context 'crypto' registered successfully",
  "context": {
    "name": "crypto",
    "description": "Cryptocurrency prices...",
    "method": "GET",
    "path": "/crypto",
    "shape": "{...generated JSON schema...}",
    "isJsonSchema": true
  }
}

Lyssna alla sammanhang

GET /api/mock/contexts

Svaret:

{
  "contexts": [
    {
      "name": "weather",
      "description": "Realistic weather data with temperature, conditions, humidity, and wind speed for a single location",
      "method": "GET",
      "path": "/weather/current",
      "shape": "{...}"
    },
    {
      "name": "crypto",
      "description": "Cryptocurrency prices...",
      "shape": "{...}"
    }
  ],
  "count": 2
}

Nota: Slutpunkten för samman kontexter som konfigureras i appsettings.json med vilka som helst dynamiskt skapade kontexter vid starttidM SK2 Beskrywingar från appsets är inbegripda även om dessa kontexter inte än har blivit dynamiskalt registreradeMSC3

få en specifik kontext

GET /api/mock/contexts/weather

Svaret:

{
  "name": "weather",
  "method": "GET",
  "path": "/weather/current",
  "shape": "{\"temperature\":0,\"condition\":\"string\"}",
  "isJsonSchema": false
}

Lösa Kontext

DELETE /api/mock/contexts/crypto

Svaret:

{
  "message": "Context 'crypto' deleted successfully"
}

Börja Kontext (Komma till slut på data generering)

POST /api/mock/contexts/crypto/start

Svaret:

{
  "message": "Context 'crypto' started successfully"
}

Börjar generera data för en stoppad kontext utan att påverka anslutna klienter.

Stopp Kontext (Pause Data Generation

POST /api/mock/contexts/crypto/stop

Svaret:

{
  "message": "Context 'crypto' stopped successfully"
}

Stoppar att generera nya data men håller kontexten registrerad. Clienter är fortfarande sammankopplade men får inga uppdaterade untils de börjat igen.

Complierade Clientexampla

<!DOCTYPE html>
<html>
<head>
    <script src="https://cdn.jsdelivr.net/npm/@microsoft/[email protected]/dist/browser/signalr.min.js"></script>
</head>
<body>
    <h1>Live Weather Data</h1>
    <div id="weather-data"></div>

    <script>
        const connection = new signalR.HubConnectionBuilder()
            .withUrl("/hub/mock")
            .withAutomaticReconnect()
            .build();

        connection.on("DataUpdate", (message) => {
            if (message.context === "weather") {
                const weatherDiv = document.getElementById("weather-data");
                weatherDiv.innerHTML = `
                    <h2>Current Weather</h2>
                    <p>Temperature: ${message.data.temperature}°F</p>
                    <p>Condition: ${message.data.condition}</p>
                    <p>Humidity: ${message.data.humidity}%</p>
                    <p>Updated: ${new Date(message.timestamp).toLocaleTimeString()}</p>
                `;
            }
        });

        connection.start()
            .then(() => {
                console.log("Connected to SignalR hub");
                return connection.invoke("SubscribeToContext", "weather");
            })
            .then(() => {
                console.log("Subscribed to weather context");
            })
            .catch(err => console.error(err));
    </script>
</body>
</html>

Dynamisk Kontextkreation från gränssnittet

async function createDynamicContext() {
    // Create the context
    const response = await fetch("/api/mock/contexts", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
            name: "stocks",
            description: "Stock market data with ticker symbol, current price, daily change percentage, and trading volume"
        })
    });

    const result = await response.json();
    console.log("Context created:", result.context);

    // Subscribe to receive data
    await connection.invoke("SubscribeToContext", "stocks");
    console.log("Now receiving live stock data!");
}

SignalR Hub-metoder

Den MockLlmHub stödjer de följande metoderna:

SubscribeToContext(string context

  • Abonnerar klienten för att få datauppdateringar för en specifik kontext
  • Klienten kommer få DataUpdate händelser med genererade data
  • Ny i v1.1.0: Automatiskt ökar kontexten's sammanräkning

Abonnement från Kontext(string context)

  • Löser kunderna från ett sammanhang
  • Client kommer inte längre få uppdaterade informationer för den kontexten
  • Ny i v1.1.0: Det minskar automatiskt kontexten's sammanräkning

Erfarenheter som client fått:

DataUpdate - innehåller genererade modelldata

{
    context: "weather",       // Context name
    method: "GET",            // Simulated HTTP method
    path: "/weather/current", // Simulated path
    timestamp: 1699564820000, // Unix timestamp (ms)
    data: {                   // Generated JSON matching the shape
        temperature: 72,
        condition: "Sunny",
        humidity: 45,
        windSpeed: 8
    }
}

Abonnerad - Bekräftelse av ګډون

{
    context: "weather",
    message: "Subscribed to weather"
}

Otillskriven - Bekräftelse på avkommelse

{
    context: "weather",
    message: "Unsubscribed from weather"
}

Konfigurationsoptioner

{
  "MockLlmApi": {
    "SignalRPushIntervalMs": 5000,  // Interval between data pushes (ms)
    "HubContexts": [...]             // Array of pre-configured contexts
  }
}

JSON Schema-stöd

Hubkontexter stödjer både enkla JSON-Former och hela JSON Schema:

Enkel form:

{
  "Name": "users",
  "Shape": "{\"id\":0,\"name\":\"string\",\"email\":\"string\"}"
}

JSON-schema:

{
  "Name": "products",
  "Shape": "{\"type\":\"object\",\"properties\":{\"id\":{\"type\":\"number\"},\"name\":{\"type\":\"string\"},\"price\":{\"type\":\"number\"}},\"required\":[\"id\",\"name\",\"price\"]}",
  "IsJsonSchema": true
}

Systemet detektorar automatiskt JSON-schemat genom att leta efter $schema, type, eller properties fält.

Arkitektur

graph TD
    Client[SignalR Client] -->|Subscribe| Hub[MockLlmHub]
    Hub -->|Join Group| Group[SignalR Group]
    BG[Background Service] -->|Generate Data| LLM[Ollama LLM]
    LLM -->|JSON Response| BG
    BG -->|Push Data| Group
    Group -->|DataUpdate Event| Client
    API[Management API] -->|CRUD| Manager[DynamicHubContextManager]
    Manager -->|Register/Unregister| BG

Komponenter:

  • MockLlmHub: SignalR-hub för att hantera klientuppkopplingar ochabo
  • MockDataBackgroundService: Hostad tjänst som kontinuerligt genererar data
  • DynamicHubContextManager: Thread - säkerhetsadministratör för urlauftids-kontextregistrering
  • HubContextConfig: Konfigurationsmodell för varje datakontext

Använd fall

1. Taskbord-prototyping

// Subscribe to multiple data sources
await connection.invoke("SubscribeToContext", "sales");
await connection.invoke("SubscribeToContext", "traffic");
await connection.invoke("SubscribeToContext", "alerts");
// Now receiving live updates for all three!

2. IoT-simulation

{
  "Name": "sensors",
  "Description": "IoT temperature sensors with device ID, current temperature, battery percentage, and signal strength",
  "Path": "/iot/sensors"
}

3. Finansdata

{
  "Name": "trading",
  "Description": "Real-time stock trades with timestamp, symbol, price, volume, and buyer/seller IDs",
  "Path": "/trading/live"
}

4. Gaming-ledandebord

{
  "Name": "leaderboard",
  "Description": "Gaming leaderboard with player name, score, rank, level, and country",
  "Path": "/game/leaderboard"
}

Kontextlivskedjans hantering

Ny i v1.1.0: Hela livscykelns kontroll över SignalR-kontexter med verkligt monitoring

Varje kontext har följande egenskaper:

  • Isaktiv: huruvida kontexten genererar data
  • sammanfogning: Anzahl av just nu anslutna klienter

Kontexter kan vara i två tillstånd

  • Aktiva: bakgrundstjänster genererar nya data varje SignalRPushIntervalMs (default: 5 sekunderM SK3
  • Stopp: Kontext kvarstår registrerad , klienter stannar uppkopplade M SK2 men inget nytt data genereras

Nyckliga egenskaper:

  • Start/stoppa kontexter utan att avkoppela klienterna
  • Verklig-timmar sammanräkning av anslutningar
  • Statusbänder som visar aktivt/stoppade tillstånd
  • Duplikat av kontextbekämpning
  • Kontexter från appsettings.json dyker upp automatiskt i gränssnittet

Response Caching för SignalR: Ny i v1.1.0: Intelligenta kackerning reducerar LLM-last och förbättrar konsistens

  • Batch förtillfüllning: Genererar 5-10 reaktioner på en gång ♫ ( ♫ konfigurierbart via MaxCachePerKey)
  • Per-Kontext köer: Varje kontext upprätthåller sin egen kass av pre-
  • Yttergrunduppfüllning: Automatiskt återuppfyller kasken när den faller under 50% kapacitet
  • Smarta skeder: Minimeerar LLM sändningar medan data är färska

Detta minskar signifikant LLM-last för höga kontexter, särskilt med flera klienter.

exempel arbetsflöde:

# Create a context
POST /api/mock/contexts
{ "name": "metrics", "description": "Server metrics" }

# Stop data generation (clients remain connected)
POST /api/mock/contexts/metrics/stop

# Resume data generation
POST /api/mock/contexts/metrics/start

# Remove context entirely
DELETE /api/mock/contexts/metrics

OpenAPI / Swagger Mock Generation

Nyhet Automatiskt generera mönster slutpunkter från OpenAPI/Swagger specifikationer! Punktera till vilken OpenAPI som helst | 3.0/ | Swagger | МSK3 | specifikation |( | URL eller file | ) | och biblioteket kommer att skapa mönste slutpunkter för alla definierade operationer

Vinnig Start med OpenAPI

dotnet add package mostlylucid.mockllmapi

Programm .cs:

using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Add OpenAPI mock services
builder.Services.AddLLMockOpenApi(builder.Configuration);

var app = builder.Build();
app.UseRouting();

// Map OpenAPI-based mock endpoints
app.MapLLMockOpenApi();

app.Run();

appsettings.json:

{
  "MockLlmApi": {
    "BaseUrl": "http://localhost:11434/v1/",
    "ModelName": "ministral-3:3b",
    "Temperature": 1.2,
    "OpenApiSpecs": [
      {
        "Name": "petstore",
        "Source": "https://petstore3.swagger.io/api/v3/openapi.json",
        "BasePath": "/petstore",
        "EnableStreaming": false
      },
      {
        "Name": "myapi",
        "Source": "./specs/my-api.yaml",
        "BasePath": "/api/v1"
      }
    ]
  }
}

Det där' det är det ! Alla utgångspunkter från din OpenAPI-specifik är nu tillgängliga som intelligent LLM

Hur det fungerar

  1. Spec Loading: Lader OpenAPI-speckor från URLs eller lokala plier (JSON eller YAML
  2. Schema omvandling: Konverterar OpenAPI-skemas till JSON-formade templater
  3. Endpunktkartläggning: kartlägger automatiskt alla operationer till ASP
  4. LLM Generering: använder LLM för att generera realistiska modelldata som matchar schemat
  5. Path-parameter: Handler bana-parameter som /users/{id} automatiskt

Konfigurationsoptioner

Varje OpenAPI specifikation supporterar dessa konfigurationsoptioner:

egenskap Typ Beschreibung
Name string En unik identifisator för den här specifikationen
Source string URL eller filepath till OpenAPI-specifikationen
BasePath string överrider basenpfad default : använder specifikationen servers[0].url)
EnableStreaming bool Lägg till /stream agtervoegsel för SSE-strömningar (default: falsktM SK2
IncludeTags string[] Generera bara slutpunkter med dessa tag
ExcludeTags string[] Springa över slutpunkter med dessa tag
IncludePaths string[] endast generera dessa vägar ( stödjer wildcards som /users/*)
ExcludePaths string[] Springa över dessa vägar ♫ ♫ ( ♫ stödjer wildcards ♫

avancerade konfigurationsexempler

Filter av tag:

{
  "Name": "petstore",
  "Source": "https://petstore3.swagger.io/api/v3/openapi.json",
  "IncludeTags": ["pet", "store"]
}

Filter genom vägar:

{
  "Name": "api",
  "Source": "./specs/api.yaml",
  "IncludePaths": ["/users/*", "/products/*"],
  "ExcludePaths": ["/admin/*"]
}

Aktivera strömningar:

{
  "Name": "api",
  "Source": "./specs/api.yaml",
  "BasePath": "/api",
  "EnableStreaming": true
}

Att testa OpenAPI-mocks

Given this OpenAPI spec configuration:

{
  "Name": "petstore",
  "Source": "./specs/petstore.json",
  "BasePath": "/petstore"
}

Och en specifikation som definierar GET /pet/{petId} som återvänder en Pet objekt, du kan testa

# Get a pet by ID
curl http://localhost:5116/petstore/pet/123

# Response (generated by LLM based on Pet schema):
{
  "id": 123,
  "name": "Fluffy",
  "category": {
    "id": 1,
    "name": "Cats"
  },
  "photoUrls": ["https://example.com/fluffy.jpg"],
  "tags": [
    {"id": 1, "name": "cute"},
    {"id": 2, "name": "playful"}
  ],
  "status": "available"
}

Modulära användning

OpenAPI-modeller fungerar oberoende av REST

// Just OpenAPI mocks
builder.Services.AddLLMockOpenApi(builder.Configuration);
app.MapLLMockOpenApi();

// Or combine with other features
builder.Services.AddLLMockRest(builder.Configuration);
builder.Services.AddLLMockOpenApi(builder.Configuration);
app.MapLLMockRest("/api/mock");
app.MapLLMockOpenApi();

Ondersteunde Specformat

  • OpenAPI 3.0 (JSON eller YAML
  • OpenAPI 3.1 (JSON eller YAML
  • Swagger 2.0 (JSON eller YAML

Nyckliga egenskaper

  • Automatisk Endpoint Generation: Alla vägar och operationer från spec blir modellera slutpunkter
  • Schema-driven: Reaktionsformer som kommer från OpenAPI-responsschemat
  • Path-parameter: Handler /users/{id}, /posts/{postId}/comments/{commentId}, etcM SK1
  • Flera Speser: Lade och monterade flera API-spetsar samtidigt
  • Smart Filtering: Inbegripa/excludera operationer genom tag eller vägar
  • Streaming-stöd: Optionell SSE-strömning för varje slutpunkt
  • LLM-Spowered: Genererar realistiska , varierade data som är lämpliga för varje schema

Använd fall

  • API- Första utvecklingen: Börja koda mot specifikation innan backend är redo
  • Frontend-prototyping: Att utveckla gränssnitt medan API byggers
  • Integrationstest: Testa klientkod utan verkliga API beroenden
  • Demomiljöer: Presentcase-apps utan produktionsAPI-utgång
  • Contrattestning: Verifiera att klienter hanterar alla skemasvariationer korrekt
  • Lade tester: Generera realistiska tester på skala

Begränsningar

  • För närvarande stödjer bara reaktionsschemas (ansökande bekräftelse inte utövad)
  • säkerhetsplaner ignoreras ( inget autentiserat krävs )
  • Bara application/json innehållstyp unterstützt för svar
  • Path-parametervärdena är inte validerade mot schemabegränsningar

Att testa OpenAPI-Management

Den inkluderade management.http file innehåller omfattande exempel på alla ledningsgränspunkter:

Spec-Management:

  • Lade upp specifikation från URL (Petstore, GitHub APIM SK2 etc .)
  • Lade specifikation från den lokala lêern
  • Lade specifikation från rå JSON/YAML
  • Lyssna alla laddade specifikationer
  • få specifika detaljer med slutpunkter
  • Lada tillbaka specifikationen (refresh från källan)
  • Lösa spec

Endpunkttesting:

  • Testa GET slutpunkter med vägparameter
  • Testa POST/PUT/DELETE slutpunkter
  • Testa slutpunkter med sökparameter
  • Testa flera slutpunkter i sekvens

avancerade arbetsflöden:

  • Lade flera specifikationer samtidigt
  • Vergleicha OpenAPI-modeller mot vanliga modeller
  • Batchoperationer
  • Ett problem med exemplet

Ett exempel från ledning.http:

### Load Petstore API
POST http://localhost:5116/api/openapi/specs
Content-Type: application/json

{
  "name": "petstore",
  "source": "https://petstore3.swagger.io/api/v3/openapi.json",
  "basePath": "/petstore"
}

### Test an endpoint
POST http://localhost:5116/api/openapi/test
Content-Type: application/json

{
  "specName": "petstore",
  "path": "/pet/123",
  "method": "GET"
}

Se den kompletta ledning.http file for 20+ ready

Demo-applikationer

Paketet består av kompletta demoapplikationer med interaktiva gränssnitt med full kontextuell ledning:

Windows Desktop Client (LLMockApiClient/) — WPF-användbar ♫ ♫ ( ♫ I utvecklingen ♫

⚠️ STATUS för utveckling: Man håller just nu på att utveckla Windows-desktopclienten . Trots att många egenskaper är funktionella M SK2 kan vissa egenskaper vara ofullständiga eller undersökta förändringar . Används för tester och utvecklingsförämpningar MSC4

En komplett WPF-desktopapplikation för att interagera med LLMock API:

Features:

  • Tavlansbord: Verklig-tidskonnektionsstatus och systemövervakning
  • SignalR Real-Time: skapa kontexter och byta upp till live dataströmmar
  • SSE Streaming: Tre strömningarsmodi
  • OpenAPI-administratör: Lade specifikationer från URL
  • gRPC Services: Uploada .proto-filer, test gRPC-metoder
  • Spela med APIs: Interaktiv HTTP-testningsplats
  • Multi-Backend Support: Konfigurera och byta mellan flera backends
  • Trafikmonitorer: Livlig HTTP-ansökning/responslogg
  • Dark/Licht Theme: Skaka mellan tema med smidiga övergångar

Dokumentation: LLMockApiClient README

Perfekt för: Desktoptestning arbetsflöden , visuell API-exploration, utveckling och debugging

Web-baserade demo

SignalR Demo (/) ♫ — ♫ Real ♫ ♫- ♫ Tidsdataströmningar med en administrationsgränssnitt

Ny i v1.1.0: Förstärkt 3-column-レイアウト med full kontextlivscykel-management

Features:

  • Skep Kontextpanel: Ge enkla engelskabeskrivningar , systemet genererar ett lämpligt JSON-skema
  • Aktiva Kontextpaneler:
    • Livlista av alla kontexter med statusbeteckningar (Aktivt /Stoppt)
    • Automatiskt visar kontexter från appsettings.json vid startup
    • Verklig-timeuppkopplingsberäkning för varje kontext
    • Per-Kontextkontroller: AnslutaM SK2 Avkoppela , Starta~, Stoppa~, Lösa
    • Auto-refresh på ändringar
  • Live Data Panel: Verklig-tidsaktualiseringar från inskrivna kontexter | ( | varenda |5 | sekunder | МSK4
    • JSON syntax Highlighting: vackra mörka -medida skärm med färg
    • Nyckeln (rött ),strängar | | ( | grönt | ), | siffror |( | orange | МSK5 | booleans |
    • Klara, läsbar format med rätt tidstamp-display
    • Inga externa beroenden - lättformade gjorda | - | i markering

Quick-Startexamples: Ett-klicka på knapparna för 5 föreM SK2konfigurerade scenarior :

  • IoT-sensorer: Temperatursensorer med apparatidentifikationen
  • Börsen: verkligt - tidsprix med ticker , pris M SK3 förändring procentuell
  • E-handelsord: Orders with IDM SK1 customer , items array, statusMSC4 total
  • Servermetrik: övervakning av data med hostnamen , CPU, minneM SK3 disk
  • Gamings ledande bord: Statistik med namn på spelare , poäng M SK2 klassificering

Perfekt för: Dashboards , live monitoring, IoT-simulationer, realM SK3 tidnydmattningsramarMSC4 prototypisering

SSE Streaming demo (/Streaming) — Fortskridande generation av JSON

Ny i v1.1.0: Quick-starta exempelknappar för direkt sändning

Features:

  • Konfigurera HTTP-metoden , väg, och optionell JSON-form
  • Titta på hur JSON genereras i realtid
  • Live statistik: stycketalkollering , tidningM SK2 datastorlek
  • Anslutningsstatusindikatorer

Quick-Startexamples: Ett-klicka på knapparna för 4 strömscenarior

  • Userlist: Array of user objects with ID , name, email
  • Produktkatalog: Lagerbestand med Artikelnummer, namn , prisM SK3 lagerstatus
  • Orderdetails: Insatta order med kundeninformation och element-arrang
  • väderdata: Current conditions with temperatureM SK1 humidity , wind speed

Perfekt för: Bevakning av LLM-generationen , ontlösningsformer, förståelse av strömbeteendet, test SSE

OpenAPI-administratörs demo (/OpenApi) — Dynamiskt Speklagning

Nyhet Interaktivt OpenAPI specifikationsmanagement med reala versioner

Features:

  • Lade specifika Dynamiskt: Från URL eller klistra rå JSON/YAML direkt i webbläsaren
  • Aktualiseringar av tid: SignalR
  • Endpoint Discovery: Automatisk extraktion av alla operationer från specifikationen
  • In-Browsertesting: Testa vilken ändpunkt som helst med en enda klix , se LLM | - | skapade modelldata
  • Livkedjanshantering: Lade , ladda tillbaks, löser specifikationer utan att starta servern igen
  • vackra gränssnitt: färg - kodade HTTP-metoder
  • Verbinding status: Live-indikator visar SignalR-uppkopplings tillstånd
  • Omgripande hjälp: Inlinedokumentation och exempel URLs

Quick-Startexamples:

  • Lade Petstore API från URL
  • Släpp Custom OpenAPI JSON
  • Se alla slutpunkter från specifikationen
  • Testa slutpunkter direkt på sidan
  • Se realistiska modelldata skapade av LLM

Perfekt för: API-prototyping , framdrivande av gränssnittet, kontrakttestning M SK2 specifikvalidering , demo

kör demonstrationen:

cd LLMApi
dotnet run

Navigera till:

  • http://localhost:5116 - SignalR real - tiddataströmning med administrationsgränssnitt
  • http://localhost:5116/Streaming - SSE progressiv generation
  • http://localhost:5116/OpenApi - OpenAPI-spec-manager med dynamiskt laddande

Alla demoer inkluderar:

  • Den komplexa inlinedokumentationen
  • Interaktiva quick-start exempel
  • Kodsnippet för integration
  • Statusindikatorer för tid
  • Kontroller för hela livscykeln

avancerade egenskaper

Response Schema Echo (Form ) Export

Du kan optionellt få den mellanvaran att återskapa den JSON-formaden/schema som användes för att generera den modellresponsen

Konfiguration:

  • Option: InbegripaFormInResponse (bool , felaktigt falskt
  • Per-bequest override: add query parameter includeSchemaMSC2true M SK3or 1)
  • Påskrift utsläppt: XM SK1Response-Schema | ( | endast när en form och storlek är tillhandahållna |≤ | МSK5 | bokstäver
  • Streaming: det slutliga SSE-eventet inkluderar ett schema-fält när det är aktiverat

exempel:

  • Aktivera globalt (appsettings.jsonM SK2
{
  "mostlylucid.mockllmapi": {
    "IncludeShapeInResponse": true
  }
}
  • Aktivera per begäran (överrider config):
curl "http://localhost:5000/api/mock/users?shape=%7B%22id%22%3A0%2C%22name%22%3A%22string%22%7D&includeSchema=true"

Svaret inkluderar opskrifte:

X-Response-Schema: {"id":0,"name":"string"}
  • Streaming: slutakten innehåller schemafältet när det är aktiverat
...
data: {"content":"{full json}","done":true,"schema":{"id":0,"name":"string"}}

Märkter:

  • Om inget mönster fanns tillgängligt (med hjälp av en fråga/koppenM SK2kroppen ), så är koppen inte tillsatt
  • Väldigt stora former (> 4000 bokstäver | ) | är inte tillskrivna i huvudet för att undvika problem med transporten |, | men normal respons fortsätter

Använd fall:

  • Client-sidan TypScript-typ generering
  • API-dokumentation och validering av schema
  • Debugging av formanalys
  • Runtime-validering

Custom prompt-templates

Oorskryf de standardintrycken med din egen

{
  "mostlylucid.mockllmapi": {
    "CustomPromptTemplate": "Generate mock data for {method} {path}. Body: {body}. Use seed: {randomSeed}"
  }
}

Möjliga platshalter:

  • {method} - HTTP-metoden
  • {path} - Full request path with query string
  • {body} - Insöksorgan
  • {randomSeed} - Genererade slumpmässiga frön
  • {timestamp} - Unix-timmar
  • {shape} - Specifikation för form om tillhandahållen

Fehlersimulation

Testa din klient's handling av fel med komplexa felsimulationsskapaciteter

Fyra sätt att konfigurera fel ( i precedensordning

  1. Fråga-parameter (höjsta precedens

Väldigt: sökparametervärden måste vara URL %20, & blir %26, : blir %3A, etcM SK1

# Properly encoded (spaces as %20)
curl "http://localhost:5000/api/mock/users?error=404&errorMessage=Not%20found&errorDetails=User%20does%20not%20exist"

# More complex example with special characters
# Decoded: "Invalid input: email & phone required"
curl "http://localhost:5000/api/mock/users?error=400&errorMessage=Invalid%20input%3A%20email%20%26%20phone%20required"
  1. HTTP-Header:
curl -H "X-Error-Code: 401" \
     -H "X-Error-Message: Unauthorized" \
     -H "X-Error-Details: Token expired" \
     http://localhost:5000/api/mock/users
  1. Form JSON (användande $error egendom):
# Simple: just status code
curl "http://localhost:5000/api/mock/users?shape=%7B%22%24error%22%3A404%7D"

# Complex: with message and details
curl "http://localhost:5000/api/mock/users?shape=%7B%22%24error%22%3A%7B%22code%22%3A422%2C%22message%22%3A%22Validation%20failed%22%2C%22details%22%3A%22Email%20invalid%22%7D%7D"
  1. Benomfattande organ (användande error egendom):
curl -X POST http://localhost:5000/api/mock/users \
  -H "Content-Type: application/json" \
  -d '{
    "error": {
      "code": 409,
      "message": "Conflict",
      "details": "User already exists"
    }
  }'

Frågliga responsformat:

Regular/Streaming slutpunkter :

{
  "error": {
    "code": 404,
    "message": "Not Found",
    "details": "Optional additional context"
  }
}

GraphQL slutpunkt:

{
  "data": null,
  "errors": [
    {
      "message": "Not Found",
      "extensions": {
        "code": 404,
        "details": "Optional additional context"
      }
    }
  ]
}

SignalR-Fehlersimulation:

Konfigurera fel i SignalR-kontexter för att testa real

{
  "HubContexts": [
    {
      "Name": "errors",
      "Description": "Error simulation stream",
      "ErrorConfig": {
        "Code": 500,
        "Message": "Server error",
        "Details": "Database connection lost"
      }
    }
  ]
}

Eller dynamiskt via administrationsAPI:

curl -X POST http://localhost:5000/api/management/contexts \
  -H "Content-Type: application/json" \
  -d '{
    "name": "errors",
    "description": "Test errors",
    "error": 503,
    "errorMessage": "Service unavailable",
    "errorDetails": "Maintenance in progress"
  }'

Ondersteunde HTTP statuskoder:

Paketet innehåller standard meddelanden för vanliga HTTP statuskoder:

  • 4xx Clientfel: 400 | | ( | Okej begäran | МSK3 | 401 |( | Unauthoriserad | Lågsam | lågstad | 11 | Misslevd | 12 | 13 | 14 | Metod inte tillåten | 15 | 16 | 17 | Inställningstid | 18 | 19 | 20 | Konflikt | 21 | 22 | 23 | Processlös subjekt | 24 | 25 | 26 | Alltför många begäran
  • 5xx Server fel: 500 | | Internal Server-Fehler

Passforms meddelanden och detaljer överrider de standarden.

Använd fall:

  • Testa klients repetitionslogik och exponentiell backoff
  • Verifiera fel meddelandet i gränssnittet
  • Test autentisering/autoriseringsflöden
  • simulera hastighetsbegränsande scenarior
  • öva eleganta nedbrytningsmönster
  • Testa felloggning och övervakning

Se LLMApi/LLMApi.http för omfattande exempel på alla felsimulationsmetoder.

Flera instanser

Mounta flera mock APIs med olika konfigurationer:

// Development data with high randomness
builder.Services.Addmostlylucid.mockllmapi("Dev", options =>
{
    options.Temperature = 1.5;
    options.ModelName = "llm-model";
});

// Stable test data
builder.Services.Addmostlylucid.mockllmapi("Test", options =>
{
    options.Temperature = 0.3;
    options.ModelName = "llm-model";
});

app.Mapmostlylucid.mockllmapi("/api/dev");
app.Mapmostlylucid.mockllmapi("/api/test");

Specifikation för form

Tre sätt att kontrollera reaktionsstrukturen:

  1. Påskrift (kommande X-Response-Shape: {"field":"type"}
  2. Fråga-param: ?shape=%7B%22field%22%3A%22type%22%7D (URL
  3. Kroppsfält: {"shape": {...}, "actualData": ...}

Att kassera flera svar via form

Du kan instruera mellanvarat att förbereda och kassera flera olika reaktionsvarianter för en specifik begäran, genom att lägga till ett speciellt fält inuti formens objekt.

  • Cache-kylten kommer från HTTP: s metod + bana ( inbegripande frågeställning | ) | + | den sanitiserade formen ♫ ( | med |$ | cachen tagits bort ♪ ) | genom Systemet ♫
  • Till och med N-responser tar man fram från LLM och lagrar dem i minnet - ( uppkopplade av MaxCachePerKey i volymenten
  • De efterföljande icke-- requesterna för samma nyckel skickas från en slutande kö.
  • Streaming slutpunkter är inte cacherade.

exempel

  • Headerform: X-ResponseM SK1Formen: {"$cacheMST4orderIdM ST5string[{"

  • kroppsform: { " "$cache " "KunstmänniskorM SK1 { ♫ ♫ "id": | ♫ "items": [ { "sku": ♫ ♫ " ♫ string ♫ " } }

  • Query param (URL-encodedM SK2 ?, form, =%7, B, SSK2, kass, %22%3, A, M SK4, C, MST5, användar, MSC6, A

Konfiguration

  • MaxCachePerKey (int

Beteckningar

  • Men ledtråden "$cache" är borttagen från formen innan den skickas till LLM
  • Om "$kassring" är utelämnad eller 0, så beter applikationen sig som innan ( inga kassring
  • Cached varianter hållers i-memory för appens livstid ; återstart löser cachen.

Testing

Testing Utilities Package (NEW!)

mestlucid.mockllmapi.Testing - En NuGet-kommande paket som gör det ännu enklare att testa med modellens API

dotnet add package mostlylucid.mockllmapi.Testing

Ett kort exempel:

using mostlylucid.mockllmapi.Testing;

// Create a configured HttpClient for testing
var client = HttpClientExtensions.CreateMockLlmClient(
    baseAddress: "http://localhost:5116",
    pathPattern: "/users",
    configure: endpoint => endpoint
        .WithShape(new { id = 0, name = "", email = "" })
        .WithCache(5)
        .WithError(404) // Simulate errors easily
);

// Use in your tests
var response = await client.GetAsync("/users");
var users = await response.Content.ReadFromJsonAsync<User[]>();

Nyckliga egenskaper:

  • Flytande API: Enkel konfiguration med WithShape(), WithError(), WithCache(), etcM SK1
  • HttpClient integrering: Fungerar problemlöst med HttpClient och IHttpClientFactory
  • Flera slutpunkter: Konfigurera olika beteenden för olika vägar
  • Fehlersimulation: Testerrorbehandling med olika statuskoder
  • Streaming-stöd: Test SSE-strömning slutpunkter
  • beroende injection: Inbyggt- i stöd för inskrivna och namngeda klienter

Konfigurationsexempler:

// Multiple endpoints with different configurations
var client = HttpClientExtensions.CreateMockLlmClient(
    "http://localhost:5116",
    configure: handler => handler
        .ForEndpoint("/users", config => config
            .WithShape(new { id = 0, name = "", email = "" })
            .WithCache(10))
        .ForEndpoint("/posts", config => config
            .WithShape(new { id = 0, title = "", content = "" })
            .WithStreaming()
            .WithSseMode("CompleteObjects"))
        .ForEndpoint("/error", config => config
            .WithError(500, "Internal server error"))
);

// Dependency Injection support
services.AddMockLlmHttpClient<IUserApiClient>(
    baseApiPath: "/api/mock",
    configure: handler => handler
        .ForEndpoint("/users", config => config.WithShape(...))
);

Hur det fungerar: Den MockLlmHttpHandler är en DelegatingHandler som intercepterar HTTP- begäran och automatiskt applicerar din konfiguration via query-parameter och opskrifte innan den skickas vidare till en modell API. Det betyder att du kan använda HttpClient instanser i dina tester medan du kontrollerar modellbeteende deklarativt.

Se den Testande paket README för komplett dokumentation och exempel.

HTTP-Dateitestning

Använd det inkluderade LLMApi.http file with:

  • Visual Studio / Rider HTTP-client
  • VS Code REST Client-extension
  • Vilkenही HTTP-client som helst

Unittests

Projektet inkluderar komplexa unittestar:

# Run all tests
dotnet test

# Run with detailed output
dotnet test --verbosity detailed

Omfattningen av tester (228 tester, 100% passgrad

  • Kroppsläsning ( tomt , JSON innehåll, lomakkropparM SK3 uppläppning av filen
  • Formkroppsanalys (enliga värden , flera värden
  • Data från flera delar (filer-metadata , blandlade fält och plier)
  • JSON flyr (citat, bakstankarM SK2 nya linjer , affischer
  • Inhaltsextraktion (OpenAI-formatet , komplext nested JSON
  • Handlig JSONkonstruktion (formdata, skivorM SK2 inbäddade strukturer )
  • Extraktion av form (sökningsparam , nagłówn, kroppsfältetM SK3 förekomstenMSC4
  • Vinnig skapande (, slumpmässighet, ,, inklusion av form, M SK2, strömmodi, )
  • Byggnader som kräver (temperatur
  • Randfall (invalid JSON
  • Integrationstest (full HTTP-flödet , bidrag till formen M SK2 upplägningar av filen , djupa vägar

Ny i v2.3.0:

  • FormBodyHandlingTests.cs - 12 tester för formkroppsanalys och JSONkonstruktion
  • JsonHandlingTests.cs - 25 tester för JSON-utsvärmning, extraktionM SK3 och randprov
  • Integrationstests.cs - Integreringstest-framework för full HTTP endpoint testing

Se EST_SUMMARY.md för komplett testdokumentation och omfattningsmått

Arkitektur

Se Arkitektur överblick ovanför systemdiagrammet och komponentbeschreibungen på hög nivå

Den detaljerade begäranströmmen

sequenceDiagram
    participant C as Client
    participant A as LLMApi
    participant H as AutoApiHelper
    participant O as Ollama
    participant M as llm-model

    C->>A: GET/POST/PUT/DELETE /api/auto/**
    A->>H: Extract context (method, path, body, shape)
    H->>H: Generate random seed + timestamp
    H->>H: Build prompt with randomness
    H-->>A: Prompt + temperature=1.2
    A->>O: POST /v1/chat/completions
    O->>M: Run inference
    M-->>O: Generated JSON
    O-->>A: Response
    A-->>C: JSON Response

Flöd för formkontroll

flowchart TD
    Start[Request Arrives] --> CheckQuery{Shape in<br/>Query Param?}
    CheckQuery -->|Yes| UseQuery[Use Query Shape]
    CheckQuery -->|No| CheckHeader{Shape in<br/>Header?}
    CheckHeader -->|Yes| UseHeader[Use Header Shape]
    CheckHeader -->|No| CheckBody{Shape in<br/>Body Field?}
    CheckBody -->|Yes| UseBody[Use Body Shape]
    CheckBody -->|No| NoShape[No Shape Constraint]

    UseQuery --> BuildPrompt[Build Prompt]
    UseHeader --> BuildPrompt
    UseBody --> BuildPrompt
    NoShape --> BuildPrompt

    BuildPrompt --> AddRandom[Add Random Seed<br/>+ Timestamp]
    AddRandom --> SendLLM[Send to LLM]

    style UseQuery fill:#4CAF50
    style UseHeader fill:#4CAF50
    style UseBody fill:#4CAF50
    style NoShape fill:#FFC107

Projekt:

  • mostlylucid.mockllmapi: NuGet paketbibliotek
  • LLMApi: Demo-applikation
  • LLMApi.Tests: xUnit testsuite (228 tester | | - |

Varför använda mestlucid.mockllmapi?

  • Rapid Prototyping: Frontend utveckling utan att vänta på baksidan
  • Komplett HTTP-stöd: JSON
  • konsekventa arbetsflöden: API-kontexter upprätthåller realistiska relationer
  • Demor: Verka realistiska dataflöden utan hårdkoderade fixeringar
  • Testing: Generera varierade testdata för randfall - eller konsekventa data med kontexter
  • minne-säkra: Uploader laddade upp och dumpade ♫ ♫ - ♫ testat med ♫ МSK2 ♫ MB ♫
  • API-design: Försök reagerande former innan vi implementerar
  • Att lära sig: exempel på LLM integrering i .NET minimala APIs
  • Noll underhåll: Ingen databas , inget tillstånd M SK2 inga modelldata-filer att underhålla
  • Flexibel: Använd vilken kombination som helst av REST
  • Tillverkning-Ready: 228 tester M SK2 | | 100% | godkäntnadsgrad

Att bygga NuGet-paketet

cd mostlylucid.mockllmapi
dotnet pack -c Release

Paketet kommer att finnas i bin/Release/mostlylucid.mockllmapi.{version}.nupkg

Att bidra

Det här är ett exempel på ett projekt som visar LLM

Licens

Detta är fri och obekväm programvara som släppts i den offentliga Domainen. Se LICENSE för detaljer eller besök utan tillstånd.org.

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.