# LLMApi-:-Verwendung lokaler LLMs zur automatischen Simulierung von APIs in ASP..-NET Core MinimalAPI
2025-11-02T12:30
# 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
[](https://www.nuget.org/packages/mostlylucid.mockllmapi)
[](https://www.nuget.org/packages/mostlylucid.mockllmapi)
Sie können die[ GitHub hier ](https://github.com/scottgal/LLMApi)für das Projekt – alle öffentlichen Bereiche usw. –
[TOC]
# 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.[LucidForums](https://github.com/scottgal/lucidforums)Ein 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...
[](https://www.nuget.org/packages/mostlylucid.mockllmapi)
[](https://www.nuget.org/packages/mostlylucid.mockllmapi)
[](https://github.com/scottgal/LLMApi/releases)
[](http://unlicense.org/)
**Companion-Paket - :** [Hauptsächlichlucid-.-Mockllmapi-.-Testing](https://github.com/scottgal/LLMApi/blob/refs/heads/master/mostlylucid.mockllmapi.Testing/README.md) Testen von Dienstprogrammen mit fließender HttpClient-Integration
---
## Wie man diese README liest
Diese README ist durch Design umfassend Wählen Sie Ihren Pfad
- **Ich möchte dies in Minuten versuchen.** Zu springen [Schnellstart](#quick-start)
- **Ich möchte wissen, was dies tun kann** Siehe auch: [Merkmale im Überblick](#features) und [Architektur](#architecture)
- **Ich möchte verstehen, wie es funktioniert.** Lesen [Feature Dokumentation](#feature-documentation) und [Erweiterte Funktionen](#advanced-features)
---
## 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
**Schwerpunkt**Sicherheitsverbesserungen 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/TEST_SUMMARY.md)
Click for detailed v2.3.0 feature breakdown
### Details zur Version
**Schwerpunkt**Komplette 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/TEST_SUMMARY.md)
Click for detailed v2.2.0 feature breakdown
### Details zur Version
**Schwerpunkt**Pluggable 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/TOOLS_ACTIONS.md)
**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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/TOOLS_ACTIONS.md), [Begrenzung der Steuersätze](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/RATE_LIMITING_BATCHING.md)L 347 vom 20.12.2013, S. 671. [API Kontexte](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md).
[Siehe RELEASE-_-NOTES-.-md für vollständige Details](https://github.com/scottgal/LLMApi/blob/refs/heads/master/RELEASE_NOTES.md)
---
## Inhaltsverzeichnis
### Kernkonzepte
- [Merkmale im Überblick](#features) Was dieses System tun kann
- [Schnellstart](#quick-start) Starten Sie in Minuten
- [Architektur](#architecture) Wie alles zusammenpasst
- [Nicht---Ziele](#non-goals--boundaries) Was ist das?
### Protokolle Merkmale
- [REST API Mocking](#1-rest-api-mocking)
- [GraphQL API Mocking](#graphql-api-mocking)
- [SSE-Streaming](#3-server-sent-events-sse-streaming)
- [SignalR Real---Zeit](#signalr-real-time-data-streaming)
- [OpenAPI-Swagger](#openapi--swagger-mock-generation)
- [gRPC-Dienstleistungen](#6-grpc-service-mocking-new-in-v170)
### Erweiterte Architektur
- [Einstellungen](#configuration-options)
- [Feature Dokumentation](#feature-documentation) In---Tiefe-Führungen
- [Erweiterte Funktionen](#advanced-features)
- [Demo-Anwendungen](#demo-applications)
- [Prüfung](#testing)
---
## 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:
```mermaid
graph LR
Client[Client] -->|HTTP Request| API[LLMApi
Minimal API]
API -->|Chat Completion| Ollama[Ollama API
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-Client**Alle Protokolle verwenden die gleiche LLM-Integration mit Resilienzrichtlinien
- **Gemeinsamer Kontextspeicher**API-Kontexte arbeiten über REST-, , GraphQL ,, , SignalR., und OpenAPI
- **Gemeinsame Merkmale**Die Geschwindigkeitsbegrenzung von ,, das Caching, die Fehlersimulation von, und das Tokenmanagement gelten für alle
- **Modulares Design**Verwenden Sie eine beliebige Kombination, nur das hinzufügen, was Sie brauchen
Siehe [detaillierte Architekturdiagramme](#architecture) unten für Anforderungsfluss und Formregelung
---
## Merkmale
Dieses Paket bietet **sechs unabhängige Merkmale** Verwenden Sie jede Kombination, die Sie benötigen [Modulare Beispiele](https://github.com/scottgal/LLMApi/blob/refs/heads/master/MODULAR_EXAMPLES.md) für Protokoll---spezifische Setups
### REST API Mocking
- **Super einfach**: `AddLLMockApi()` + `MapLLMockApi("/api/mock")` Sofortige Mock-API
- **Formregelung**Geben Sie die genaue JSON-Struktur über den Header an.
- **Alle HTTP-Methoden**:-Unterstützt GETC,-POST-,-PUT-,-DELETE,-PATCH
- **Wildcard Routing**Jeder Pfad unter dem gewählten Endpunkt funktioniert
- **Vollständiger Inhaltstyp Support** ,( ,NEW in %
- **JSON** (`application/json`Standard-JSON-Anforderungsstellen
- **Formkörper** (`application/x-www-form-urlencoded`Einreichung von HTML-Formularen
- **Dateiuploads** (`multipart/form-data`Datei-Uploads mit Metadatenextraktion
- **Speicher , - , sicher**Dateiinhalt gestreamt und versenkt Nur Metadaten erhalten
- **Willkürliche Pfadlängen**Tiefenpfad-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 Formen**Die GraphQL-Abfrage selbst definiert die Antwortstruktur
- **Variablen Operationen**Volle Unterstützung für Variablen, , und Fragmente
- **Richtige Fehlerbehandlung**-: , gibt GraphQL ,- formatierte Fehler mit `data` und `errors` Felder
### Server-Ausgesandte Ereignisse
- **Progressives Streaming**SSE-Unterstützung mit progressiver JSON-Generation
- **Echtzeit-Updates**Daten Token streamen-von -Token an Clients
- **Alleinstehende Werke**Keine REST API-Einrichtung erforderlich
- **[Vollständiger SSE-Leitfaden](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/SSE_STREAMING_MODES.md)** | **[Kontinuierliches Streaming](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/CONTINUOUS_STREAMING.md)**
### SignalR Echtzeit-Streaming
- **WebSocket Streaming**Kontinuierliche Echtzeit---Zeitmockdaten über SignalR
- **Mehrere Kontexte**Ausführen mehrerer unabhängiger Datenströme gleichzeitig
- **Lebenszyklusmanagement**Starten von /Stop-Kontexten dynamisch mit Management API
- **Alleinstehende Werke**Keine REST API-Einrichtung erforderlich
- **[SignalR-Demohandbuch](https://github.com/scottgal/LLMApi/blob/refs/heads/master/SIGNALR_DEMO_GUIDE.md)**
### OpenAPI - Swagger Mock Generation
- **Automatische Endpoint-Generierung**Hinweis auf eine beliebige OpenAPI, / oder Datei
- **Alle Operationen gedämpft**Jeder Pfad und jede Methode aus der Spezifikation wird zu einem Live-Endpunkt
- **Schema---Antriebsdaten**LLM erzeugt realistische Daten, die Ihren Schemas entsprechen
- **Mehrere Specs**Beladen und Montieren mehrerer API-Spezifikationen gleichzeitig
- **Alleinstehende Werke**Keine REST API-Einrichtung erforderlich
- **[Anleitung für OpenAPI-Funktionen](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/OPENAPI-FEATURES.md)**
### GRPC Service Mocking Macking MACKing M('NEW in v.1.7.0)"
- **Protokolldatei hochladen**Hochladen von Dateien zum Generieren von gRPC-Diensten
- **Unterstützung für Doppelprotokolle**JSON über HTTP zum Testen von Binär-Protobuf für die Produktion
- **Dynamische Serialisierung**Laufzeit Protobuf-Kodierung ohne Codegenerierung
- **LLM.-.Powered Data**Realistische Antworten passend zu Ihren Proto-Meldungsdefinitionen
- **Alleinstehende Werke**Keine REST API-Einrichtung erforderlich
- **[gRPC-Unterstützungshandbuch](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/GRPC_SUPPORT.md)**
### Gemeinsame Merkmale
- **Konfigurierbar**Konfiguration der Appsettings von ., Json oder Inline
- **Hochvariable Daten**Jede Anfrage erzeugt völlig unterschiedliche realistische Daten
- **NuGet-Paket**Bequeme Ergänzung zu bestehenden Projekten
- **AutoShape-Speicher für (-Formen**Die 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](#autoshape-shape-memory)**
- **API Kontexte**Pflege der Konsistenz über verwandte Anfragen hinweg **[Vollständiger Leitfaden](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)**
- **Fehlersimulation**Umfassende Fehlerprüfung mit den Statuscodes von /5xx und mehreren Konfigurationsmethoden
- **Prüfung von Versorgungseinrichtungen**Paket mit Begleitpersonen `mostlylucid.mockllmapi.Testing` für einfache HttpClient-Integration in Tests **[Siehe Abschnitt „Prüfung"](#testing)**
---
## 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/DOCKER_GUIDE.md)** 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/BACKEND_API_REFERENCE.md)** 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/MULTIPLE_LLM_BACKENDS.md)** 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)** ,- , 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/RATE_LIMITING_BATCHING.md)** 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/TOOLS_ACTIONS.md)** 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/GRPC_SUPPORT.md)** 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/OPENAPI-FEATURES.md)**
- 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/MODULAR_EXAMPLES.md)**
- REST---only,-GraphQL---onally,-SignalR.--Setups
- Strategien zur Speicheroptimierung
- Protokolle mischen und anpassen
- **[SignalR-Demohandbuch](https://github.com/scottgal/LLMApi/blob/refs/heads/master/SIGNALR_DEMO_GUIDE.md)**
- Echtzeit-Datenstreaming-Einrichtung
- Kontext Lebenszyklus-Management
- Beispiele für die Client-Verbindung
- **[Freigabehinweise](https://github.com/scottgal/LLMApi/blob/refs/heads/master/RELEASE_NOTES.md)**
- Vollständige Versionshistorie
- Breaking-Änderungen seit v-1.0!)
- Migrationsleitfäden
- **[Zusammenfassung der Prüfung](https://github.com/scottgal/LLMApi/blob/refs/heads/master/TEST_SUMMARY.md)** NIEDERLANDE
- Vollständige Dokumentation der Prüfabdeckung
- Tests mit detaillierter Aufschlüsselung
- Leistungskennzahlen und Validierung
- Alle erklärten Testkategorien
- **[Zusammenfassung der Umsetzung](https://github.com/scottgal/LLMApi/blob/refs/heads/master/IMPLEMENTATION_SUMMARY.md)** 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„:"**
```bash
dotnet add package mostlylucid.mockllmapi
```
**Testen von Versorgungseinrichtungen (MSK)**
```bash
dotnet add package mostlylucid.mockllmapi.Testing
```
> Bietet fließende API für einfache HttpClient-Konfiguration in Tests. [Siehe Abschnitt „Prüfung"](#testing) für Details
### Schnelles Starten mit Docker
Der schnellste Weg, um begonnen zu bekommen, keine Installation erforderlich
```bash
# 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/DOCKER_GUIDE.md)** 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](https://dotnet.microsoft.com/download/dotnet/8.0) oder später
2. Installieren [Ollama](https://ollama.ai/) und ziehen Sie ein Modell.
```bash
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
```bash
ollama pull ministral-3:3b
```
```json
{
"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 –:-**
```bash
ollama pull mistral-nemo
```
```json
{
"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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/MULTIPLE_LLM_BACKENDS.md#ollama-context-window-configuration))
- Am besten für komplexe verschachtelte Strukturen und große Datensätze
- Mehr kreative Variation der generierten Daten
- **Anmerkung**Benötigt mehr Ressourcen
#### Spezifische Konfiguration des Modells
**Für Ministrale , -3:3 , b ,( , empfohlen , - , default , ): ,**
```json
{
"ModelName": "ministral-3:3b",
"Temperature": 1.2,
"MaxContextWindow": 262144 // 256K context window
}
```
**für Gemma-3:4-b oder Lama-3:-**
```json
{
"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**
```json
{
"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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/MULTIPLE_LLM_BACKENDS.md#ollama-context-window-configuration) für Kontexte der ,128'K'
**Wo finden Sie MaxContextWindow?**
```bash
# Check model info
ollama show {model-name}
# Look for "context_length" or "num_ctx" parameter
# Example output: "context_length": 8192
```
**Für kleinere Modelle**
```json
{
"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
```bash
# 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`, `phi3`Arbeit, 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-:-**
```csharp
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-:-**
```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
```http
# First request - generates free-form response
GET /api/mock/users/123
Response: {"id": 123, "name": "Alice", "email": "alice@example.com", "role": "admin"}
# Second request - automatically uses same structure
GET /api/mock/users/456
Response: {"id": 456, "name": "Bob", "email": "bob@example.com", "role": "user"}
# All subsequent requests use the same schema!
GET /api/mock/users/789
Response: {"id": 789, "name": "Carol", "email": "carol@example.com", "role": "manager"}
```
### Einrichtung
**Standardmäßig aktiviert** in der `appsettings.json`:
```json
{
"MockLlmApi": {
"EnableAutoShape": true, // Default: true
"ShapeExpirationMinutes": 15 // Default: 15
}
}
```
### Steuerung für Per---Anfragen
**Deaktivieren Sie für spezifische Anforderungen**
```http
GET /api/mock/users/special?autoshape=false
```
**Erneuern Sie eine schlechte Form**
```http
# 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}`):
```http
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**
```http
GET /api/mock/users/1?renewshape=true
```
**Alle Formen programmatisch löschen**
```csharp
// Inject AutoShapeManager
autoShapeManager.ClearAllShapes();
```
Für eine vollständige Dokumentation siehe: [CLUDE-.-md AutoShape Abschnitt](https://github.com/scottgal/LLMApi/blob/refs/heads/master/CLAUDE.md#autoshape-feature-shape-memory).
**Testabdeckung** Tests, die alle autoshape Funktionalitäten abdecken
## Einstellungen
> **Vollständige Konfigurationsreferenz** Siehe [Referenzhandbuch für die Konfiguration](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/CONFIGURATION_REFERENCE.md) für alle Optionen
> **Vollständiges Beispiel** Siehe [Appsettings.-Full-.-Json](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMApi/appsettings.Full.json) -® zeigt **jedes** Konfigurationsoption
### Über die Appsettings....-json...Empfohlene Version...
```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„-"Spezifische Token-Grenzwerte**Siehe 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 Kontexte**Für detaillierte Informationen über die Verwendung von Kontexten, um Konsistenz über Anfragen zu erhalten . . **[API Kontext-Leitfaden](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)**.
### 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**
```json
{
"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
```csharp
builder.Services.Addmostlylucid.mockllmapi(options =>
{
options.BaseUrl = "http://localhost:11434/v1/";
options.ModelName = "mixtral";
options.Temperature = 1.5;
options.TimeoutSeconds = 60;
});
```
### Benutzerdefinierte Endpunktmuster
```csharp
// 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
```bash
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**
```bash
curl -X POST http://localhost:5000/api/mock/users/register \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "username=john_doe&email=john@example.com&age=30"
```
Die Formulardaten werden automatisch in JSON konvertiert und zur realistischen Reaktionsgenerierung an die LLM übergeben.
**Form mit mehreren Werten**
```bash
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**
```bash
curl -X POST http://localhost:5000/api/mock/photos/upload \
-F "title=My Photo" \
-F "description=Beautiful sunset" \
-F "image=@photo.jpg"
```
**Mehrere Dateien mit Formdaten ,:**
```bash
curl -X POST http://localhost:5000/api/mock/documents/bulk \
-F "title=Multiple uploads" \
-F "file1=@document1.pdf" \
-F "file2=@document2.pdf"
```
**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**
```json
{
"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**
```bash
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.**
```bash
# 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)** für komplette Beispiele
### Mit Shape Control
```bash
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.**
```csharp
// SSE streaming is automatically available at /api/mock/stream/**
app.MapLLMockApi("/api/mock", includeStreaming: true);
```
**Verwendung**
```bash
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**
```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**
```bash
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.
```csharp
app.MapLLMockApi("/api/mock", includeGraphQL: true); // GraphQL enabled by default
```
Dies erzeugt einen GraphQL-Endpunkt bei `/api/mock/graphql`.
### Grundlegende Verwendung
**Einfache Abfrage**
```bash
curl -X POST http://localhost:5000/api/mock/graphql \
-H "Content-Type: application/json" \
-d '{"query": "{ users { id name email role } }"}'
```
**Ansprechrate**
```json
{
"data": {
"users": [
{ "id": 1, "name": "Alice Johnson", "email": "alice@example.com", "role": "admin" },
{ "id": 2, "name": "Bob Smith", "email": "bob@example.com", "role": "user" }
]
}
}
```
### Mit Variablen
```bash
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
```graphql
{
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
```javascript
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
```json
{
"data": null,
"errors": [
{
"message": "Invalid GraphQL request format",
"extensions": {
"code": "INTERNAL_SERVER_ERROR"
}
}
]
}
```
### Wie es funktioniert
1. **Parse-Antrag**Extrahieren Sie GraphQL-Abfrage und den Namen der Operation.
2. **Prompt erstellen**Senden Sie die Abfragestruktur an das LLM mit Anweisungen, um passende Daten zu generieren
3. **Daten generieren**LLM erstellt realistische Daten, die exakt zu den Abfragefeldern passen
4. **Wrap Response**Gibt Daten im GraphQL-Format zurück `{ "data": {...} }`
### Die wichtigsten Vorteile
- **Keine Formspezifikation erforderlich**Die GraphQL-Abfrage definiert die Struktur
- **Typ Sicherheit**Fragefelder explizit nach Namen anfordern
- **Verschachtelte Beziehungen**Natürliche Unterstützung für komplexe, verschachtelte Datenstrukturen
- **Standardformat**Funktioniert mit jeder GraphQL-Clientbibliothek
- **Realistische Daten**LLM 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMApi/LLMApi.http#L229-L294) für komplette Arbeitsbeispiele
### GraphQL-Konfiguration
#### Token Limits und Modellauswahl
GraphQL-Antworten können mit tief verschachtelten Abfragen groß werden. `GraphQLMaxTokens` Option „:"
```json
{
"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**
```json
{
"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**
```csharp
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.
```csharp
// 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**
```json
{
"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**
```javascript
// 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
```json
{
"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.
```json
{
"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
```bash
POST /api/mock/contexts
Content-Type: application/json
{
"name": "crypto",
"description": "Cryptocurrency prices with symbol, USD price, 24h change percentage, and market cap"
}
```
Ansprechrate
```json
{
"message": "Context 'crypto' registered successfully",
"context": {
"name": "crypto",
"description": "Cryptocurrency prices...",
"method": "GET",
"path": "/crypto",
"shape": "{...generated JSON schema...}",
"isJsonSchema": true
}
}
```
#### Alle Kontexte auflisten
```bash
GET /api/mock/contexts
```
Ansprechrate
```json
{
"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
```bash
GET /api/mock/contexts/weather
```
Ansprechrate
```json
{
"name": "weather",
"method": "GET",
"path": "/weather/current",
"shape": "{\"temperature\":0,\"condition\":\"string\"}",
"isJsonSchema": false
}
```
#### Kontext löschen
```bash
DELETE /api/mock/contexts/crypto
```
Ansprechrate
```json
{
"message": "Context 'crypto' deleted successfully"
}
```
#### Ausgangskontext Datengenerierung fortsetzen)
```bash
POST /api/mock/contexts/crypto/start
```
Ansprechrate
```json
{
"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
```bash
POST /api/mock/contexts/crypto/stop
```
Ansprechrate
```json
{
"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
```html
Live Weather Data
```
### Dynamische Kontexterstellung aus der Benutzeroberfläche
```javascript
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
```javascript
{
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
```javascript
{
context: "weather",
message: "Subscribed to weather"
}
```
**Abonniert** Bestätigung der Abmeldung
```javascript
{
context: "weather",
message: "Unsubscribed from weather"
}
```
### Einstellungen
```json
{
"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**
```json
{
"Name": "users",
"Shape": "{\"id\":0,\"name\":\"string\",\"email\":\"string\"}"
}
```
**JSON-Schema-:**
```json
{
"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`, `type`mit einem Quadratmetergewicht von mehr als 1 kg `properties` felds-.-
### Architektur
```mermaid
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 :"**
- **MockLlmHub**SignalR-Hubbearbeitung von Clientverbindungen und Abonnements
- **MockDataBackgroundService**Gehosteter Service, der kontinuierlich Daten generiert
- **DynamicHubContextManager**Sicherheitsmanager für die Laufzeit-Kontextregistrierung
- **HubContextConfig**Konfigurationsmodell für jeden Datenkontext
### Anwendungsfälle
**Dashboard-Prototyping**
```javascript
// 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**
```json
{
"Name": "sensors",
"Description": "IoT temperature sensors with device ID, current temperature, battery percentage, and signal strength",
"Path": "/iot/sensors"
}
```
**Finanzdaten**
```json
{
"Name": "trading",
"Description": "Real-time stock trades with timestamp, symbol, price, volume, and buyer/seller IDs",
"Path": "/trading/live"
}
```
**Spielendes Leaderboard**
```json
{
"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ählen**Anzahl der aktuell angeschlossenen Clients
Kontexte können in zwei Zuständen sein
- **Aktiv**Hintergrunddienst erzeugt neue Daten jeder `SignalRPushIntervalMs` ,( , default , : , 5 , sekunden , )
- **Angehalten**Kontext 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üllung**Erzeugt Antworten auf einmal, die über `MaxCachePerKey`)
- **Kontext Warteschlangen**Jeder Kontext pflegt seinen eigenen Cache von vor- und generierten Antworten
- **Hintergrund Nachfüllen**Der Cache wird automatisch nachgefüllt, wenn er unter die Kapazität des Speichers fällt.
- **Intelligente Planung**Minimiert LLM-Aufrufe unter Beibehaltung der Datenfrischheit
Dies reduziert die LLM-Last für hochfrequente Kontexte, besonders bei mehreren Clients,
**Beispiel Workflow - :**
```bash
# 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
```bash
dotnet add package mostlylucid.mockllmapi
```
**Programm .-cs-:-**
```csharp
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-:-**
```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 Laden**Ladet OpenAPI-Spezifikationen aus URLs oder lokalen Dateien.
2. **Schemaumwandlung**Umwandelt OpenAPI-Schemas in JSON-Formvorlagen
3. **Endpunkt-Mapping**Alle Operationen automatisch auf ASP-.-NET Core-Endpunkte abbilden
4. **Erzeugung von LLM**Verwendet LLM, um realistische Mock-Daten zu erzeugen, die dem Schema entsprechen
5. **Pfadparameter**Behandelt 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**
```json
{
"Name": "petstore",
"Source": "https://petstore3.swagger.io/api/v3/openapi.json",
"IncludeTags": ["pet", "store"]
}
```
**Filtern nach Pfaden**
```json
{
"Name": "api",
"Source": "./specs/api.yaml",
"IncludePaths": ["/users/*", "/products/*"],
"ExcludePaths": ["/admin/*"]
}
```
**Streaming aktivieren**
```json
{
"Name": "api",
"Source": "./specs/api.yaml",
"BasePath": "/api",
"EnableStreaming": true
}
```
### Testen von OpenAPI Mocks
Angesichts dieser OpenAPI-Spezifikationskonfiguration
```json
{
"Name": "petstore",
"Source": "./specs/petstore.json",
"BasePath": "/petstore"
}
```
Und eine Spezifität definieren `GET /pet/{petId}` die eine `Pet` Objekt: ,, du kannst testen :,
```bash
# 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.:-
```csharp
// 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-Generierung**Alle Pfade und Operationen von Spec werden zu Mockendpoints
- **Schema---getrieben**Aus OpenAPI-Antwortschemas abgeleitete Antwortformen
- **Pfadparameter**Griffe `/users/{id}`, `/posts/{postId}/comments/{commentId}`,,, usw. , .
- **Mehrere Specs**Beladen und Montieren mehrerer API-Spezifikationen gleichzeitig
- **Intelligente Filterung**Einschließen von Operationen durch Tags oder Pfade
- **Streaming-Unterstützung**Optionales SSE-Streaming für jeden Endpunkt
- **LLM.-.Powered**Erzeugt realistische, abwechslungsreiche Daten für jedes Schema
### Anwendungsfälle
- **API.-.Erste Entwicklung**Starten Sie die Codierung gegen Spec, bevor das Backend fertig ist
- **Frontend Prototyping**Entwickeln Sie Benutzeroberfläche, während API gebaut wird
- **Integrationsprüfung**Testen Sie den Clientcode ohne echte API-Abhängigkeiten
- **Demoumgebungen**Vorzeigeapps ohne API-Zugriff in der Produktion
- **Vertragsprüfung**Überprüfe, ob alle Schemavariationen korrekt behandelt werden
- **Belastungsprüfung**Erzeugen 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**:
```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"
}
```
Siehe das vollständige [Geschäftsführung: http:www.msk.org/](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMApi/management.http) 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-Client`LLMockApiClient/`WPF-Anwendung in der Entwicklung
> **ENTWICKLUNGSSTATUS**Der 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**
- **Dashboard**Echtzeit-Verbindungsstatus und Systemüberwachung
- **SignalR Real---Zeit**Kontexte erstellen und Live-Datenströme abonnieren
- **SSE-Streaming**3 Streaming-Modi (Tokens,« Objekte,« Array-Elemente)«
- **OpenAPI-Manager**Belastungsspezifikationen aus den Testendpunkten von URL-/.JSON-MSC2.
- **gRPC-Dienstleistungen**Testen Sie die gRPC-Methoden
- **Mit APIs abspielen**Interaktiver HTTP-Testspielplatz
- **Unterstützung für Multi---Backends**Konfigurieren und Umschalten zwischen mehreren Backends
- **Verkehrsüberwachung**Live-HTTP-Request-Antwortprotokollierung
- **Dark-/-Licht-Design**Umschalten zwischen Themen mit glatten Übergängen
**Dokumentation** [LLMockApiClient README](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMockApiClient/README.md)
**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 erstellen**Das 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-Datenfeld**Echtzeit-Updates aus abonnierten Kontexten
- **JSON Syntax Hervorhebung**Schö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 Sensoren**Temperaturfühler mit Geräte-ID, ,, Messwerte, Batterieanteil
- **Aktienmarkt**Reale Preise mit Ticker , , , Preis ,, , Veränderung in Prozent , , , Volumen
- **Aufträge für den Handel**Bestellungen mit ID., customer; , items array; MSV3 status; MSC4 assem
- **Server-Metriken**Überwachen von Daten mit Hostname: ,, CPU: ,, Speicher: MSC3, Festplatte: ,, Verbindungen
- **Gaming Leaderboard**Spieler-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
- **Benutzerliste**Array von Benutzerobjekten mit ID-ID-,-Namen
- **Produktkatalog**Produktbestand mit Artikel-Nr.: ,, Name: ,, Preis:,, Lagerbestand:
- **Einzelheiten zur Bestellung**Verschachtelte Bestellungen mit Kundeninformationen und Artikel-Array
- **Wetterdaten**Aktuelle 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`/OpenApi`Dynamische Spec-Belastung
**Neue Funktion** Interaktives OpenAPI-Spezifikationsmanagement mit Echtzeit-Updates
**Merkmale**
- **Technische Daten dynamisch laden**Aus URL oder Roh einfügen JSON-/.YAML direkt im Browser
- **Echtzeit-Updates**SignalR.- mit Live-Benachrichtigungen für alle Aktionen
- **Endpoint Discovery**Automatische Extraktion aller Operationen aus Spec
- **Prüfung des In---Browsers**Testen Sie jeden Endpunkt mit einem Klick.,. Siehe LLM.MSC2.generierte Mock-Daten
- **Lebenszyklusmanagement**Daten löschen ohne Server neu starten
- **Schöne Benutzeroberfläche**Farbige HTTP-Methoden – -, kodierte HTTP-Verfahren – MSV2, Syntax – MSC3, hervorgehobene JSON-Antworten
- **Verbindungsstatus**Live-Anzeige zeigt SignalR-Verbindungszustand
- **Umfassende Hilfe**Inline 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**
```bash
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
```json
{
"mostlylucid.mockllmapi": {
"IncludeShapeInResponse": true
}
}
```
- Pro Anfrage einschalten
```bash
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
```json
{
"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):
**WICHTIG**Parameterwerte für Abfragen MUSS URL, -, codiert werden `%20`, `&` wird `%26`, `:` wird `%3A`,,, usw. , .
```bash
# 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"
```
2. **HTTP-Header**:
```bash
curl -H "X-Error-Code: 401" \
-H "X-Error-Message: Unauthorized" \
-H "X-Error-Details: Token expired" \
http://localhost:5000/api/mock/users
```
3. **Form JSON** Verwendung `$error` Eigentum
```bash
# 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"
```
4. **Antragsstelle** Verwendung `error` Eigentum
```bash
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
```json
{
"error": {
"code": 404,
"message": "Not Found",
"details": "Optional additional context"
}
}
```
GraphQL-Endpunkt - :
```json
{
"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
```json
{
"HubContexts": [
{
"Name": "errors",
"Description": "Error simulation stream",
"ErrorConfig": {
"Code": 500,
"Message": "Server error",
"Details": "Database connection lost"
}
}
]
}
```
Oder dynamisch über die Management-API.:
```bash
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-Fehler**Nicht zugelassene MSK-Methode nicht erlaubt ),-408-MSC17-),-MSSK19-MS K20-MS-MSP21-MS422-MSG23-MSD25-MSH25-M429MSB26-MSZK27-MS
- **Serverfehler**Nicht 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
```csharp
// 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
```bash
dotnet add package mostlylucid.mockllmapi.Testing
```
**Schnelles Beispiel**
```csharp
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();
```
**Hauptmerkmale**
- **Fließfähige API**Einfache Konfiguration mit `WithShape()`, `WithError()`, `WithCache()`,,, usw. , .
- **Integration von HttpClient**Funktioniert nahtlos mit `HttpClient` und `IHttpClientFactory`
- **Mehrere Endpunkte**Konfigurieren Sie verschiedene Verhaltensweisen für unterschiedliche Pfade
- **Fehlersimulation**Testfehlerbehandlung mit verschiedenen Statuscodes
- **Streaming-Unterstützung**Testen Sie SSE-Streamingendpunkte
- **Abhängigkeitsinjektion**Unterstützung für typisierte und benannte Clients
**Konfigurationsbeispiele**
```csharp
// 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(
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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/mostlylucid.mockllmapi.Testing/README.md) 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.
```bash
# 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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/TEST_SUMMARY.md) für vollständige Testdokumentation und Abdeckungsmetriken
## Architektur
Siehe [Architektur im Überblick](#architecture-overview) oben für das Systemdiagramm und die Komponentenbeschreibung auf hoher Ebene
### Detaillierte Anfrage Fluss
```mermaid
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
```mermaid
flowchart TD
Start[Request Arrives] --> CheckQuery{Shape in
Query Param?}
CheckQuery -->|Yes| UseQuery[Use Query Shape]
CheckQuery -->|No| CheckHeader{Shape in
Header?}
CheckHeader -->|Yes| UseHeader[Use Header Shape]
CheckHeader -->|No| CheckBody{Shape in
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
+ Timestamp]
AddRandom --> SendLLM[Send to LLM]
style UseQuery fill:#4CAF50
style UseHeader fill:#4CAF50
style UseBody fill:#4CAF50
style NoShape fill:#FFC107
```
**Projekte**
- `mostlylucid.mockllmapi`Software-Paketbibliothek für NuGet
- `LLMApi`Demo-Anwendung
- `LLMApi.Tests`:- xUnit Test Suite Tests -- xunit-Tests 100%-Passrate
## Warum verwenden Sie meistlucid ,. , mockllmapi , ? ,
- **Schnelles Prototyping**Weiterentwicklung des Frontends ohne Warten auf Backend
- **Vollständige HTTP-Unterstützung**Datei-Uploads für alle erfassten Inhaltstypen
- **Konsequente Workflows**API-Kontexte pflegen realistische Beziehungen über mehrstufige Prozesse hinweg
- **Demonstrationen**.: . Zeigen Sie realistische Datenströme ohne fest codierte Vorrichtungen
- **Prüfung**Erzeugen von abwechslungsreichen Testdaten für Randfälle oder konsistente Daten mit Kontexten
- **Speicher , - , sicher**Datei-Uploads gestreamt und abgeladen - , getestet mit Dateien von 100 , MB , + ,
- **API-Design**Experimentieren Sie mit Antwortformen vor der Implementierung
- **Lernen**Beispiel für die LLM-Integration in minimalen APIs
- **Null Wartung**Keine Datenbank keine Datendateien zu pflegen
- **Flexibel**Verwenden 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
```bash
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](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LICENSE) für Details oder Besuch [unlizenziert ,. ,org](https://unlicense.org).