LLMApi-:-Verwendung lokaler LLMs zur automatischen Simulierung von APIs in ASP..-NET Core MinimalAPI (Deutsch (German))

LLMApi-:-Verwendung lokaler LLMs zur automatischen Simulierung von APIs in ASP..-NET Core MinimalAPI

Sunday, 02 November 2025

//

53 minute read

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

Einleitung

Eine meiner konstanten Obsessionen ist Beispieldaten...... es ist ein oft ärgerlicher Aspekt der Entwicklung von Systemen, die Sie den Fang haben.... von Daten benötigen, um die Funtionalität beim Entwickeln des Systems zu testen. In Kombination mit meiner aktuellen Liebe zu ' assistiert ' , das Kodieren von zufälligen Ideen es führte ' , um die ceation eines kleinen LLM aktiviert Testdatengenerator zusammen mit einem Nuget-Paket mit einer Middleware, die simulierte API-Antworten mit einem API erzeugen können

NuGet NuGet

Sie können die GitHub hier für das Projekt – alle öffentlichen Bereiche usw. –

Begriff

Wie bei einer Menge von "-AI Assisted-"-Kodierung Ideen begann es mit einer Idee über die Simulation der Ausgabe mit LLMs. .-Ich arbeitete an einem anderen Projekt.LucidForumsEin urkomisch dysfunktionales selbstbevölkertes LLM-basiertes Forum-Experiment und LLMs sind wirklich gut, wenn ein wenig langsames ) bei der Erzeugung von Probendaten so Was ist, wenn Ich könnte sie verwenden, um jede API zu simulieren.

Anforderungen

  1. Es sollte einfach sein, in einer ASPA.-NET Core App zu implementieren.
  2. Die Daten sollten ziemlich realistisch sein.
  3. Die Daten sollten zufällig sein.
  4. Es kann JSON akzeptieren, die dem LLM sagen, wie die Antwort sein sollte.
  5. Es kann lokale Open Source LLMs verwenden
  6. Es sollte frei sein, Nuget-Kontrolle zu verwenden

Dies ist, was ich kam mit .. .I' .ll fügen Sie mehr Details auf dem Denken hinzu, wie ich hinzufügen mehr Funktionalitäten ?. . Es ist wirklich ordentlich ' funktioniert und schneller als gefürchtet I' .

Zukünftige Ergänzungen werden wahrscheinlich Caching beinhalten, falls Sie schneller perf-.-

Hier ist das Readme für das Paket automatisch eingeklemmt

Meistlucid-.-mockllmapi

Was es tut Eine produktionsbereite ASP...NET Core Spoting-Plattform zur Generierung realistischer Mock API-Antworten mit LLMs...

Warum Sie es verwenden Fügen Sie intelligente Mock-Endpunkte zu jedem Projekt mit geraden Linien des Codes hinzu... keine Datenbanken... keine festkodierten Vorrichtungen... keine Wartung...

NuGet NuGet GitHub-Freigabe Lizenzierungsverbot

Companion-Paket - : Hauptsächlichlucid-.-Mockllmapi-.-Testing Testen von Dienstprogrammen mit fließender HttpClient-Integration

Wie man diese README liest

Diese README ist durch Design umfassend Wählen Sie Ihren Pfad

Was ist die neue Version von -?

Letzten Monat Automatische JSON-Strukturkonsistenz über Endpunktaufrufe hinweg V. 2.5.0:- Sicherheitsverbesserungen: Unterstützung für das Abschneiden von Serialisierungsabhängigkeiten V. 2.3.0:- Full content type support Formularaufbauten ,-Datei-Uploads Umfassendes Testen von MS K3-Tests V. 2.2.0:- Pluggable Tools für die API-Integration - , , vor der Konfiguration von REST APIs - automatischer Kontextspeicherablauf V. 2.1.0:- Ratenbegrenzung: ,-Batching, ,-n---Komplettierungen mit mehreren Ausführungsstrategien

Click for detailed v2.5.0 feature breakdown

Details zur Version

SchwerpunktSicherheitsverbesserungen und Unterstützung für die AOT-/-Trimmung durch Entfernen von Serialisierungsabhängigkeiten.

Unterstützung für das Trimmen von / Alle Reflektionen entfernt, auf - basierende Serialisierungsabhängigkeiten entfernt

  • Ausgeschieden System.Text.Json Reflektionsnutzung
  • Manuelle JSON-Konstruktion in der gesamten Codebase
  • Volle Kompatibilität mit AOT und Trimmung
  • Keine Probleme mit der Auflösung des Laufzeittyps
  • Kleinere binäre Größe und verbesserte Startleistung

Verbesserte Sicherheit Umfassende Sicherheitsverbesserungen

  • Entfernt alle Reflection-basierte Serialisierung, die Typinformationen aussetzen könnte
  • Eliminierte potenzielle Inferenz-Schwachstellen
  • Sicherere JSON-Handhabung mit expliziten Typenbeschränkungen
  • Reduzierte Angriffsfläche für Serialisierungs-basierte Exploits
  • Besserer Schutz vor Deserialisierungsangriffen

Leistungsoptimierungen Verbesserte Runtime-Performance:

  • Schnellere JSON-Konstruktion ohne Reflexion über Kopf
  • Reduzierte Speicherzuweisungen
  • Bessere Cache-Lokalität
  • Verbesserte Startzeit für getrimmte Anwendungen
  • Geringere Speicherabstände

Kompatibilität Volle Unterstützung für . NET Vorschau-Builds

  • Manuelle JSON-Konstruktion durchweg, um Reflexionen zu vermeiden
  • Alle Funktionen getestet und arbeiten auf -.-NET-Vorschau baut
  • Keine kaputten Änderungen an bestehenden Funktionen

Verbesserung der Testergebnisse Verstärkte Testabdeckung

  • Zusätzliche Tests für AOT-/-Trimmungsszenarien
  • Sicherheitstests mit --fokussierter Einheit
  • Leistungsvergleichstests
  • Passrate mit allen neuen Tests

Siehe TEST-_-SUMMARY-.-md und UMSETZUNG, für vollständige Details

Click for detailed v2.3.0 feature breakdown

Details zur Version

SchwerpunktKomplette Inhaltstyp-Unterstützung für alle gängigen HTTP-Request-Formate, vollständig abwärtskompatibel mit v-2.2.0.

Form Körper Unterstützung Volle Unterstützung für application/x-www-form-urlencoded Inhaltstyp: .-Einzel- und Mehrfachwerte: ,-Automatische JSON-Konvertierung: ,-Manuelle Konstruktion für .-NET Kompatibilität: .-Kompatibilität: Perfekt zum Testen von HTML-Formularen und traditionellen Web-Apps:.-

Unterstützung für das Hochladen von Dateien Volle Unterstützung für multipart/form-data Einschließlich Dateiuploads.-Speicher--sicheres Streaming (8-KB-Puffer),-Metadatenextraktion M(-Dateiname,-Größe,-Inhaltstyp),-Mischformfelder und Dateien.-Inhalt wird abgeladen, um Speicher aufblähen. zu vermeiden

Beliebige Pfadlängen Unterstützung für tiefe Pfad-Nistungen über {**path} catch---all-Routing - .-Test mit tiefen Pfaden und komplexen Query Strings getestet - . - Keine praktische Begrenzung der Pfadtiefe bis zu ASP-MSC5-NET-Core-Standards

Umfassende Test-Suite 228-Tests neue )-Test mit allen Funktionen .-Formkörperparsing Tests ),-JSON-Handling Tests),-Integrationstests für vollständige HTTP-Workflows.-Test-Passrate ,-Nullregressionen .-Test

Kompatibilität Alle Funktionen getestet und arbeiten an .. NET Vorschau-Builds ?. ?

Siehe TEST-_-SUMMARY-.-md und UMSETZUNG, für vollständige Details

Click for detailed v2.2.0 feature breakdown

Details zur Version

SchwerpunktPluggable Tools für die API-Integration: ,, vor der Konfiguration von REST APIs: , und intelligentem Kontextspeicher: ., vollständig rückwärtskompatibel mit v-2.1.0.,

Pluggable Tools - Aktionssystem für & Rufen Sie externe REST-APIs oder Kettenmockendpunkte auf, um realistische Workflows und Entscheidungsbäume zu erstellen. Vollständige Dokumente

Konfigurierte REST-APIs Definieren Sie komplette API-Konfigurationen einmalig ,, , Anruf mit Namen , . , Form oder OpenAPI Spec Reference , , , gemeinsam genutztes Kontextmanagement , Werkzeugintegration , . , siehe appsettings.Full.json für vollständige Beispiele:

Dynamische Speicherverwaltung im Kontext Kontexte laufen jetzt ab nach den Minuten der Inaktivität von 15, konfigurierbar, 5-1440, mind.)., ohne Speicherlecks, automatischer Reinigung, ,, smart touch on access-.,

Intelligente gemeinsame Datenextraktion Automatisches Extrahieren von ALLE Felder aus den Antworten auf jedem Nesting-Niveau.Verschachtelte Objekte.

Verbesserte Dokumentation Neue umfassende Leitfäden für Werkzeuge Aktionen, Begrenzung der SteuersätzeL 347 vom 20.12.2013, S. 671. API Kontexte.

Siehe RELEASE-_-NOTES-.-md für vollständige Details

---

Inhaltsverzeichnis

Kernkonzepte

Protokolle Merkmale

Erweiterte Architektur

Architektur im Überblick

Ein Motor – mehrere Protokolle – gemeinsame Infrastruktur Alle Funktionen teilen sich die gleiche Generation: ,-Kontext:,- und Steuerungssysteme: —-Geben Sie konsistentes Verhalten über REST-,-GraphQL.,-SSE],-Signal:

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

Schlüsselkomponenten

  • Einzel-LLM-ClientAlle Protokolle verwenden die gleiche LLM-Integration mit Resilienzrichtlinien
  • Gemeinsamer KontextspeicherAPI-Kontexte arbeiten über REST-, , GraphQL ,, , SignalR., und OpenAPI
  • Gemeinsame MerkmaleDie Geschwindigkeitsbegrenzung von ,, das Caching, die Fehlersimulation von, und das Tokenmanagement gelten für alle
  • Modulares DesignVerwenden Sie eine beliebige Kombination, nur das hinzufügen, was Sie brauchen

Siehe detaillierte Architekturdiagramme unten für Anforderungsfluss und Formregelung

Merkmale

Dieses Paket bietet sechs unabhängige Merkmale Verwenden Sie jede Kombination, die Sie benötigen Modulare Beispiele für Protokoll---spezifische Setups

REST API Mocking

  • Super einfach: AddLLMockApi() + MapLLMockApi("/api/mock") Sofortige Mock-API
  • FormregelungGeben Sie die genaue JSON-Struktur über den Header an.
  • Alle HTTP-Methoden:-Unterstützt GETC,-POST-,-PUT-,-DELETE,-PATCH
  • Wildcard RoutingJeder Pfad unter dem gewählten Endpunkt funktioniert
  • Vollständiger Inhaltstyp Support ,( ,NEW in %
    • JSON (application/jsonStandard-JSON-Anforderungsstellen
    • Formkörper (application/x-www-form-urlencodedEinreichung von HTML-Formularen
    • Dateiuploads (multipart/form-dataDatei-Uploads mit Metadatenextraktion
    • Speicher , - , sicherDateiinhalt gestreamt und versenkt Nur Metadaten erhalten
  • Willkürliche PfadlängenTiefenpfad-Nistung vollständig unterstützt/api/mock/v1/api/products/electronics/computers/laptops/gaming/...)

GraphQL API-Mocking

  • Native GraphQL Unterstützung:, POST bis /api/mock/graphql mit Standard GraphQL-Abfragen
  • Abfrage---getriebene FormenDie GraphQL-Abfrage selbst definiert die Antwortstruktur
  • Variablen OperationenVolle Unterstützung für Variablen, , und Fragmente
  • Richtige Fehlerbehandlung-: , gibt GraphQL ,- formatierte Fehler mit data und errors Felder

Server-Ausgesandte Ereignisse

SignalR Echtzeit-Streaming

  • WebSocket StreamingKontinuierliche Echtzeit---Zeitmockdaten über SignalR
  • Mehrere KontexteAusführen mehrerer unabhängiger Datenströme gleichzeitig
  • LebenszyklusmanagementStarten von /Stop-Kontexten dynamisch mit Management API
  • Alleinstehende WerkeKeine REST API-Einrichtung erforderlich
  • SignalR-Demohandbuch

OpenAPI - Swagger Mock Generation

  • Automatische Endpoint-GenerierungHinweis auf eine beliebige OpenAPI, / oder Datei
  • Alle Operationen gedämpftJeder Pfad und jede Methode aus der Spezifikation wird zu einem Live-Endpunkt
  • Schema---AntriebsdatenLLM erzeugt realistische Daten, die Ihren Schemas entsprechen
  • Mehrere SpecsBeladen und Montieren mehrerer API-Spezifikationen gleichzeitig
  • Alleinstehende WerkeKeine REST API-Einrichtung erforderlich
  • Anleitung für OpenAPI-Funktionen

GRPC Service Mocking Macking MACKing M('NEW in v.1.7.0)"

  • Protokolldatei hochladenHochladen von Dateien zum Generieren von gRPC-Diensten
  • Unterstützung für DoppelprotokolleJSON über HTTP zum Testen von Binär-Protobuf für die Produktion
  • Dynamische SerialisierungLaufzeit Protobuf-Kodierung ohne Codegenerierung
  • LLM.-.Powered DataRealistische Antworten passend zu Ihren Proto-Meldungsdefinitionen
  • Alleinstehende WerkeKeine REST API-Einrichtung erforderlich
  • gRPC-Unterstützungshandbuch

Gemeinsame Merkmale

  • KonfigurierbarKonfiguration der Appsettings von ., Json oder Inline
  • Hochvariable DatenJede Anfrage erzeugt völlig unterschiedliche realistische Daten
  • NuGet-PaketBequeme Ergänzung zu bestehenden Projekten
  • AutoShape-Speicher für (-FormenDie JSON-Struktur des ersten Ansprechens wird automatisch gespeichert., , um konsistente Schemata über alle nachfolgenden Anfragen bis zum gleichen Endpunkt zu gewährleisten. Siehe Anleitung für AutoShape
  • API KontextePflege der Konsistenz über verwandte Anfragen hinweg Vollständiger Leitfaden
  • FehlersimulationUmfassende Fehlerprüfung mit den Statuscodes von /5xx und mehreren Konfigurationsmethoden
  • Prüfung von VersorgungseinrichtungenPaket mit Begleitpersonen mostlylucid.mockllmapi.Testing für einfache HttpClient-Integration in Tests Siehe Abschnitt „Prüfung"

Nicht---Ziele

Was ist das?

  • Ein Entwicklungs- und Prototyping-Tool für realistische Mock-Datengenerierung
  • Perfekt für Frontend-Entwicklung, ,, API Design, ,, Demos und Tests
  • Zero---Pflegealternative zu hardcodierten Vorrichtungen und Datenbank-Mocks

Was ist das?

  • Keine Produktionsdatenquelle Generierte Daten sind realistisch, aber synthetisch
  • Kein Ersatz für Vertragsprüfungen Verwenden Sie dies für die Entwicklung, um echte APIs separat zu validieren.
  • Nicht für nicht validierten Produktionsverkehr Benutzereingabe geht direkt zu den LLM-Prompten Einspritzung möglich
  • Keine Datenbank oder dauerhafter Speicher Kein Zustand zwischen den Anfragen beibehalten. Außer optionalen API-Kontexten.
  • Kein Ersatz für echte Backend-Logik Business-Regeln – , validierung –, und Workflows bleiben vereinfacht

Wann es zu verwenden ist

  • Frontends entwickeln, bevor Backends fertig sind
  • Realistische Demos ohne Zugriff auf Produktionsdaten erstellen
  • Prüfung von UI-Komponenten mit vielfältigen Datenszenarien
  • Prototyping API entwirft und experimentiert mit Antwortformen
  • Lernen von LLM-Integrationsmustern in .-NET

Wenn es NICHT zu verwenden ist

  • In Produktionsumgebungen für echte Anwender
  • Zum Testen der Authentisierungslogik /-Authorisationslogika (-Security Scheme ignoriert )-Test
  • Wenn die Daten den strengen Geschäftsregeln oder der Validierung entsprechen müssen
  • Für Lastprüfungen tatsächliche Leistung des Backends
  • Wenn deterministische, reproduzierbare Daten über Testläufe erforderlich sind

Feature Dokumentation

Für detaillierte Guides mit Architekturdiagrammen - Anwendungsfälle - , und Implementierungsdetails

  • Anleitung für den Einsatz von Docker Komplette Docker-Einrichtung und -Ausführung

    • Schnellstart mit Docker-Compose
    • Beispiel für das Ende des Modells mit dem Modell llm.-
    • Verfahren zur Konfiguration von Dateien für das Volume Mapping von ,
    • GPU-Unterstützung: Multi---Backend-Einrichtung
    • Produktionsüberlegungen und Fehlerbehebung

  • API-Referenz für Backend Vollständige Dokumentation des Managementendpunktes

    • OpenAPI-Managementendpunkte
    • API-Kontextverwaltung
    • gRPC-Protomanagement
    • SignalR-Naben
    • Vollständiges Anfordern von Beispielen für die Antwort

  • Leitfaden für mehrere LLM-Backends Mehrfacher Provider-Support

    • Verbinden Sie sich gleichzeitig mit Ollama- und LM-Studio
    • Auswahl des Backends per Header anfordern
    • Komplette Rückwärtskompatibilität mit Legacy-Konfigurationen
    • AnbieterBesondere Beispiele und bewährte Verfahren

  • API Kontext-Leitfaden ,- , NEWSK1 ,

    • Gemeinsamer Speicher über Anfragen hinweg für konsistente Multi---Schritt-Workflows
    • E---Handelsströme , , , Aktienticker ,, , Spielzustand Beispiele
    • Token-Management und intelligente Beschneidung
    • Meerjungfrau Architektur-Diagramme

  • Geschwindigkeitsbegrenzungshandbuch für Batching NIEDERLANDE

    • Unterstützung für die Generierung mehrerer Antwortvarianten
    • Per.-.endpoint Statistik-Tracking mit gleitenden Durchschnitten
    • Drei Batching-Strategien
    • Detaillierte Timing-Header für die Leistungsprüfung
    • Perfekt zum Testen von Backoff-Strategien und Timeout-Szenarien

  • Pluggable Tools Leitfaden für Aktionen NIEDERLANDE

    • MCP---kompatible Architektur für erweiterbare Werkzeugintegration
    • HTTP-Tools zum Aufruf externer APIs mit Authentifizierung
    • Mock-Tools zur Erstellung von Entscheidungsbäumen und Workflows
    • Vorlagesubstitution durch Umgebungsvariablenunterstützung
    • Werkzeugketten mit Sicherheitsgrenzen und Ergebnis-Caching
    • Phase (Ausdrücklich ),Ausdrucks-Phase 2Ausschnitts-(LLM-Ausrichtungs-),Auszugs-phase 3Auswertungs- und Ausbaufahrplan )

  • gRPC-Unterstützungshandbuch NIEDERLANDE

    • Upload-Dateien für automatische gRPC Service Spoting
    • Duale Unterstützung: :-JSON über HTTP und binär Protobuf
    • LLM---powered realistische Reaktionserzeugung
    • Vollständige Umsetzungsdetails und Teststrategien

  • Anleitung für OpenAPI-Funktionen

    • Dynamisches Laden von Specs aus URLs , , , Dateien , oder Inline-JSON
    • Automatische Endpoint-Generierung mit Pfadparametern
    • Beispiele für die Reaktion mit der Petstore API anfordern
    • SignalR-Integration für Echtzeit-Updates

  • Beispiele für modulare Architektur

    • REST---only,-GraphQL---onally,-SignalR.--Setups
    • Strategien zur Speicheroptimierung
    • Protokolle mischen und anpassen

  • SignalR-Demohandbuch

    • Echtzeit-Datenstreaming-Einrichtung
    • Kontext Lebenszyklus-Management
    • Beispiele für die Client-Verbindung

  • Freigabehinweise

    • Vollständige Versionshistorie
    • Breaking-Änderungen seit v-1.0!)
    • Migrationsleitfäden

  • Zusammenfassung der Prüfung NIEDERLANDE

    • Vollständige Dokumentation der Prüfabdeckung
    • Tests mit detaillierter Aufschlüsselung
    • Leistungskennzahlen und Validierung
    • Alle erklärten Testkategorien

  • Zusammenfassung der Umsetzung NIEDERLANDE

    • Aufbau und Datei upload implementation Details
    • Manuelle JSON-Konstruktion für .-NET
    • Speicher---sichere Datei-Handling-Architektur
    • Vollständige Code-Änderungen und Begründung

Schnellstart

Installation

Hauptpaket„:"

dotnet add package mostlylucid.mockllmapi

Testen von Versorgungseinrichtungen (MSK)

dotnet add package mostlylucid.mockllmapi.Testing

Bietet fließende API für einfache HttpClient-Konfiguration in Tests. Siehe Abschnitt „Prüfung" für Details

Schnelles Starten mit Docker

Der schnellste Weg, um begonnen zu bekommen, keine Installation erforderlich

# 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\":\"\"}"

Dass es ''s ist Die API läuft unter http://localhost:5116 mit Ollama-Backend

Siehe Komplette Anleitung für Docker für„:"

  • Konfigurationsoptionen für das Volumen-Mapping von )
  • Verwendung unterschiedlicher Modelle (-Gemma-3:4-B2-Mistral-MSC3-Nemo-)-
  • Unterstützung der GPU
  • Produktionsausbau
  • Fehlerbehebung

Voraussetzungen für die lokale Entwicklung

Wenn Sie Docker-: nicht verwenden

  1. Installieren ,.-NET , 8.0-SDK oder später
  2. Installieren Ollama und ziehen Sie ein Modell. 
    ollama pull ministral-3:3b

Auswahl eines LLM-Modells

Dieses Paket war entwickelt und getestet mit ministral-3:3b Parameter der ),, die hervorragende Ergebnisse für alle Funktionen mit sehr schneller Leistung liefern, aber es funktioniert mit jedem Ollama-- kompatiblen Modell.

Empfohlene Modelle

-Modell Größe -Geschwindigkeit Qualität -Kontext Am besten für -Gewinde
Ministral--3:3-b (-default-)- -m3- -fast- -fashion-m-sk6-m.sk7-mzk8-mc9-mg KILLER für JSON-!-Schnelles, präzises und riesiger Kontext
Gemma-3:4-b -4-M -MUSK3-MASK4-Gute Alternative für Maschinen mit niedrigerem --Ende
llama-3- -M8- -M-M -M- -M sehr gut -8-MH-MSC6-M/,-Fertigung
Mistral---Nemo 12 Slower Ausgezeichnete -128-K- Hochwertige massive Datensätze
Mistral-:7-b -7-M -M-M -M- -M sehr gut -8-M M- -Alternative zu llm--Modell
phia-3- Schnelles schnelles Prototyping
tinellama ---1.1-- --Very Fast -- -- Basic -- --MCSK6--Ultraressource -----constrained -- --

EMPFEHLUNG DES :-Qwen-Coders für die Entwicklung

Qwen-Coder ist KILLER für JSON-Generation Hochpräzise, hochpräziser, großer Kontext

ollama pull ministral-3:3b

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

Warum es groß ist

  • Außergewöhnlich schnell auf jeder Hardware
  • Beste Genauigkeit der JSON-Generierung
  • Kontextfenster der (, Griffe komplexe verschachtelte Strukturen
  • Ausgebildet speziell für code/-strukturierte Daten
  • Perfekt für CIP-/-CD Pipelines und Entwicklung
  • Minimale Halluzinationen im Vergleich zu allgemeinen Modellen

PRODUKTION:- Mistral---Nemo - Beste Qualität - Massive Kontexte

Für die Produktion – --ähnliche Tests mit komplexen Schemas –:-

ollama pull mistral-nemo

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

Warum es groß ist

  • Höchste Qualität realistische Datengenerierung
  • Kontextfenster von -128.K ( erfordert Konfiguration von Ollama)
  • Am besten für komplexe verschachtelte Strukturen und große Datensätze
  • Mehr kreative Variation der generierten Daten
  • AnmerkungBenötigt mehr Ressourcen

Spezifische Konfiguration des Modells

Für Ministrale , -3:3 , b ,( , empfohlen , - , default , ): ,

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

für Gemma-3:4-b oder Lama-3:-

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

Für die Mistral---Nemo-Produktion mit hoher Qualität

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

Anmerkung: Mistral---nemo erfordert Ollama-Kontextkonfiguration für Kontexte der ,128'K'

Wo finden Sie MaxContextWindow?

# Check model info
ollama show {model-name}

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

Für kleinere Modelle

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

Warum Temperatur-Materien?

  • Größere Modelle kann mit hohen Temperaturen umgehen, unter Beibehaltung gültiger JSON
  • Kleinere Modelle Sie benötigen niedrigere Temperaturen, um die Temperatur zu vermeiden.
    • Ungültige JSON-Syntax Anführungszeichen
    • Beschneidete Reaktionen mit Ellipsen
    • Halluzinierte Feldnamen oder -strukturen
  • Niedrigere Temperatur Vorhersehbarerer Ausgang weniger Vielfalt
  • Höhere Temperatur Mehr kreative Ausgabe Mehr Vielfalt Aber riskanter für kleine Modelle

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

Wichtige Einschränkungen

  • Kleinere Modelle (tinyllama, phi3Arbeit, kann aber
    • Einfachere, abwechslungsreiche Daten generieren
    • Struggle mit komplexen GraphQL-Abfragen
    • Brauchen Sie mehr Wiederholung Versuche
    • Arbeiten Sie am besten mit einfachen Abfragen und kleinen Antwortgrößen
  • Alle Modelle kann kämpfen mit
    • Sehr komplexe, tief verschachtelte GraphQL-Abfragen Konzentrationen in der Tiefe
    • Viele Felder pro Objekt ](>10-Felder ®)
    • Anforderungen an große Arrays Beschränken Sie sich auf Elemente für die Zuverlässigkeit
  • Wenn Sie Fehler sehen über abgeschnittene JSON oder Kommentare
    • Niedrigere Temperatur bis unter oder unter MSK
    • Vereinfachen Sie Ihre GraphQL-Abfrage
    • Erhöhung MaxRetryAttempts nicht mehr als 20 GHT

Grundlegende Verwendung

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

Das ,''s es jetzt alle Anfragen an /api/mock/** Intelligente Mock-Daten zurückgeben

AutoShape-Speicher für (-Formen

Konsistente JSON-Strukturen über Anfragen bis zum gleichen Endpunkt automatisch erhalten

Was es bewirkt

AutoShape erinnert sich an die JSON-Struktur von der ersten Antwort auf einen Endpunkt und wendet diese automatisch für alle nachfolgenden Anfragen auf denselben Endpunkt an.

  • Konsequente Reaktionsschemata über mehrere Anrufe hinweg
  • Kein Schemadrift während der Entwicklung
  • Vorhersehbares API-Verhalten zum Testen

Schnelles Beispiel

# 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"}

Einrichtung

Standardmäßig aktiviert in der appsettings.json:

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

Steuerung für Per---Anfragen

Deaktivieren Sie für spezifische Anforderungen

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

Erneuern Sie eine schlechte Form

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

Pfad-Normalisierung

Alle diese Anfragen haben die gleiche Form /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

Hauptmerkmale

  • Standardmäßig aktiviert Funktioniert aus dem Kasten heraus
  • Formerneuerung Befestigen Sie schlechte Formen mit ?renewshape=true
  • Expiration Formulare laufen nach Inaktivität aus.
  • Intelligente Normalisierung Verschiedene IDs zu gleichen Endpunkten teilen Formen
  • Explizites Überschreiben Die Bereitstellung von expliziter Form über Query-/-Header-MSC2-body überspringt die Autoform
  • Funktioniert überall Endpunkte von , und GraphQL

Wann verwendet werden soll

Perfekt für

  • Frontend-Entwicklung, die konsistente Mockdatenstrukturen benötigt
  • Integrationstests, die vorhersehbare Schemata erfordern
  • Demos, bei denen die Datenstruktur zwischen den Anfragen ändern sollte
  • API-Prototyping mit sich entwickelnden, aber konsistenten Formen

Nicht erforderlich, wenn

  • Mit expliziten Formen haben sie sowieso Vorrang
  • Maximale Vielfalt in jeder Antwort wollen
  • Testen von Schema-Entwicklungsszenarien

Fehlerbehebung

Formen, die nicht angewendet werden

  1. Kontrolle EnableAutoShape: true in config
  2. Prüfen Sie keine explizite Form zur Verfügung gestellt
  3. Ablaufzeit prüfen

Notwendigkeit, eine Form zu ändern

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

Alle Formen programmatisch löschen

// Inject AutoShapeManager
autoShapeManager.ClearAllShapes();

Für eine vollständige Dokumentation siehe: CLUDE-.-md AutoShape Abschnitt.

Testabdeckung Tests, die alle autoshape Funktionalitäten abdecken

Einstellungen

Vollständige Konfigurationsreferenz Siehe Referenzhandbuch für die Konfiguration für alle Optionen Vollständiges Beispiel Siehe Appsettings.-Full-.-Json -® zeigt jedes Konfigurationsoption

Über die Appsettings....-json...Empfohlene Version...

{
  "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„-"Spezifische Token-GrenzwerteSiehe auch: LLMApi/appsettings.json für Konfigurationsbeispiele für verschiedene Modelle (-Llama - TinyLama-,- Mistral-,- usw. .).-Jedes Modell hat unterschiedliche Kontextfenstergrößen --Einstellung MaxInputTokens Entsprechende Angaben:

API KontexteFür detaillierte Informationen über die Verwendung von Kontexten, um Konsistenz über Anfragen zu erhalten . . API Kontext-Leitfaden.

Resilienzpolitik

Neu in v.1.2.0:- Integrierte Polly-Resilienzrichtlinien schützen Ihre Anwendung vor LLM-Serviceausfällen

Das Paket enthält zwei Resilienz-Muster, die standardmäßig aktiviert sind.

Exponentielle Rücklaufwiederholung

  • Automatisch retries fehlgeschlagene LLM-Anfragen mit exponentiellen Verzögerungen
  • Einschließlich Jitter, um donnernde Herdenprobleme zu verhindern
  • Behandelt Verbindungsfehler-Timeouts und Nicht--Erfolgsstatuscodes
  • Standardmäßige Versuche mit der zweiten Basisverzögerung

Leistungsschalter

  • Öffnet nach aufeinanderfolgenden Ausfällen, um Kaskadenausfälle zu verhindern
  • Bleibt für eine konfigurierte Dauer offen, bevor Testanfragen zugelassen werden
  • Drei Staaten, die geschlossen sind, (, normales ),, offenes (, ablehnendes),, halb geöffnete -, geöffnetes (, Testing-)
  • Standardmäßig Öffnet sich :- nach aufeinanderfolgenden Ausfällen, bleibt ,- für Sekunden geöffnet.

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

Protokollierung .: .

Die Resilienz-Richtlinien protokollieren alle Wiederholungsversuche und Änderungen des Leistungsschalterzustandes

[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

Wann man sich anpasst

  • Langsam LLM-? Erhöhung MaxRetryAttempts oder RetryBaseDelaySeconds
  • Aggressive Erholung Reduzierung CircuitBreakerDurationSeconds
  • Viele transiente Fehler Erhöhung CircuitBreakerFailureThreshold
  • Deaktivieren Sie für lokale Tests. Beides einstellen EnableRetryPolicy und EnableCircuitBreaker zu false

Über Code

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

Benutzerdefinierte Endpunktmuster

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

Anwendungsbeispiele

Grundantrag

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

Gibt realistische Benutzerdaten zurück, die durch das LLM-.® erzeugt wurden

Formkörper-Antworten in v.2.3.0)

HTML-Vorlageformular

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"

Die Formulardaten werden automatisch in JSON konvertiert und zur realistischen Reaktionsgenerierung an die LLM übergeben.

Form mit mehreren Werten

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"

Mehrere Werte für den gleichen Feldnamen werden automatisch in Arrays konvertiert.

Datei-Upload-Anfragen in v.2.3.0)

Einzelne Datei hochladen

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

Mehrere Dateien mit Formdaten ,:

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

Wie Datei hochlädt Arbeit .:

  • Dateiinhalt ist gestreamt durch einen Puffer und gedumpt Nicht im Speicher gespeichert
  • Nur Metadaten werden beibehalten.:-Dateiname: ,-Inhaltstyp:,-Größe: , Bytes lesen
  • LLM erhält Datei-Metadaten und erzeugt entsprechende Antwort
  • Speicher---sicher für große Dateien mit (-getestet

Beispiel: Response

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

Tiefer Pfad verschachtelt sich in v.2.3.0)

Komplexe verschachtelte Pfade

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

Das LLM integriert alle Pfadsegmente und Abfrageparameter in die realistische Reaktionsgenerierung..- Kein praktisches Limit für die Pfadtiefe.

Mit API-Kontext in v.1.5.0)

Verwenden Sie Kontexte, um die Konsistenz über mehrere verwandte Anfragen hinweg zu erhalten.

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

Jede Anfrage im gleichen Kontext sieht die vorherigen Anfragen ,, , um konsistente IDs , , names und Datenbeziehungen zu gewährleisten.. , Perfekt für Multi- , - , Schritt-Workflows API Kontext-Leitfaden für komplette Beispiele

Mit Shape Control

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 generiert Daten passend zu Ihrer exakten Formspezifikation.

Streaming von (-SSE-Servern

SSE-Streaming ist Teil der REST API, die nur beim Mapping von Endpunkten aktiviert wird.

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

Verwendung

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

Gibt Server zurück, wenn JSON ein Token erzeugt wird.

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":"{...}"}

Beispiel für 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);
    }
};

Mit Formsteuerung

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

Der Streaming-Endpunkt unterstützt alle die gleichen Funktionen wie normale Endpunkte.

  • Formregelung für die Parameter ,, Header , oder Body)
  • Unterstützung von JSON Schema
  • Benutzerdefinierte Eingabeaufforderung
  • Alle HTTP-Methoden

GraphQL API Mocking

Neu in v.1.2.0:- Native GraphQL-Unterstützung mit Abfrage-Mock-Datengenerierung

LLMock API enthält integrierte GraphQL-Endpunkteunterstützung im Vergleich zu REST-Endpunkten, bei denen Sie Formen separat angeben. Graph QL-Abfragen definieren natürlich die genaue Struktur, die sie erwarten.

Schnellstart mit GraphQL

Der GraphQL-Endpunkt ist automatisch verfügbar, wenn Sie die LLMock API abbilden.

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

Dies erzeugt einen GraphQL-Endpunkt bei /api/mock/graphql.

Grundlegende Verwendung

Einfache Abfrage

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

Ansprechrate

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

Mit Variablen

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

Verschachtelte Abfragen

GraphQL-'s Leistung glänzt mit verschachtelten Daten

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

Das LLM generiert realistische Daten, die Ihrer exakten Abfragestruktur entsprechen.

Beispiel für JavaScript-Clients

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' });

Fehlerbehebung

GraphQL-Fehler werden im Standardformat zurückgegeben

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

Wie es funktioniert

  1. Parse-AntragExtrahieren Sie GraphQL-Abfrage und den Namen der Operation.
  2. Prompt erstellenSenden Sie die Abfragestruktur an das LLM mit Anweisungen, um passende Daten zu generieren
  3. Daten generierenLLM erstellt realistische Daten, die exakt zu den Abfragefeldern passen
  4. Wrap ResponseGibt Daten im GraphQL-Format zurück { "data": {...} }

Die wichtigsten Vorteile

  • Keine Formspezifikation erforderlichDie GraphQL-Abfrage definiert die Struktur
  • Typ SicherheitFragefelder explizit nach Namen anfordern
  • Verschachtelte BeziehungenNatürliche Unterstützung für komplexe, verschachtelte Datenstrukturen
  • StandardformatFunktioniert mit jeder GraphQL-Clientbibliothek
  • Realistische DatenLLM erzeugt kontextabhängig passende Daten für jedes Feld

Prüfung von GraphQL

Nutzen Sie die enthaltenen LLMApi.http Datei, die bereit ist,- zu verwenden

  • Einfache Benutzerabfrage
  • Abfrage mit Variablen
  • Verschachtelte Felder mit Arrays
  • Produktkatalog für den Handel
  • Komplexe Organisationsdaten

Siehe GraphQL-Beispiele auf LLMApi...http für komplette Arbeitsbeispiele

GraphQL-Konfiguration

Token Limits und Modellauswahl

GraphQL-Antworten können mit tief verschachtelten Abfragen groß werden. GraphQLMaxTokens Option „:"

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

Token Limit Guidelines®:-

Empfohlene Max-Tokens Notizen |-------|----------------------|-------| | llm,-, Modell Optimale Balance von Geschwindigkeit und Komplexität | Mistral-:7-b Griffe verschachtelte Strukturen gut | phia-3- Bewahren Sie die Abfragen einfach auf | tinellama Verwenden Sie nur flache Abfragen

Warum Niedriger besser ist

  • Die Aufforderung priorisiert Korrektheit über die Länge
  • Untere Grenzen zwingen die LLM, einfacher zu generieren.
  • Höhere Grenzwerte Risiko verkürzte Ansprechraten
  • Wenn Sie sehen, dass LLM®" Fehler bei nicht gültigem JSON sind GraphQLMaxTokens reduzieren

Für komplexe verschachtelte Abfragen

  1. Verwenden Sie größere Modelle (-llm---Modell MS K2-mistral-:7-b-MS K4-
  2. Erhöhen Sie GraphQLMaxTokens auf MSA
  3. Halten Sie Array-Größen klein.
  4. Überwachen Sie Protokolle für Kurzbefehle

Beispielkonfiguration für komplexe Abfragen

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

SignalR Echtzeit---Zeitdatenstreaming

LLMock API enthält optionale SignalR-Unterstützung für continuous - , , real -- ,time Mock Datengenerierung , . , Dies ist perfekt für ,: ,

  • Dashboard Prototypen erfordern Live-Updates
  • Prüfung von Echtzeit-UI-Komponenten
  • Demos mit ständig wechselnden Daten
  • Test der Integration von WebSocket-/-SignalR

Schnellstart mit SignalR

SignalR arbeitet unabhängig von der Verwendung der REST API-Endpunkte für SignalR-Streaming

Nur für die Einrichtung des minimalen Signals

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

Optional auch REST API hinzufügen

Wenn Sie auch die REST API-Endpunkte wollen, fügen Sie diese Zeilen hinzu.

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

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

Konfigurieren Sie in 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"
      }
    ]
  }
}

Schließen Sie sich vom Client an

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

Konfiguration des Hubkontexts

Jeder Hub-Kontext simuliert eine komplette API-Anfrage und generiert kontinuierlich Daten

{
  "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
}

Empfohlene Verwendung von einfachen englischen Beschreibungen

Lassen Sie die LLM automatisch entsprechende JSON-Strukturen erzeugen.

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

Das LLM erzeugt automatisch ein passendes JSON-Schema aus Ihrer Beschreibung. keine manuelle Form erforderlich.

Dynamic Context Creation API

Erstellen und Verwalten von SignalR-Kontexten zur Laufzeit mit Hilfe der Management-API

Kontext erstellen

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

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

Ansprechrate

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

Alle Kontexte auflisten

GET /api/mock/contexts

Ansprechrate

{
  "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
}

Hinweis: Der Listenendpunkt verschmilzt Kontexte, die in Appsettings konfiguriert sind, mit dynamisch erzeugten Kontexten zur Laufzeit.::: .® Beschreibungen aus Appsetsettings sind enthalten, auch wenn diese Kontexte noch nicht dynamisch registriert wurden.:.

Spezifischen Kontext erhalten

GET /api/mock/contexts/weather

Ansprechrate

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

Kontext löschen

DELETE /api/mock/contexts/crypto

Ansprechrate

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

Ausgangskontext Datengenerierung fortsetzen)

POST /api/mock/contexts/crypto/start

Ansprechrate

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

Startet die Generierung von Daten für einen gestoppten Kontext, ohne dass verbundene Clients betroffen sind.

Kontext beenden _(-Pause Datengenerierung

POST /api/mock/contexts/crypto/stop

Ansprechrate

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

Stoppt die Generierung neuer Daten, hält aber den Kontext registriert..-Clients bleiben verbunden, erhalten jedoch keine Updates, bis sie wieder gestartet werden.

Vollständiges Client-Beispiel

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

Dynamische Kontexterstellung aus der Benutzeroberfläche

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

Das MockLlmHub unterstützt die folgenden Methoden:

SubscribeToContext.(.string context. ).

  • Subscribes the client to receive data updates for a specific context
  • Kunde erhält DataUpdate Ereignisse mit generierten Daten
  • Neu in v.1.1.0:- Erhöht automatisch die Anzahl der Verbindung im Kontext

AbbestellenVomContext-Kontext-String

  • Abonniert den Client aus einem Kontext
  • Der Kunde erhält für diesen Kontext keine Updates mehr
  • Neu in v.1.1.0:- Dekrementiert automatisch die Kontextanzahl von '

Veranstaltungen, die vom Kunden empfangen werden

Datenaktualisierung Enthält generierte Mock-Daten

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

Unterzeichnet Bestätigung des Abonnements

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

Abonniert Bestätigung der Abmeldung

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

Einstellungen

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

Unterstützung von JSON Schema

Hub-Kontexte unterstützen sowohl einfache JSON-Formen als auch vollständige JSON Schema.

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

Das System auto---entdeckt JSON Schema durch die Suche nach $schema, typemit einem Quadratmetergewicht von mehr als 1 kg properties felds-.-

Architektur

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

Komponenten :"

  • MockLlmHubSignalR-Hubbearbeitung von Clientverbindungen und Abonnements
  • MockDataBackgroundServiceGehosteter Service, der kontinuierlich Daten generiert
  • DynamicHubContextManagerSicherheitsmanager für die Laufzeit-Kontextregistrierung
  • HubContextConfigKonfigurationsmodell für jeden Datenkontext

Anwendungsfälle

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

IoT-Simulation

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

Finanzdaten

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

Spielendes Leaderboard

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

Kontext Lebenszyklusmanagement

Neu in v.1.1.0:- Volle Lebenszykluskontrolle über SignalR-Kontexten mit Echtzeit---Statusverfolgung

Jeder Kontext hat die folgenden Eigenschaften:

  • Ist aktiv.: . Ob der Kontext Daten erzeugt . . ( .default .
  • VerbindungszählenAnzahl der aktuell angeschlossenen Clients

Kontexte können in zwei Zuständen sein

  • AktivHintergrunddienst erzeugt neue Daten jeder SignalRPushIntervalMs ,( , default , : , 5 , sekunden , )
  • AngehaltenKontext bleibt registriert, , Clients bleiben verbunden, , aber es werden keine neuen Daten generiert

Hauptmerkmale

  • Kontexte starten, ohne Clients zu trennen
  • Echtzeit-Verbindungszählerverfolgung
  • Status-Abzeichen zeigen aktiven Zustand
  • Doppelte Kontextprävention
  • Kontexte aus der Appsettings-Anwendung .-json erscheinen automatisch in der Benutzeroberfläche

Ansprech-Caching für SignalR.:. Neu in v.1.1.0:- Intelligentes Caching reduziert LLM-Last und verbessert die Konsistenz

  • Batch-VorfüllungErzeugt Antworten auf einmal, die über MaxCachePerKey)
  • Kontext WarteschlangenJeder Kontext pflegt seinen eigenen Cache von vor- und generierten Antworten
  • Hintergrund NachfüllenDer Cache wird automatisch nachgefüllt, wenn er unter die Kapazität des Speichers fällt.
  • Intelligente PlanungMinimiert LLM-Aufrufe unter Beibehaltung der Datenfrischheit

Dies reduziert die LLM-Last für hochfrequente Kontexte, besonders bei mehreren Clients,

Beispiel Workflow - :

# 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

Neue Funktion Automatische Generierung von Mockendpoints aus den OpenAPI-Spezifikationen/-Swagger-Specifications!-Point to any OpenAPI - 3.0/-Swaiger-Spekulationen (-URL oder Datei) und die Bibliothek erstellt Mock Endpoints für alle definierten Operationen..-

Schnellstart mit 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"
      }
    ]
  }
}

Alle Endpunkte aus Ihrer OpenAPI-Spezifikation sind jetzt als intelligentes LLM-M--powered-Mods erhältlich.

Wie es funktioniert

  1. Spec LadenLadet OpenAPI-Spezifikationen aus URLs oder lokalen Dateien.
  2. SchemaumwandlungUmwandelt OpenAPI-Schemas in JSON-Formvorlagen
  3. Endpunkt-MappingAlle Operationen automatisch auf ASP-.-NET Core-Endpunkte abbilden
  4. Erzeugung von LLMVerwendet LLM, um realistische Mock-Daten zu erzeugen, die dem Schema entsprechen
  5. PfadparameterBehandelt Pfadparameter wie z.B. /users/{id} automatisch

Einstellungen

Jede OpenAPI-Spezifikation unterstützt diese Konfigurationsoptionen

Beschreibung des Objekts |----------|------|-------------| | Name Eindeutiger Identifikator für diese Spezifikation | Source URL oder Dateipfad zu OpenAPI Spec | BasePath Die Zeichenfolge | überschreiben den Basispfad "MSC2" verwendet Spec-'s servers[0].url) | | EnableStreaming ,| bool , | , Hinzufügen /stream Suffix für das SSE-Streaming | IncludeTags Zeichenkette[Nur Endpunkte mit diesen Tags generieren | ExcludeTags Zeichenkette[Endpunkte mit diesen Tags überspringen | IncludePaths Zeichenkette[Nur diese Pfade zu generieren, unterstützt Wildcards wie z.B. /users/*) | | ExcludePaths Zeichenkette[Überspringen Sie diese Pfade (Unterstützt Wildcards

Erweiterte Konfigurationsbeispiele

Filtern nach Tags

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

Filtern nach Pfaden

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

Streaming aktivieren

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

Testen von OpenAPI Mocks

Angesichts dieser OpenAPI-Spezifikationskonfiguration

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

Und eine Spezifität definieren GET /pet/{petId} die eine Pet Objekt: ,, du kannst testen :,

# 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"
}

Modulare Nutzung

OpenAPI-Mocks arbeiten unabhängig von REST-/-GraphQL./-SignalR.:-

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

Unterstützte Spec Formate

  • Öffnen Sie die API. ](-JSON oder YAML-)-
  • Öffnen Sie die API. ](-JSON oder YAML-)-
  • Swagger - 2.0- ](-JSON oder YAML-)-

Hauptmerkmale

  • Automatische Endpoint-GenerierungAlle Pfade und Operationen von Spec werden zu Mockendpoints
  • Schema---getriebenAus OpenAPI-Antwortschemas abgeleitete Antwortformen
  • PfadparameterGriffe /users/{id}, /posts/{postId}/comments/{commentId},,, usw. , .
  • Mehrere SpecsBeladen und Montieren mehrerer API-Spezifikationen gleichzeitig
  • Intelligente FilterungEinschließen von Operationen durch Tags oder Pfade
  • Streaming-UnterstützungOptionales SSE-Streaming für jeden Endpunkt
  • LLM.-.PoweredErzeugt realistische, abwechslungsreiche Daten für jedes Schema

Anwendungsfälle

  • API.-.Erste EntwicklungStarten Sie die Codierung gegen Spec, bevor das Backend fertig ist
  • Frontend PrototypingEntwickeln Sie Benutzeroberfläche, während API gebaut wird
  • IntegrationsprüfungTesten Sie den Clientcode ohne echte API-Abhängigkeiten
  • DemoumgebungenVorzeigeapps ohne API-Zugriff in der Produktion
  • VertragsprüfungÜberprüfe, ob alle Schemavariationen korrekt behandelt werden
  • BelastungsprüfungErzeugen realistischer Testdaten im Maßstab

Einschränkungen

  • Derzeit unterstützt Reaktionsschemase nur die Validierung nicht erzwungen.
  • Sicherheitsvorkehrungen werden ignoriert.
  • Nur Anwendungs-Inhaltstyp für Antworten unterstützt
  • Pfadparameterwerte werden nicht gegen Schemabeschränkungen validiert

OpenAPI-Verwaltung testen

Einschließlich management.http Datei enthält umfassende Beispiele für alle Managementendpunkte

Spec Management:

  • Spezifik von URL laden (-Petstore-,-GitHub API, , usw. .)-
  • Spezifität aus der lokalen Datei laden
  • Spezifität von rohem JSON-/-YAML laden
  • Alle geladenen Spezifikationen auflisten
  • Spezielle Details mit Endpunkten erhalten
  • Spezifik neu laden aus Quelle aktualisieren
  • Spezifik löschen

Endpunktprüfung:

  • Test GET-Endpunkte mit Pfadparametern
  • POST-/-PUT-/-DELETE-Endpunkte testen
  • Testendpunkte mit Abfrageparametern
  • Mehrere Endpunkte in Folge testen

Fortgeschrittene Workflows:

  • Mehrere Spezifikationen gleichzeitig laden
  • Vergleich OpenAPI mocks vs regelmäßig spots
  • Batch-Betrieb
  • Beispiele für Fehlerbehandlungen

Beispiel aus der Geschäftsleitunghttp:

### 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"
}

Siehe das vollständige Geschäftsführung: http:www.msk.org/ Datei für das Bereitstellen von - Zu verwenden von Beispielen für -

Demo-Anwendungen

Das Paket beinhaltet komplette Demo-Anwendungen mit interaktiven Schnittstellen mit Vollkontext-Management.

Windows-Desktop-ClientLLMockApiClient/WPF-Anwendung in der Entwicklung

ENTWICKLUNGSSTATUSDer Windows-Desktop-Client befindet sich derzeit in der aktiven Entwicklung.Während viele Funktionen funktional sind, können einige Funktionalitäten unvollständig sein oder Änderungen unterliegen.

Eine umfassende WPF-Desktopanwendung für die Interaktion mit der LLMock API.

Merkmale

  • DashboardEchtzeit-Verbindungsstatus und Systemüberwachung
  • SignalR Real---ZeitKontexte erstellen und Live-Datenströme abonnieren
  • SSE-Streaming3 Streaming-Modi (Tokens,« Objekte,« Array-Elemente)«
  • OpenAPI-ManagerBelastungsspezifikationen aus den Testendpunkten von URL-/.JSON-MSC2.
  • gRPC-DienstleistungenTesten Sie die gRPC-Methoden
  • Mit APIs abspielenInteraktiver HTTP-Testspielplatz
  • Unterstützung für Multi---BackendsKonfigurieren und Umschalten zwischen mehreren Backends
  • VerkehrsüberwachungLive-HTTP-Request-Antwortprotokollierung
  • Dark-/-Licht-DesignUmschalten zwischen Themen mit glatten Übergängen

Dokumentation LLMockApiClient README

Perfekt für Desktop-Testing von Workflows – visuelle API-Exploration – Entwicklung und Debugging

Web---basierte Demos

SignalR-Demo/Zeitdaten-Streaming mit Management Benutzeroberfläche

Neu in v.1.1.0:- Verstärktes Layout für die Kolumnen mit vollständigem Lifecycle-Management

Merkmale

  • Kontext-Panel erstellenDas System erzeugt ein passendes JSON-Schema
  • Active Contexts Panel:
    • Live-Liste aller Kontexte mit Statusabzeichen
    • Kontexte von Appsettings automatisch beim Start anzeigen
    • Echtzeit-Verbindungszahl für jeden Kontext
    • Per---Kontext-Steuerungen :-Verbindung verbinden ,-Verbindung trennen ,-Start,-Stopp Löschen
    • Automatisches Aktualisieren bei Änderungen
  • Live-DatenfeldEchtzeit-Updates aus abonnierten Kontexten
    • JSON Syntax HervorhebungSchöne dunkles Display mit farbigen, farblichen und kodierten Elementen
    • Schlüssel (-rote Zeichenketten (-grüne Zeichenfolgen ),-Nummern (-orange),-Booleane (-cyan-),-null (-violette Zeichen
    • Sauberes, lesbares Format mit korrekter Zeitstempelanzeige
    • Keine externen Abhängigkeiten, leicht gebaut, im Highlighter

Beispiele für schnelles Starten von : One---Klick-Tasten für vorkonfigurierte Szenarien

  • IoT SensorenTemperaturfühler mit Geräte-ID, ,, Messwerte, Batterieanteil
  • AktienmarktReale Preise mit Ticker , , , Preis ,, , Veränderung in Prozent , , , Volumen
  • Aufträge für den HandelBestellungen mit ID., customer; , items array; MSV3 status; MSC4 assem
  • Server-MetrikenÜberwachen von Daten mit Hostname: ,, CPU: ,, Speicher: MSC3, Festplatte: ,, Verbindungen
  • Gaming LeaderboardSpieler-Statistiken mit Namen,Auswertung,Auswertung ,Ausrichtung,Ausrichtung

Perfekt für Dashboards, ,, Live-Monitoring, IoT-Simulationen, ,, real-, Time Feeds, Prototyping

SSE-Streaming-Demo/Streaming- Progressive JSON-Generation

Neu in v.1.1.0:- Quick-Beispieltasten für Instant-Streaming starten - !

Merkmale

  • HTTP-Methode konfigurieren path- und optionale JSON-Form
  • Beobachten Sie, dass JSON in Echtzeit erzeugt wird.
  • Live-Statistiken: :, Stückzahl: ,, Dauer: MSC2, Datengröße:
  • Verbindungszustandsindikatoren

Beispiele für schnelles Starten von : One-Click-Tasten für Streaming-Szenarien

  • BenutzerlisteArray von Benutzerobjekten mit ID-ID-,-Namen
  • ProduktkatalogProduktbestand mit Artikel-Nr.: ,, Name: ,, Preis:,, Lagerbestand:
  • Einzelheiten zur BestellungVerschachtelte Bestellungen mit Kundeninformationen und Artikel-Array
  • WetterdatenAktuelle Bedingungen mit Temperatur , Luftfeuchtigkeit , , , Windgeschwindigkeit

Perfekt für Beobachten der LLM-Generation – ,-Debugging-Formen –,-Verständnis des Streaming-Verhaltens – Tests von SSE

OpenAPI-Manager-Demo/OpenApiDynamische Spec-Belastung

Neue Funktion Interaktives OpenAPI-Spezifikationsmanagement mit Echtzeit-Updates

Merkmale

  • Technische Daten dynamisch ladenAus URL oder Roh einfügen JSON-/.YAML direkt im Browser
  • Echtzeit-UpdatesSignalR.- mit Live-Benachrichtigungen für alle Aktionen
  • Endpoint DiscoveryAutomatische Extraktion aller Operationen aus Spec
  • Prüfung des In---BrowsersTesten Sie jeden Endpunkt mit einem Klick.,. Siehe LLM.MSC2.generierte Mock-Daten
  • LebenszyklusmanagementDaten löschen ohne Server neu starten
  • Schöne BenutzeroberflächeFarbige HTTP-Methoden – -, kodierte HTTP-Verfahren – MSV2, Syntax – MSC3, hervorgehobene JSON-Antworten
  • VerbindungsstatusLive-Anzeige zeigt SignalR-Verbindungszustand
  • Umfassende HilfeInline Dokumentation und Beispiel-URLs

Beispiele für schnelles Starten von :

  • Petstore API von der URL laden
  • Benutzerdefinierte OpenAPI JSON einfügen
  • Alle Endpunkte von der Spezifikation anzeigen
  • Testendpunkte direkt auf der Seite
  • Siehe realistische Mock-Daten, die von LLM erzeugt werden

Perfekt für API-Prototypisierung - Entwicklung von Frontends ,, , Contract Testing , , , Spec Validierung , , Demos

Führen Sie die Demos aus

cd LLMApi
dotnet run

Navigieren Sie zu„:"

  • http://localhost:5116 SignalR Echtzeit-Datenstreaming mit Management UI
  • http://localhost:5116/Streaming SSE-Progressive Generation
  • http://localhost:5116/OpenApi OpenAPI Spec Manager mit dynamischer Belastung

Alle Demos enthalten

  • Umfassende Inline-Dokumentation
  • Interaktive Beispiele für den schnellen Start von -
  • Code-Schnipsel für die Integration
  • Echtzeit-Statusindikatoren
  • Kontrolle des gesamten Lebenszyklus des Kontexts

Erweiterte Funktionen

Antwort Schema Echo -(-Shape , )-Export

Sie können optional das Middleware-Echo zurück die JSON-Form haben, die verwendet wurde, um die Mock-Response zu erzeugen.

Konfiguration

  • Option: Einschließen vonShapeInResponse - Standard-False-)
  • Per.-.Request override; :.Add Query Parameter schließen Schema; =.true ein
  • Header emittiert ,: , X , - , Response , - , Schema , nur wenn eine Form bereitgestellt wurde und Größe ,≤ , , 4000 chars, ) ,
  • Streaming-Event des letzten SSE-Events enthält ein Schema-Feld, wenn aktiviert

Beispiele

  • Globale Einstellungen aktivieren
{
  "mostlylucid.mockllmapi": {
    "IncludeShapeInResponse": true
  }
}
  • Pro Anfrage einschalten
curl "http://localhost:5000/api/mock/users?shape=%7B%22id%22%3A0%2C%22name%22%3A%22string%22%7D&includeSchema=true"

Response enthält Header.:.

X-Response-Schema: {"id":0,"name":"string"}
  • Streaming-Event enthält Schema-Feld, wenn aktiviert
...
data: {"content":"{full json}","done":true,"schema":{"id":0,"name":"string"}}

Anmerkungen

  • Wenn keine Form zur Verfügung gestellt wurde, wird der Header nicht hinzugefügt
  • Very large forms -(> -4000Chars ,)- werden nicht zum Header hinzugefügt, um Transportprobleme zu vermeiden, aber die normale Reaktion geht weiter

Anwendungsfälle

  • Client-Generierung TypeScript
  • API-Dokumentation und Schemavalidierung
  • Debugging Form Parsing
  • Validierung der Laufzeit

Benutzerdefinierte Prompt-Vorlagen

Überschreiben Sie die Standard-Prompte mit Ihrem eigenen

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

Verfügbare Platzhalter

  • {method} HTTP-Methode zur Messung der POST-, usw..)
  • {path} Vollständiger Request-Pfad mit Query String
  • {body} Beantragen Sie die Stelle
  • {randomSeed} Generierter zufälliger Samen
  • {timestamp} Zeitstempel für Unix
  • {shape} Formspezifikation, sofern vorhanden

Fehlersimulation

Testen Sie Ihre Client-Fehlerbehandlung mit umfassenden Fehlersimulationsfunktionen

Vier Möglichkeiten, Fehler zu konfigurieren Vorrangige Reihenfolge:

  1. Abfrageparameter Höchste Priorität):

WICHTIGParameterwerte für Abfragen MUSS URL, -, codiert werden %20, & wird %26, : wird %3A,,, usw. , .

# 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 Verwendung $error Eigentum
# 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. Antragsstelle Verwendung error Eigentum
curl -X POST http://localhost:5000/api/mock/users \
  -H "Content-Type: application/json" \
  -d '{
    "error": {
      "code": 409,
      "message": "Conflict",
      "details": "User already exists"
    }
  }'

Formate für die Fehlerreaktion

Regelmäßiger /-Streaming Endpunkte

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

GraphQL-Endpunkt - :

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

SignalR-Fehlersimulation :

Konfigurieren von Fehlern in SignalR-Kontexten zum Testen der realen Fehlerbehandlung

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

Oder dynamisch über die Management-API.:

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

Unterstützte HTTP-Statuscodes

Das Paket enthält Standardmeldungen für gemeinsame HTTP-Statuscodes.

  • Client-FehlerNicht zugelassene MSK-Methode nicht erlaubt ),-408-MSC17-),-MSSK19-MS K20-MS-MSP21-MS422-MSG23-MSD25-MSH25-M429MSB26-MSZK27-MS
  • ServerfehlerNicht implementiert ),, nicht implementiert 502, schlechtes Gateway),, nicht verfügbar ),, nicht erhältlich 504, nicht vorhanden (, Torway Timeout)

Benutzerdefinierte Nachrichten und Details überschreiben die Standardwerte

Anwendungsfälle

  • Test-Client retry Logik und exponentielle Backoff
  • Anzeige der Fehlermeldung in UI bestätigen
  • Test-Authentifizierungsflüsse
  • Simulation von Zinsbegrenzungsszenarien
  • Üben anmutige Abbaumuster
  • Fehlerprotokollierung und -überwachung testen

Siehe LLMApi/LLMApi.http für umfassende Beispiele aller Fehlersimulationsmethoden

Mehrere Instanzen

Mehrere Mock-APIs mit verschiedenen Konfigurationen montieren

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

Beschreibung der Form

Drei Möglichkeiten zur Steuerung der Reaktionsstruktur

  1. Kopfzeile Zu empfehlende Maßnahme: X-Response-Shape: {"field":"type"}
  2. Abfrage-Param: ?shape=%7B%22field%22%3A%22type%22%7D (-URL---kodierte JSON-)-
  3. Körperfeld: {"shape": {...}, "actualData": ...}

Mehrere Reaktionen über Form caching

Sie können die Middleware anweisen, mehrere Reaktionsvarianten für eine bestimmte Anforderung vor dem - zu generieren und zwischenzuspeichern./Ausformung durch Hinzufügen eines speziellen Feldes innerhalb des Formobjekts

  • Der Cache-Schlüssel wird von der HTTP-Methode abgeleitet.+-Pfad..(.einschließlich Abfrage...). +. die sanitäre Form. (. mit entferntem ).
  • Bis zu N-Antworten werden aus dem LLM vorgefunden und in MaxCachePerKey gespeichert.
  • Nachfolgende nicht---Streaming-Anfragen für den gleichen Schlüssel werden aus einer erschöpfenden Warteschlange serviert, wenn ein frischer Stapel N erschöpft wird.
  • Streaming-Endpunkte werden nicht zwischengespeichert

Beispiele

  • Kopfform - : X---Response--Shape:-Shake{"$-Cache":3,"-OrderId":"-String","-Status":"-Strings","-Sitems":[{"-Sku":"-String, ","-Sqty":0}]}-Sk

  • Körperform { "-Form, ":-Form und MS-Form "$-Cache-":-5,- ," ,InvoiceId ,": , " ,String , ", , "-Kunden-":-{-M"-ID":-MSC5-String",-"-Name":-"-Strings"-MSSK11- ]"-Titems-":- [ {-"-":-M"-String",-"-qty-MSC6-0,MSSK8-Preis Gesamt-": } }

  • Abfrage-Param (-URL---kodiert ?-Shape-=%7-S%22%24-Sachverhalt%22%3-Sichter2%2-Sätze%22%3-Säulen%5-Single%7-Sandwich%22%3-Signiere0%2-Segment%22-Name%22%3-Sickel%22-Sortiments%22%7-D%5-D-Sack

Einrichtung

  • MaxCachePerKey Standard-,® Caps die von "$®cache angeforderte Anzahl pro Schlüssel

Anmerkungen

  • Der Hinweis "$ wird aus der Form entfernt, bevor er an das LLM-." gesendet wird.
  • Wenn "$-Cache, ", weggelassen wird oder 0,, verhält sich die Anfrage wie vor (, kein Caching, /, Warmup, MSC5
  • Cached-Varianten werden im Memory für die Lebensdauer der App aufbewahrt.Der Neustart von ; löscht den Cache.

Prüfung

Testen von Utilities-Paketen

Hauptsächlichlucid-.-Mockllmapi-.-Testing Ein Begleiter NuGet Paket, das Testen mit der Mock API noch einfacher macht

dotnet add package mostlylucid.mockllmapi.Testing

Schnelles Beispiel

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[]>();

Hauptmerkmale

  • Fließfähige APIEinfache Konfiguration mit WithShape(), WithError(), WithCache(),,, usw. , .
  • Integration von HttpClientFunktioniert nahtlos mit HttpClient und IHttpClientFactory
  • Mehrere EndpunkteKonfigurieren Sie verschiedene Verhaltensweisen für unterschiedliche Pfade
  • FehlersimulationTestfehlerbehandlung mit verschiedenen Statuscodes
  • Streaming-UnterstützungTesten Sie SSE-Streamingendpunkte
  • AbhängigkeitsinjektionUnterstützung für typisierte und benannte Clients

Konfigurationsbeispiele

// 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(...))
);

Wie es funktioniert Das MockLlmHttpHandler ist ein DelegatingHandler die HTTP-Anfragen abfangen und Ihre Konfiguration automatisch über Abfrageparameter und Header vor der Weiterleitung an die Mock API anwenden. Dies bedeutet, dass Sie real verwenden können HttpClient Instanzen in Ihren Tests bei der Steuerung des Mockverhaltens deklarativ

Siehe Testpaket README für komplette Dokumentation und Beispiele

HTTP-Dateiprüfung

Nutzen Sie die enthaltenen LLMApi.http Datei mit„:"

  • Visual Studio HTTP-Client für Rider
  • VS Code REST Client Erweiterung
  • Jeder HTTP-Client

Einzelprüfungen

Das Projekt umfasst umfassende Unit-Tests.

# Run all tests
dotnet test

# Run with detailed output
dotnet test --verbosity detailed

Prüfungsabdeckung (228-Tests ,-Test 100%-Passrate ):-Test

  • Körperlesung (-Lempty-,-JSON-Inhalte-,-Formkörper-Datei Uploads-)-
  • Formkörperparsing Einzelwerte, Mehrfachwerte, Sonderzeichen
  • Mehrteilige Formulardaten Datei-Metadaten metadaten MSA-Mischfelder und -Dateien MSA
  • JSON flüchtet (-Zitate,-Rückschläge,-Neulinien,-Registerblätter,-Unicode,-Emoji-)
  • Extraktion von Inhalten (-OpenAI-Format - Komplexe verschachtelte JSON-,-Fehlerbehandlung
  • Manuelle JSON-Konstruktion (-Formdaten,-Arrays,-Verschachtelte Strukturen
  • Formenextraktion ](-Query param ®,-Header ?,-Körperfeld Â,-Prioritäts-)-
  • Prompte Generation Zufälligkeit, Formeinschluss, Streaming-Modi, )
  • Gebäude anfordern (-Temperatur-,-Modell-,-Nachrichten
  • Kantenfälle Nichtzutreffendes streichen.
  • Integrationsprüfungen Vollständiger HTTP-Workflow, Formulareinreichungen, Dateiuploads, Tiefenpfade)

Neu in v.2.3.0:-

  • FormKörperHandhabungPrüfungen Tests für Formkörperparsing und JSON-Konstruktion
  • JsonHandlingTests-.cs Tests für JSON-Extraktion und Kantenfälle
  • Integrationstests - .-cs Integrationstestrahmen für vollständige HTTP-Endpunktprüfung

Siehe PRÜFUNG _-ZUSAMMENFASSUNG für vollständige Testdokumentation und Abdeckungsmetriken

Architektur

Siehe Architektur im Überblick oben für das Systemdiagramm und die Komponentenbeschreibung auf hoher Ebene

Detaillierte Anfrage Fluss

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

Formregelungsfluss

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

Projekte

  • mostlylucid.mockllmapiSoftware-Paketbibliothek für NuGet
  • LLMApiDemo-Anwendung
  • LLMApi.Tests:- xUnit Test Suite Tests -- xunit-Tests 100%-Passrate

Warum verwenden Sie meistlucid ,. , mockllmapi , ? ,

  • Schnelles PrototypingWeiterentwicklung des Frontends ohne Warten auf Backend
  • Vollständige HTTP-UnterstützungDatei-Uploads für alle erfassten Inhaltstypen
  • Konsequente WorkflowsAPI-Kontexte pflegen realistische Beziehungen über mehrstufige Prozesse hinweg
  • Demonstrationen.: . Zeigen Sie realistische Datenströme ohne fest codierte Vorrichtungen
  • PrüfungErzeugen von abwechslungsreichen Testdaten für Randfälle oder konsistente Daten mit Kontexten
  • Speicher , - , sicherDatei-Uploads gestreamt und abgeladen - , getestet mit Dateien von 100 , MB , + ,
  • API-DesignExperimentieren Sie mit Antwortformen vor der Implementierung
  • LernenBeispiel für die LLM-Integration in minimalen APIs
  • Null WartungKeine Datenbank keine Datendateien zu pflegen
  • FlexibelVerwenden Sie eine beliebige Kombination von REST.,. GraphQL.,. SSE.MSC3. SignalR.MS K4 oder OpenAPI-Spezifikationen
  • Produktion ,- , fertig:-Tests,-Testtests100%-Passrate,- umfassende Dokumentation

Aufbau des NuGet-Pakets

cd mostlylucid.mockllmapi
dotnet pack -c Release

Paket wird in sein bin/Release/mostlylucid.mockllmapi.{version}.nupkg

Beitrag

Dies ist ein Beispielprojekt, das LLM---powered Mock APIs demonstriert.

Lizenz

Dies ist freie und unbelastete Software, die in der Public Domain veröffentlicht wird. LIZENZ für Details oder Besuch unlizenziert ,. ,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.