Back to "LLMApi: Utilisation de LLM locaux pour simuler automatiquement les API dans ASP.NET Core MinimalAPI"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

# LLMApi: Utilisation de LLM locaux pour simuler automatiquement les API dans ASP.NET Core MinimalAPI

<datetime class="hidden">2025-11-02T12:30</datetime>

# Introduction

Une de mes obsessions constantes est l’échantillonnage des données.
Combiné à mon amour actuel de 'AI assisté ' codage d’idées aléatoires il' a conduit à la mise en place d’un petit générateur de données d’essai activé par LLM ainsi qu’à un paquet nuget avec un middleware qui peut générer des réponses API simulées au moyen d’une API

Vous pouvez trouver le[ GitHub ici ](https://github.com/scottgal/LLMApi)pour le projet, tous les domaines publics, etc.

[TOC]

# Concept

Comme pour beaucoup d’idées de codage "AI Assisted" il a commencé par une idée sur la simulation des résultats à l’aide de LLMsM SK2 J’étais en train de travailler sur un autre projet ([LucidForums](https://github.com/scottgal/lucidforums), une expérience de forum basée sur l’autopopulation LLM qui est hilarément dysfonctionnelle ) et les LLMs sont vraiment bons ( si un peu lentement) à produire des données d’échantillonnage. *ce qui se passerait si* Je peux les utiliser pour simuler n'importe quel API.

# Exigences

1. Il devrait être simple de mettre en œuvre dans un ASP.NET Core App.
2. Les données devraient être assez réalistes.
3. Les données devraient être aléatoires
4. Il peut accepter JSON 'shapes' qui indiquent au LLM quelle devrait être la réponse.
5. Il peut utiliser des LLM de source ouverte locale
6. Il devrait être gratuit d'utiliser le contrôle Nuget

C’est ce que j’ai trouvé.

Les ajouts futurs incluront vraisemblablement le caching en cas de besoin plus rapide perf.

Voici le readme du paquet (fetched automatically).

# mostlylucid.mockllmapi

**Ce qu'il fait:** Une production-ready ASP.NET Core mocking platform for generating realistic mock API responses using LLMsM SK2

**Pourquoi l’utilisez-vous ?** Ajouter des paramètres de modèle intelligents à tout projet avec seulement 2 lignes de code—pas de bases de donnéesM SK2 pas d'installations codées durementMSC3 pas de maintenance .

[![NuGet](https://img.shields.io/nuget/v/mostlylucid.mockllmapi.svg)](https://www.nuget.org/packages/mostlylucid.mockllmapi)
[![NuGet](https://img.shields.io/nuget/dt/mostlylucid.mockllmapi.svg)](https://www.nuget.org/packages/mostlylucid.mockllmapi)
[![Mise à jour de GitHub](https://img.shields.io/github/v/release/scottgal/LLMApi)](https://github.com/scottgal/LLMApi/releases)
[![Licence: Non-licence](https://img.shields.io/badge/license-Unlicense-blue.svg)](http://unlicense.org/)

**Companion Package:** [mostlylucid.mockllmapiM SK1Testing](https://github.com/scottgal/LLMApi/blob/refs/heads/master/mostlylucid.mockllmapi.Testing/README.md) - Utilisations d'essai avec une intégration HttpClient fluide

---

## Comment lire ce README

Ce README est complet par design. Choisissez votre chemin:

- **"Je veux essayer cela en 5 minutes"** → Passer à [Démarrage rapide](#quick-start)
- **"Je veux savoir ce que cela peut faireM SK1** → Voir [Aperçu des caractéristiques](#features) et [Architecture](#architecture)
- **"Je veux comprendre comment cela fonctionne"** → Lire [Documentation sur les caractéristiques](#feature-documentation) et [Caractéristiques avancées](#advanced-features)

---

## Qu’est-ce que ' Nouveau - TLM SK2DR

**Le plus récent:** AutoShape (Shape Memory) - Conséquence automatique de la structure JSON à travers les appels en point final
**v2.5.0:** Améliorations de la sécurité, AOT/appui à l'enlèvement par le retrait des dépendances de serialisation
**v2.3.0:** Soutien du type de contenu complet - organes de formulaires, téléchargement des fichiers , essais exhaustifs
**v2.2.0:** Outils pluggables pour l'intégration des API, pré-APIs REST configurésM SK2 expiration automatique de la mémoire contextuelle
**v2.1.0:** Limitation du taux, battage, nM SK2achèvements avec plusieurs stratégies d'exécution

<details>
<summary><strong>Click for detailed v2.5.0 feature breakdown</strong></summary>

### Version 2.5.0 Détails

**Concentration**: Améliorations de sécurité et AOT/appui à l'amorçage en supprimant les dépendances liées à la serialisation . Compatible avec v intégralement arrièreM SK3

**1. AOT/Support à l'écoulement** - Remplacement de toutes les dépendances de réflectation fondées sur la serialisationM SK1:

- Élimination `System.Text.Json` utilisation de la réflexion
- Construction manuelle de JSON dans toute la base de code
- Compatibilité complète avec .NET 8.0+ AOT et trimming
- Aucun problème de résolution du type runtime
- Plus petite taille binaire et meilleure performance de démarrage

**2. Sécurité améliorée** - Amélioration complète de la sécuritéM SK1

- On a supprimé toutes les séries basées sur la réflexion- qui pourraient exposer l'information de type.
- Élimination des vulnérabilités liées à l'inférence de type potentiel
- Gestion plus sûre de JSON avec des contraintes explicites du type
- Surface d'attaque réduite pour les exploits basés sur la serialisation-
- Une meilleure protection contre les attaques de déserialisation

**3. Optimisations du rendement** - Performance améliorée du temps d'exécutionM SK1

- Construction plus rapide de JSON sans réflexion au-dessus
- Réduction des affectations de mémoire
- Améliorer la localité du cache
- Amélioration du temps de démarrage pour les applications trimmées
- Imprint inférieur de la mémoire

**Compatibilité** - Soutien complet pour les constructions de préview .NET

- Construction manuelle de JSON tout au long afin d’éviter les problèmes de séries basés sur la réflexion-
- Tous les éléments testés et utilisés sur .NET 10 préview builds
- Aucune modification de la fonctionnalité existante

**5. Amélioration des essais** - Protection des essais amélioréeM SK1

- Essais additionnels pour les scénarios de trimming AOT/
- Sécurité-essais axés sur les unités
- Essais de comparaison du rendement
- 100% taux de passage avec tous les nouveaux tests

[Pour plus de détails, voir TEST_SUMMARYM SK1md et IMPLEMENTATION_SUMmARY .md.](https://github.com/scottgal/LLMApi/blob/refs/heads/master/TEST_SUMMARY.md)

</details>
<details>
<summary><strong>Click for detailed v2.3.0 feature breakdown</strong></summary>

### Version 2.3.0 Détails

**Concentration**: Soutien complet du type de contenu pour tous les formats de demande HTTP communs . Compatible à l'arrière-plan avec v2.2.0.

**1. Forme de soutien du corps** - Soutien complet pour `application/x-www-form-urlencoded` type de contenu. valeurs uniques et multiples , conversion automatique JSONM SK2 construction manuelle pour .NET MSC4 compatibilitéMSC5 parfait pour tester les formulaires HTML et les applications Web traditionnellesMST6

**Soutien au téléchargement de fichiers 2.** - Soutien complet pour `multipart/form-data` Incluant les téléchargements de fichiers. MémoireM SK1Traitement sécuritaire (8Buffer KB), Extraction des métadonnées MNK4Nom du fichier MNK5 tailleMKK6 type de contenuMMK7 champs et fichiers à forme mixteMRK8 Le contenu est dédoupé pour éviter une blotte de mémoireMCK9

**3. Longueurs arbitraires des voies** - Soutien à la nidification par voie profonde via `{**path}` catch-total routing. Étudié avec 9-pathes profonds de segment et chaînes complexes de demandesM SK3 Aucune limite pratique sur la profondeur du chemin MSC4 jusqu’à ASP

**4. Suite d'essai approfondie** - 228 essais 37 nouveauM SK3 couvrant toutes les fonctionnalités. Partage du corps de forme M(12 essaiMS), manipulation JSON (25 testsM), tests d'intégration pour des flux de travail HTTP completsMSC9 MMSC10 taux de passageM MSC11 régression zéro MMSC12

**Compatibilité** - Construction manuelle de JSON tout au long du processus afin d'éviter les réflexions- problèmes de serialisation basés sur . Toutes les fonctionnalités testées et utilisées sur .NET

[Pour plus de détails, voir TEST_SUMMARYM SK1md et IMPLEMENTATION_SUMmARY .md.](https://github.com/scottgal/LLMApi/blob/refs/heads/master/TEST_SUMMARY.md)

</details>
<details>
<summary><strong>Click for detailed v2.2.0 feature breakdown</strong></summary>

### Version 2.2.0 Détails

**Concentration**: Outils pluggables pour l'intégration des API, préM SK2APIs REST configurés , et mémoire contextuelle intelligente

**1. Outils pluggables & Système d'actions** - Demander à des API externes REST ou à des points d'extrémité de modèles de chaîne pour créer des flux de travail et des arbres décisionnels réalistes [Dossiers complets →](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/TOOLS_ACTIONS.md)

**2. Pré-APIs REST Configurés** - Définir les configurations API complètes une fois qu’on a appelé , appel par nom . Référence à la spécification de Shape ou OpenAPI , Gestion du contexte partagée , Intégration des outils . Voir `appsettings.Full.json` pour les exemples complets de 8

**3. Gestion de la mémoire en contexte dynamique** - Les contextes expirent maintenant après 15 minutes d'inactivité

**4. Extraction intelligente de données partagées** - Extrait automatiquement TOUS les champs des réponses à n'importe quel niveau de nidification . Objets nichés M SK2 Traçage d'arréaux , Données sur le premier article MSC4 Champs personnalisés MST5 Tous suivis automatiquement Mst6

**5. Documentation améliorée** - Nouveaux guides complets pour [Outils & Actions](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/TOOLS_ACTIONS.md), [Limitation du taux](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/RATE_LIMITING_BATCHING.md), et [Contextes de l'API](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md).

[Voir RELEASE_NOTES.md pour plus de détails](https://github.com/scottgal/LLMApi/blob/refs/heads/master/RELEASE_NOTES.md)

</details>
---

## Table des matières

### Concepts fondamentaux

- [Aperçu des caractéristiques](#features) - Ce que ce système peut faire
- [Démarrage rapide](#quick-start) - Sortir en 5 minutes
- [Architecture](#architecture) - Comment cela allègue-t-il ensemble
- [Non-Objectifs M SK1 Limites](#non-goals--boundaries) - Ce qui n'est pas

### Protocoles & Faits

- [REST API Mocking](#1-rest-api-mocking)
- [GraphQL API Mocking](#graphql-api-mocking)
- [SSE Streaming](#3-server-sent-events-sse-streaming)
- [SignalR Real-Time](#signalr-real-time-data-streaming)
- [Swagger OpenAPI /](#openapi--swagger-mock-generation)
- [Services gRPC](#6-grpc-service-mocking-new-in-v170)

### Architecture avancée &

- [Options de configuration](#configuration-options)
- [Documentation sur les caractéristiques](#feature-documentation) - Dans les guides de profondeur
- [Caractéristiques avancées](#advanced-features)
- [Applications de démonstration](#demo-applications)
- [Évaluation](#testing)

---

## Aperçu de l'architecture

**Un moteur, protocoles multiples , infrastructure partagée.** Toutes les fonctionnalités partagent la même génération, contexte , et systèmes de contrôle— vous offrant un comportement cohérent à travers RESTM SK3 GraphQLMska4 SSEMka5 SignalRM Ska6 OpenAPIM ska7 et gRPCMske8

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

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

**Components clés:**

- **Client unique LLM**: Tous les protocoles utilisent la même intégration LLM avec des politiques de résilience
- **Mémoire de contexte partagé**: Les contextes API fonctionnent à travers RESTM SK1 GraphQL , SignalR, et OpenAPI
- **Faits généraux**: Limitation des vitesses , caching, simulation d'erreursM SK3 et gestion des tokens s'appliquent à tous
- **Modèle modulaire**: Utilisez n’importe quelle combinaison—ajouter seulement ce dont vous avez besoin

Voir [diagrammes d'architecture détaillés](#architecture) ci-dessous pour le contrôle du flux et de la forme des demandes.

---

## Caractéristiques

Ce paquet fournit **six caractéristiques indépendantes** - utiliser toute combinaison dont vous avez besoin voir [Exemples modulaires](https://github.com/scottgal/LLMApi/blob/refs/heads/master/MODULAR_EXAMPLES.md) pour le protocole-systèmes spéciaux):

### 1. Mocking de l'API REST

- **Super Simple**: `AddLLMockApi()` + `MapLLMockApi("/api/mock")` = API de simulation instantanée
- **Contrôle de la forme**: Préciser la structure exacte de JSON par l'en-têteM SK1 param de demande, ou corps de demande
- **Tous les méthodes HTTP**: Appuie GETM SK1 POST, PUT , DELETEMSC4 PATCH
- **Routage de cartes sauvages**: Tout chemin sous votre point final choisi fonctionne
- **Soutien complet du type de contenu** (NEW dans vM SK1
  - **JSON** (`application/json`) - Organes de demande standard JSON
  - **Organes de forme** (`application/x-www-form-urlencoded`) - Présentation de formulaire HTML
  - **Les téléchargements de fichiers** (`multipart/form-data`) - Les fichiers téléchargés avec extraction de métadonnées
  - **Memory-Safe**: Contenu du fichier transmis et détourné ( seules les métadonnées conservées
- **Longueurs arbitraires du chemin**: La nidification par voie profonde est entièrement appuyée (`/api/mock/v1/api/products/electronics/computers/laptops/gaming/...`)

### 2. GraphQL Mocking API

- **Soutien GraphQL autochtone**: POSTE à `/api/mock/graphql` avec les demandes GraphQL standard
- **Question-Formes dirigés**: La demande GraphQL elle-même définit la structure de réponse
- **Variables & Opérations**: Soutien complet pour les variables, noms d'opérations , et fragments
- **Traitement d'une erreur appropriée**: Retourne les erreurs GraphQL-formatées avec `data` et `errors` Les champs

### 3. ServeurM SK1 Événements envoyés (SSE) Enregistrement

- **Enregistrement progressif**: Soutien SSE avec génération progressive de JSON
- **Mise à jour en temps réel-**: Token de données d'acheminement-parM SK2token vers les clients
- **Travaux autonomes**: Aucune configuration de l'API REST n'est requise
- **[Guide SSE complet](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/SSE_STREAMING_MODES.md)** | **[Enregistrement continu](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/CONTINUOUS_STREAMING.md)**

### 4. SignalR Real-Traitement de temps

- **WebSocket Streaming**: Données de simulation continues réelles-temps via SignalR
- **Contextes multiples**: Effectuer plusieurs flux de données indépendants simultanément
- **Gestion du cycle de vie**: Start/arrêter les contextes dynamiquement avec l'API de gestion
- **Travaux autonomes**: Aucune configuration de l'API REST n'est requise
- **[Guide de démonstration de SignalR](https://github.com/scottgal/LLMApi/blob/refs/heads/master/SIGNALR_DEMO_GUIDE.md)**

### 5. OpenAPI Swagger Mock Generation

- **Production automatique d'un point final**: Indiquer à n'importe quel OpenAPIM SK1Swagger spec (URL ou fichier)
- **Toutes les opérations sont supprimées**: Chaque chemin et méthode de spec devient un point final en direct
- **Tableau de diagramme-Découlement des données**: LLM produit des données réalistes correspondant à vos schémas
- **Échantillons multiples**: Charger et monter plusieurs spécifications API simultanément
- **Travaux autonomes**: Aucune configuration de l'API REST n'est requise
- **[Guide des fonctionnalités de l'OpenAPI](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/OPENAPI-FEATURES.md)**

### 6. Motage du service gRPC (NEW dans v1.7.0)

- **Mise à jour du fichier Proto**: charger les fichiers de protocole . pour générer des modèles de service gRPC
- **Soutien du protocole double**: JSON sur HTTP pour l'essaiM SK1 Protobuf binaire pour la production- mocking de niveau
- **Serialisation dynamique**: Encodage de Protobuf en temps d'exécution sans production de code
- **LLM-Données électriques**: Réponses réalistes correspondant aux définitions de votre message proto
- **Travaux autonomes**: Aucune configuration de l'API REST n'est requise
- **[Guide de soutien gRPC](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/GRPC_SUPPORT.md)**

### Faits généraux

- **Configurable**: appsettings .json ou configuration en ligne
- **Données très variables**: Chaque demande/update produit des données réalistes complètement différentes
- **NuGet Package**: Facile à ajouter aux projets existants
- **AutoShape (Memorie de la forme)**: Remarque automatiquement la structure de JSON à partir de la première réponse , garantissant des schémas cohérents dans toutes les demandes subséquentes jusqu'au même point final **[Voir Guide d'autoformation](#autoshape-shape-memory)**
- **Contextes de l'API**: Maintenir la cohérence entre les demandes connexes - **[Guide complet](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)**
- **Simulation d'une erreur**: Essais d'erreur approfondis avec des codes de situation 4xx/5xx, messages personnalisés
- **Utilités d'essai**: Companion package `mostlylucid.mockllmapi.Testing` pour une intégration facile de HttpClient dans les essais - **[Voir Section des essais](#testing)**

---

## Non-Objectifs M SK1 Limites

**Qu'est-ce que ce soit:**

- Un outil d'élaboration et de prototype pour la production réaliste de données modèles
- Perfectieux pour le développement de frontend, conception API, démonstration de , et essais
- Zero-alternative à l'entretien des appareils et de la base de données codés sur support dur

**Qu'est-ce que ce n'est pas:**

- **N'est pas une source de données de production** - Les données produites sont réalistes mais synthétiques
- **Pas de remplacement pour les essais contractuels** - Utilisez-le pour le développement; valider séparément les API réels
- **Non pour le trafic de production non validé** - L'entrée de l'utilisateur va directement aux prompts LLM (injection rapide possible)
- **N'est pas une base de données ou un stock persistant** - Aucun état n'est maintenu entre les demandes (à l'exception des contextes API facultatifs)
- **Il ne s'agit pas d'un remplacement de la logique réelle du backend.** - Règles d’affaires, validationM SK2 et flux de travail restent simplifiés

**Quand l'utiliser:**

- Élaboration de frontends avant que les backends ne soient prêts
- Créer des démonstrations réalistes sans accès aux données de production
- Évaluation des composants de l'interface avec divers scénarios de données
- Prototyping API designs and experimenting with response shapes
- Apprentissage des modèles d'intégration LLM dans .NET

**Quand ne pas l'utiliser:**

- Dans les milieux de production qui servent des utilisateurs réels
- Pour tester l'authentification/logice d'authorisation M SK1 schémas de sécurité ignorés)
- Lorsque les données doivent se conformer aux règles commerciales strictes ou à la validation
- Pour la mise à l'essai de performance réelle du backend
- Lorsque des données déterministes, reproductibles sont requises à travers les essais

---

## Documentation sur les caractéristiques

Pour des guides détaillés avec diagrammes d'architecture, cas d'utilisationM SK1 et détails de mise en œuvre:

- **[Guide de déploiement du Docker](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/DOCKER_GUIDE.md)** - Installation et déploiement complets du Docker
  
  - Démarrage rapide avec Docker Compose + Ollama
  - Fin-to-exemplaire de fin avec llmM SK2model
  - Méthodes de configuration (env varsM SK1 cartographie du volume, . fichiers envMSC4
  - Support GPU, multi-configuration du backend
  - Considérations de production et résolution des problèmes

- **[Référence à l'API de backend](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/BACKEND_API_REFERENCE.md)** - Documentation complète sur les points finals de gestion
  
  - Points finals de gestion OpenAPI
  - Gestion du contexte de l'API
  - gRPC gestion proto
  - Centres de signalisation R
  - Demande complète/exemples de réponse

- **[Guide de backends multiple LLM](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/MULTIPLE_LLM_BACKENDS.md)** - Soutien à plusieurs fournisseurs
  
  - Connectez simultanément Ollama, OpenAI, et LM Studio
  - Per-request backend selection via headers/query params
  - Compatibilité ultérieure complète avec les configurations traditionnelles
  - Fournisseur-exemples et pratiques exemplaires spécifiques

- **[Guide des contextes de l'API](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)** - NOUVEAUM SK1
  
  - Mémoire partagé à travers les demandes pour des flux de travail uniformes multi-
  - E- flux commerciauxM SK1 tickers de stocks , exemples d’état des jeux
  - Gestion des tokens et truncation intelligente
  - Diagrammes d'architecture Mermaid

- **[Limitation du taux & Guide de mise en charge](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/RATE_LIMITING_BATCHING.md)** - NOUVEAU dans vM SK1
  
  - N-completions support pour générer plusieurs variantes de réponse
  - Per-Statistiques de pointe suivies avec moyennes en mouvement
  - Trois stratégies de mise en lots (Sequential,ParallèleM SK2StreamingMSC3
  - Encadrements détaillés sur le calendrier des essais de performance
  - Perfect pour tester les stratégies de retrait et les scénarios d'échéance

- **[Outils pluggables & Guide des actions](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/TOOLS_ACTIONS.md)** - NOUVEAU dans vM SK1
  
  - MCP-architecture compatible pour l'intégration d'outils élargisables
  - Outils HTTP pour appeler des API externes avec authentification
  - Mock outils pour créer des arbres de décision et des flux de travail
  - Substitution de modèles avec un support pour les variables environnementales
  - Chaînement d'outils avec limites de sécurité et cache des résultats
  - Phase 1 (ExplicitM SK2 Phase ≥2 \(LLMMSC5driven), Phase

- **[Guide de soutien gRPC](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/GRPC_SUPPORT.md)** - NOUVEAU dans vM SK1
  
  - Télécharger les fichiers .proto pour le montage automatique du service gRPC
  - Soutien double: JSON sur HTTP et Protobuf binaire
  - LLM-génération d'une réponse réaliste
  - Détails complets de la mise en œuvre et stratégies d'essai

- **[Guide des fonctionnalités de l'OpenAPI](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/OPENAPI-FEATURES.md)**
  
  - chargement dynamique des spécifications provenant de fichiers URL, , ou JSON en ligne
  - Production automatique d'un point final avec des paramètres de chemin
  - Demande/exemples de réponse avec l'API Petstore
  - Intégration de SignalR pour les mises à jour en temps réel

- **[Exemples d'architecture modulaire](https://github.com/scottgal/LLMApi/blob/refs/heads/master/MODULAR_EXAMPLES.md)**
  
  - REST-seulementM SK1 GraphQL-seuls , SignalRMSC4seules configurations
  - Stratégies d'optimisation de la mémoire
  - Mélanger et correspondre les protocoles

- **[Guide de démonstration de SignalR](https://github.com/scottgal/LLMApi/blob/refs/heads/master/SIGNALR_DEMO_GUIDE.md)**
  
  - Établissement de la diffusion de données en temps réel
  - Gestion du cycle de vie dans le contexte
  - Exemples de connexion avec un client

- **[Notes de diffusion](https://github.com/scottgal/LLMApi/blob/refs/heads/master/RELEASE_NOTES.md)**
  
  - Historique complète de la version
  - Débrouillage des changements (pas depuis vM SK1
  - Guides de migration

- **[Résumé de l'essai](https://github.com/scottgal/LLMApi/blob/refs/heads/master/TEST_SUMMARY.md)** - NOUVEAU dans vM SK1
  
  - Documentation complète sur la couverture des essais
  - Essais 228 avec ventilation détaillée
  - Mesures de rendement et validation
  - Toutes les catégories d'essai expliquées

- **[Résumé de la mise en œuvre](https://github.com/scottgal/LLMApi/blob/refs/heads/master/IMPLEMENTATION_SUMMARY.md)** - NOUVEAU dans vM SK1
  
  - Form body and file upload implementation details
  - Construction manuelle de JSON pour .NET 10
  - Memory-architecture de gestion des fichiers sécuritaire
  - Modifications complètes du code et justification

---

## Démarrage rapide

### Installation

**Package principal:**

```bash
dotnet add package mostlylucid.mockllmapi
```

**Utilités d'essai (Optionnelles):**

```bash
dotnet add package mostlylucid.mockllmapi.Testing
```

> Offre une API fluide pour la configuration facile de HttpClient dans les essais. [Voir Section des essais](#testing) pour plus de détails.

### Démarrage rapide avec le Docker (Recommandé)

La façon la plus rapide de démarrer - pas . Installation NET ou Ollama requise!

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

**Ce n’est pas le cas.** L'API est en cours à `http://localhost:5116` avec Ollama backend.

Voir le **[Guide Docker complet](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/DOCKER_GUIDE.md)** pour:

- Options de configuration (env varsM SK1 cartographie du volume)
- Utilisation de différents modèles (gemma3:4bM SK2 mistralMSC3nemoMST4
- Soutien GPU
- Déploiement de la production
- Troubleshooting

### Exigences (Développement local)

Si vous n'utilisez pas Docker:

1. Installer [.NET  8.0 SDK](https://dotnet.microsoft.com/download/dotnet/8.0) ou plus tard
2. Installer [Ollama](https://ollama.ai/) et retirer un modèle:
   ```bash
   ollama pull ministral-3:3b
   ```

### Choix d'un modèle LLM

Ce paquet était **a été mis au point et testé avec `ministral-3:3b`** (3Paramètres BM SK1 qui fournit des résultats excellents pour toutes les fonctions avec une performance très rapide. CependantMSC3 il fonctionne avec tout modèle OllamaMST4compatibleMSS5

#### Modèles recommandés

| Modèle MSC1 Taille MSC2 Accès SMC3 Qualité SMC4 Contexte ESC5 Le meilleur pour SMC6
|----------------------|------|-----------|---------|---------|----------|
| **Ministre-3:3b** (défaultM SK1 | | | 3 | B | 4 | V | 5 | Fast | 6 | Excellent | 7 | 8 | K | 9 | **KILLER pour JSON! Fast, exactM SK2 grand contexte** |
| **3:4b gemma** | 4B S| rapide | bon | | | 5 | K | | solution de rechange pour les machines inférieures
| **3** | MSC1B MSC2 Moyenne SMC3 Très bonne ESC4 | | 5 | K | SMC6 | Utilisation générale | MSC7 | Production |MSC8
| **Mistral-nemo** | MSC1B SMC2 Moins lentement MSC3 Excellente | ≥MSC5K SMC6 **Qualité élevée, ensembles de données massifs** |
| **Mistral:7b** | 7B S| Moyenne | Très bonne | | | 5 | K | | | Solutions de rechange à llm | - | modèle ||
| **3** | MSC1B MSC2 Rapide SMC3 Bonne SMC4 | | 5 | 6 | Élaboration rapide de prototypes | SMC7
| **de l'eau potable** | MSC1B MSC2 Très rapide SMC3 Basique SMC4 | | 5 | 6 | Ressource ultra | SMC7 | restreint | | |

#### RECOMMANDÉ: Qwen M SK1 Coder (3B) - Perfect pour le développementMSC5

**Qwen 2.5 Coder est KILLER pour la génération JSON** - ultraM SK1 rapide , extrêmement précis, contexte largeMSC4

```bash
ollama pull ministral-3:3b
```

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

**Pourquoi ce n’est-ce qu’un excellent travail?**

- Exceptionnellement rapide sur tout matériel (3-4GB RAM)
- Exactitude de génération JSON de la classe Best-in-
- 256K fenêtre contextuelle ( manipule des structures ensemencées complexes
- Formé spécialement pour les données structurées de code/
- Perfect pour les pipelines et le développement de CI/CD
- Hallucinations minimales par rapport aux modèles généraux

#### PRODUCTION: MistralM SK1Nemo - La meilleure qualité & Contextes massifs

**Pour la production-essais similaires avec des schémas complexes:**

```bash
ollama pull mistral-nemo
```

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

**Pourquoi ce n’est-ce qu’un excellent travail?**

- Production de données réalistes de la plus haute qualité
- **128K fenêtre contextuelle** (exige [Configuration Ollama](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/MULTIPLE_LLM_BACKENDS.md#ollama-context-window-configuration))
- Le meilleur pour les structures ensemencées complexes et les grands ensembles de données
- Variation plus créative des données générées
- **Remarque**: Besoins de ressources supplémentaires

#### Modèle-Configuration spécifique

**Pour le ministre-3:3b M SK1Recommandé - défaut):**

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

**Pour gemma3:4b ou llama3:**

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

**Pour le mistral-nemo (HighM SK2production de qualité):**

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

**Note:** Mistral-nemo requiert [Configuration du contexte Ollama](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/MULTIPLE_LLM_BACKENDS.md#ollama-context-window-configuration) pour 128K contexts.

**Où trouver MaxContextWindow:**

```bash
# Check model info
ollama show {model-name}

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

**Pour les modèles plus petits (phiM SK1 tinyllama):**

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

**Pourquoi la température est importante:**

- **Modèles plus gros (7BM SK1** peut gérer des températures élevées (1.0-1.5) tout en maintenant un JSON valide
- **Modèles plus petits (<4BM SK1** Il faut des températures plus basses (0.6-0.8) pour éviter
  - Syntaxe JSON invalide (quotes manquantesM SK1 crochets)
  - Réponses tronquées avec ellipse ("...")
  - Noms de champ ou structures hallucinatoires
- Température inférieure = rendement plus prévisible , moins de variété
- Température plus élevée = output plus créativeM SK1 plus de variété ( mais plus risqué pour les petits modèles)

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

**Limites importantes:**

- **Modèles plus petits** (`tinyllama`, `phi3`) fonctionne, mais peut fonctionner
  - générer des données plus simples/ sans variations
  - Lutte contre les questions complexes de GraphQL
  - Besoin d'autres tentatives de retry
  - Travailler avec des questions simples et de petites tailles de réponse
- **Tous les modèles** peut faire face à:
  - **Très complexe/questions de GraphQL ensemencées profondément** (>5 Niveaux profonds
  - **Nombre de champs par objet** (>10 champsM SK1
  - **Large array requests** - Limite à 2-5 pour les articles de fiabilité
- **Si vous voyez des erreurs** sur le JSON tronqué ("...") ou les commentaires ("//"):
  - Température inférieure à 0.8 ou moins
  - Simplifier votre demande GraphQL (moins champs, moins nidificationM SK2
  - Accroître `MaxRetryAttempts` à 5 ou plus

### Usage de base

**Programme.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.jsonM SK1**

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

Que'c'est ce qu'il est! Maintenant, toutes les demandes de `/api/mock/**` Retour des données de modèle intelligente.

## AutoShape (Memorie de la forme)

**Maintenir automatiquement des structures JSON cohérentes à travers les demandes au même point final.**

### Ce qu'elle fait

AutoShape se souvient de la structure JSON depuis la première réponse à un point final et l’applique automatiquement à toutes les demandes subséquentes à ce même point final (avec des ID différentes ). Cela assure

- Systèmes de réponse cohérents à travers plusieurs appels
- Aucune dérive du schéma pendant le développement
- Utilisation prévisible de l'API pour les essais

### Exemple rapide

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

### Configuration

**Activé par défaut** dans `appsettings.json`:

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

### Per-Contrôle de demande

**Disabler pour une demande spécifique:**

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

**Renouveler une mauvaise forme:**

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

### Normalisation du chemin

Tous ces demandes ont la même forme (normalisée à `/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
```

### Faits clés

- **✅ activé par défaut** - fonctionne hors de la boîte
- **🔄 Renouvellement de forme** - Fixer les mauvaises formes avec `?renewshape=true`
- **⏱️ Auto-expiration** - Les formes expirent après l'inactivité.
- **🎯 Normalisation intelligente** - Identités différentes pour les mêmes formes de partage du point final
- **🚫 Supprimer explicitement** - Fourniture de la forme explicite par l'entremise de la demandeM SK1header/body skips autoshape
- **✨ Travaille partout** - RESTM SK1 Streaming, et GraphQL finpoints

### Quand utiliser

**Perfect pour:**

- Développement de frontend nécessitant des structures de données modèles cohérentes
- Essais d'intégration nécessitant des schémas prévisibles
- Démos où la structure des données ne devrait pas changer entre les demandes
- Fabrication de prototypes d'API avec des formes évolutives mais cohérentes

**N'est pas nécessaire lorsque:**

- Utilisation de formes explicites (elles ont la préséance en tout état de cause
- Besoin d'une variété maximale dans chaque réponse
- Évaluation des scénarios d'évolution du schéma

### Troubleshooting

**Formes non appliquées?**

1. Vérifier `EnableAutoShape: true` dans la configuration
2. Vérifiez qu'il n'y a pas de forme explicite fournie (query/headerM SK2bodyMSC3
3. Vérifier le temps d'expiration (défault 15 minutesM SK2

**Besoin de changer une forme?**

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

**Supprimer toutes les formes de façon programmatique:**

```csharp
// Inject AutoShapeManager
autoShapeManager.ClearAllShapes();
```

Pour obtenir la documentation complète,, voir [CLAUDE.md AutoShape Section](https://github.com/scottgal/LLMApi/blob/refs/heads/master/CLAUDE.md#autoshape-feature-shape-memory).

**Couverture d'essai:** 39 essais couvrant toutes les fonctions d'autoformation ✅

## Options de configuration

> **📘 Référence de configuration complète:** Voir [Guide de référence pour la configuration](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/CONFIGURATION_REFERENCE.md) pour toutes les options
> **📄 Exemple complète:** Voir [appsettings.FullM SK1json](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMApi/appsettings.Full.json) - démontre **tous les** option de configuration

### Par l'intermédiaire des réglages d'application.json M SK1Recommandé)

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

**Modèle- Limites spécifiques des tokens**: Voir `LLMApi/appsettings.json` pour des exemples de configuration pour différents modèles (Llama 3, TinyLlama, MistralMSC3 etcM SK4 Chaque modèle a différentes tailles de fenêtres contextuelles `MaxInputTokens` par conséquent.

**Contextes de l'API**: Pour de plus amples renseignements sur l’utilisation des contextes pour maintenir la cohérence entre les demandes, voir le **[Guide des contextes de l'API](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)**.

### Politiques de résilience

**Nouveaux dans v1.2.0:** Élaboré-Les politiques de résilience Polly protègent votre application contre les défaillances du service LLM!

Le paquet comprend deux modèles de résistance activés par défaut:

**Réessai de déblocage exponentiel**

- Récupération automatique des demandes de LLM qui ont échoué avec retards exponentiels (1s,
- Inclure le tremblement pour empêcher les problèmes de troupe d'écrasement
- Génie les erreurs de connexion, les arrêts de temps , et non-codes d'état de réussite
- Défault: M SK1 tentatives avec 1 deuxième retard de base

**Réparateur de circuits**

- Ouverture après des défaillances consécutives pour empêcher la cascade
- Reste ouvert pendant une durée configurée avant de permettre les demandes d'essai
- Trois états: Fermé M SK1Normal), Ouvert (Rejet ),Half SSK5 Ouverture S(ÉvaluationMSC7
- Défault: Ouverture après M SK1 défaillances consécutives, reste ouverte pendant 30 secondes

**Configuration:**

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

**Enregistrement:**

Les politiques de résilience enregistrent toutes les tentatives de répétition et les changements d’état du brise-circuit:

```
[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
```

**Quand ajuster:**

- **Slow LLM?** Accroître `MaxRetryAttempts` ou `RetryBaseDelaySeconds`
- **Récupération agressive?** Réduire `CircuitBreakerDurationSeconds`
- **Nombre d'erreurs transitoires?** Accroître `CircuitBreakerFailureThreshold`
- **Disabler les essais locaux?** Établir les deux `EnableRetryPolicy` et `EnableCircuitBreaker` à `false`

### Par le biais du code

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

### Paramètres de point final personnalisés

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

## Exemples d'utilisation

### Demande de base

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

Retourne les données réalistes de l'utilisateur générées par le LLM.

### Formulaire des demandes de corps (NEW dans vM SK1

**Présentation du formulaire HTML:**

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

Les données du formulaire sont automatiquement converties en JSON et transmises au LLM pour la génération de réponses réalistes.

**Formulaire avec plusieurs valeurs:**

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

Plusieurs valeurs pour le même nom de champ sont converties en tableaux automatiquement.

### Demandes de téléchargement des fichiers (NEW dans v2.3.0)

**Upload de fichier unique:**

```bash
curl -X POST http://localhost:5000/api/mock/photos/upload \
  -F "title=My Photo" \
  -F "description=Beautiful sunset" \
  -F "image=@photo.jpg"
```

**Plusieurs fichiers avec des données du formulaire:**

```bash
curl -X POST http://localhost:5000/api/mock/documents/bulk \
  -F "title=Multiple uploads" \
  -F "file1=@document1.pdf" \
  -F "file2=@document2.pdf"
```

**Comment fonctionnent les téléchargements de fichiers:**

- Le contenu du fichier est **transmis par un tampon 8KB** et **rejeté** (non stocké en mémoire)
- Seuls les métadonnées sont conservés: nom du fichier , type de contenuM SK2 taille, lecture des bytes
- LLM reçoit des métadonnées de fichier et génère une réponse appropriée
- Memory-safe for large files (tested with 100MBM SK3

**Réponse par exemple:**

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

### Ensemencement de voies profondes (NEW dans v2.3.0)

**Voies Nested complexes:**

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

Le LLM intègre tous les segments de cheminement et les paramètres de demande dans la génération réaliste des réponses. Aucune limite pratique sur la profondeur du cheminementM SK1

### Contexte API (NEW dans v1.5.0)

**Utiliser des contextes pour maintenir la cohérence entre plusieurs demandes connexes:**

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

Chaque demande dans le même contexte affiche les demandes antérieures, assurant des ID cohérentsM SK1 noms , et relations de données. parfaite pour les flux de travail à plusieurs étapes **[Guide des contextes de l'API](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)** pour des exemples complets.

### Avec le contrôle de la forme

```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 génère des données correspondant à votre spécification exacte de forme.

### Enregistrement (SSE - ServeurM SK2 Événements envoyés)

**SSE streaming fait partie de l'API REST - il est seulement possible d'en ouvrir lors de la cartographie des points finals:**

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

**Usage:**

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

Retourne le serveur-Les événements envoyés en tant que JSON sont générés par un token

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

**Exemple de 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);
    }
};
```

**Avec contrôle de forme:**

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

Le point final d'écoulement appuie toutes les mêmes fonctionnalités que les points terminaux réguliers:

- Contrôle de la forme (param de demandeM SK1en-tête , ou corps)
- Soutien du schéma JSON
- Demandes de renseignements personnalisés
- Tous les méthodologies HTTP (GET, POST , PUTM SK3 DELETEMSC4 PATCHMST5

## GraphQL API Mocking

**Nouveaux dans v1.2.0:** Soutien GraphQL natif avec la demande-génération de données mock dirigées!

L'API de LLMock inclut des éléments structurés-in GraphQL pour l'appui aux points d'extrémité. Contrairement à ceux du REST où vous spécifiez les formes séparémentM SK2 Les demandes de GrafQL définissent naturellement la structure exacte qu'elles s'attendent à - la demande est la forme

### Démarrage rapide avec GraphQL

Le point final GraphQL est automatiquement disponible lorsque vous cartographiez l’API LLMock:

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

Ceci crée un point final GraphQL à `/api/mock/graphql`.

### Usage de base

**Question simple:**

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

**Réponse:**

```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" }
    ]
  }
}
```

### Avec des variables

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

### Demandes en positionnement

GraphQL's puissance brille avec les données ensemencées:

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

Le LLM génère des données réalistes correspondant à votre structure exacte de demande - y compris toutes les relations entamées.

### Exemple de client JavaScript

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

### Erreur de manutention

Les erreurs GraphQL sont retournées dans le format standard:

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

### Comment cela fonctionne

1. **Tracer la demande**: Extraire la demande de GraphQL, variablesM SK2 et nom d'opération
2. **Établissement rapide**: Envoyer la structure de demande au LLM avec des instructions pour produire les données correspondantes
3. **Générer les données**: LLM crée des données réalistes qui correspondent exactement aux champs de demande
4. **Réponse à l'enveloppe**: Retourne les données dans le format GraphQL `{ "data": {...} }`

### Avantages clés

- **Aucune spécification de forme n'est requise**: La demande GraphQL définit la structure
- **Type Sécurité**: Demande explicitement des champs de demande par nom
- **Relations nichées**: Soutien naturel pour les structures de données nested complexes
- **Format normalisé**: Travaille avec toute bibliothèque de clients GraphQL
- **Données réalistes**: LLM produit des données contextuellement appropriées pour chaque champ

### Évaluation de GraphQL

Utiliser l'inclusion `LLMApi.http` fichier qui contient 5 prêtM SK1à-utiliser des exemples de GraphQL :

- Demande simple de l'utilisateur
- Demande avec des variables
- Champs nichés avec des tableaux
- E-catalogue de produits du commerce
- Données organisationnelles complexes

Voir le [Exemples de GraphQL dans LLMApi.http](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMApi/LLMApi.http#L229-L294) pour des exemples de travail complets.

### Configuration de GraphQL

#### Limites des symboles et sélection du modèle

Les réponses de GraphQL peuvent devenir importantes avec des questions profondément nichées. Pour empêcher les erreurs de truncation JSON, configurez la `GraphQLMaxTokens` option:

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

**Lignes directrices sur les limites des symboles:**

| Modèle
|-------|----------------------|-------|
| **Modèle** | 300-500 ≥| Le meilleur équilibre de la vitesse et de la complexité
| **Mistral:7b** | 300-500 ≥| Génie bien les structures ensemencées.
| **3** | 200-300 ≥| Gardez les demandes simples |
| **de l'eau potable** | 150-200 ≥| Utiliser uniquement les demandes de renseignements superficiels

**Pourquoi un niveau inférieur est meilleur:**

- La priorité est donnée à la demande. **correction par rapport à la longueur**
- Les limites inférieures obligent le LLM à générer un JSON plus simple, complet
- Limites plus élevées risquent de réduire les réponses (invalid JSONM SK1
- Si vous voyez les erreurs "Invalid JSON from LLM **Réduire les GraphQLMaxTokens**

**Pour les demandes complexes Nested:**

1. Utilisez des modèles plus grands (llmM SK1model, mistral :7bMSC4
2. Augmenter GraphQLMaxTokens à 500-1000
3. Garder les tailles des tableaux petites (2 items max par défaut)
4. Surveiller les registres pour les avertissements de truncation

**Exemple de configuration pour les demandes complexes:**

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

## SignalR Real-Traitement de données en temps réel

L'API LLMock comprend un support SignalR facultatif pour la production de données continues , réelles - d'un modèle de temps

- Prototypes de tableaux appelant des mises à jour en direct
- Évaluation des composants de l'interface real-time
- Démos avec des données en constante évolution
- Test d'intégration WebSocket/SignalR

### Démarrage rapide avec SignalR

**SignalR fonctionne indépendamment - vous n'avez pas besoin de l'interface REST API pour utiliser le flux signalR.**

**1. Signal minimalRM SK1Système de configuration seulement:**

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

**Optionnel: Ajouter REST API aussi**

Si vous voulez aussi les points de fin REST API, ajouter ces lignes:

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

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

**2. Configurer dans les paramètres d'applicationM SK1json:**

```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"
      }
    ]
  }
}
```

**3. Connexion à partir du client**

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

### Configuration du contexte de l'Hub

Chaque contexte de hub simule une demande API complète et génère des données continuellement:

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

**Recommended: Utiliser des descriptions en anglais simples**

Laissez le LLM générer automatiquement des structures JSON appropriées:

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

Le LLM génère automatiquement un schéma JSON approprié de votre description.

### API de création du contexte dynamique

Créer et gérer les contextes de SignalR au moment du démarrage en utilisant l’API de gestion:

#### Créer un contexte

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

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

Réponse:

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

#### Liste de tous les contextes

```bash
GET /api/mock/contexts
```

Réponse:

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

Note: Le point final de la liste fusionne les contextes configurés dans les appsettings.json avec tout contexte dynamiquement créé au moment du démarrageM SK2 Les descriptions des appsets sont incluses même si ces contextes n'ont pas encore été dynamicement enregistrés .

#### Obtenir un contexte spécifique

```bash
GET /api/mock/contexts/weather
```

Réponse:

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

#### Supprimer le contexte

```bash
DELETE /api/mock/contexts/crypto
```

Réponse:

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

#### Démarrer le contexte (Resumer la génération de données)

```bash
POST /api/mock/contexts/crypto/start
```

Réponse:

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

Commence à produire des données pour un contexte interrompu sans affecter les clients connectés.

#### Stop Contexte (Pause Data Generation)

```bash
POST /api/mock/contexts/crypto/stop
```

Réponse:

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

Cesse de produire de nouvelles données mais garde le contexte enregistré. Les clients demeurent connectés mais ne reçoivent aucune mise à jour jusqu’à ce qu’ils soient relancés.

### Exemple de client complet

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

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

### Création du contexte dynamique à partir de l'interface

```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!");
}
```

### Méthodes d'appui de SignalR

L'article 5 de la Loi sur l'immigration et le statut des réfugiés `MockLlmHub` appuie les méthodes suivantes:

**SubscribeToContext(contexte de chaînes)**

- Inscrire le client pour recevoir des mises à jour de données pour un contexte particulier
- Le client recevra `DataUpdate` événements avec des données générées
- **Nouveaux dans v1.1.0:** Augmente automatiquement le nombre de connexions du contexte'

**Désubscrire à partir du contexte(contexte de chaînes)**

- Désubscrire le client à partir d'un contexte
- Le client ne recevra plus de mises à jour pour ce contexte.
- **Nouveaux dans v1.1.0:** Réduira automatiquement le nombre de connexions du contexte'

**Événements reçus par le client:**

**Mise à jour des données** - Contient des données de modèle générées

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

**Adhésion** - Confirmation de l'abonnement

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

**Non appuyé** - Confirmation de non-abonnement

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

### Options de configuration

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

### Soutien du schéma JSON

Les contextes de l’hub appuient à la fois les formes simples JSON et le schéma complet JSON:

**Forme simple:**

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

**Système JSON:**

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

Le système auto- détecte le schéma JSON en cherchant `$schema`, `type`, ou `properties` champs.

### Architecture

**Components:**

- **MockLlmHub**: Le hub SignalR traite des connexions et des abonnements clients
- **MockDataBackgroundService**: Service hébergé produisant continuellement des données
- **DynamicHubContextManager**: Thread- gestionnaire sécuritaire pour l'enregistrement du contexte de temps d'exécution
- **Configuration du contexte Hub**: Modèle de configuration pour chaque contexte de données

### Utiliser les cas

**1. Prototypage du tableau de bord**

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

**2. Simulation de l'IoT**

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

**3. Données financières**

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

**4. Tableau de bord des jeux**

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

### Contexte Gestion du cycle de vie

**Nouveaux dans v1.1.0:** Contrôle complet du cycle de vie sur les contextes SignalR avec le suivi réel-de l'état d'avancement du temps!

Chaque contexte a les propriétés suivantes:

- **Il est actif**: Si le contexte génère des données
- **Nombre de connexions**: Nombre de clients actuellement connectés (autoM SK2tracked)

Contextes peuvent être dans deux états:

- **Activité**: Le service d’information produit chaque fois de nouvelles données `SignalRPushIntervalMs` (défaultM SK1 5 secondes)
- **Arrêtée**: Contexte demeure enregistréM SK1 clients restent connectés, mais aucune nouvelle donnée n'est générée

**Faits clés:**

- Démarrer/arrêter les contextes sans déconnecter des clients
- Surveillance du nombre réel de connexions
- Insignes de situation montrant l'état actif/État arrêté
- Prévention du contexte
- Contextes des appsettings.json apparaissent automatiquement dans l'interface

**Cache de réponse pour SignalR:**
**Nouveaux dans v1.1.0:** Le caching intelligent réduit la charge de LLM et améliore la cohérence!

- **Préalimentation en lots**: Génie simultanément des réponses 5-10 (configurables via `MaxCachePerKey`)
- **Per-Context Queues**: Chaque contexte maintient son propre cache des réponses générées avant -
- **Renouvellement du contexte**: Remplit automatiquement le cache lorsqu'il tombe sous la capacité 50%
- **Calendrier intelligent**: Réduise les appels LLM tout en maintenant la fraîcheur des données

Cela réduit considérablement la charge de LLM pour les contextes à fréquence élevée- , particulièrement avec plusieurs clients.

**Exemple de travail:**

```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 / Production de boucles d'évacuateur

**Nouvelle fonctionnalité:** Gérer automatiquement des paramètres de clôture à partir d'OpenAPI/Swagger spécifications! Pointer sur n'importe quel OpenAPI M SK2SWAgger 2.0 spec (URL ou fichierMSC5 et la bibliothèque créera des parameters de cloison pour toutes les opérations définies

### Démarrage rapide avec OpenAPI

```bash
dotnet add package mostlylucid.mockllmapi
```

**Programme.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.jsonM SK1**

```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"
      }
    ]
  }
}
```

Que's it! Tous les points de fin provenant de votre spécification OpenAPI sont maintenant disponibles en tant que modèles intelligents LLM

### Comment cela fonctionne

1. **Établissement de spécifications**: Charge les spécifications OpenAPI à partir d'URLs ou de fichiers locaux (JSON ou YAML)
2. **Conversion du schéma**: Convert les schémas OpenAPI à des modèles de forme JSON
3. **La cartographie des points finals**: Carte automatiquement toutes les opérations aux points de départ ASP.NET Core
4. **Production de LLM**: Utilise LLM pour produire des données de modèle réalistes correspondant au schéma
5. **Paramètres du chemin**: Génie les paramètres du chemin comme `/users/{id}` Automatiquement

### Options de configuration

Chaque spécification OpenAPI appuie ces options de configuration:

| Propriété | Type MSC2 Description SMC3
|----------|------|-------------|
| `Name` | chaîne | Identificateur unique pour cette spécification
| `Source` | chaîne | URL ou chemin de fichier à OpenAPI spécification
| `BasePath` | chaîne | Insérer le chemin de base ≥(defaultM SK3 utilise les spécifications's `servers[0].url`) |
| `EnableStreaming` | bool | Ajouter `/stream` suffix pour SSE streaming (default:fausseM SK2 |
| `IncludeTags` | chaîne[] | générer uniquement les points de fin avec ces balises.
| `ExcludeTags` | chaîne[] | Passer les points finals avec ces balises |
| `IncludePaths` | chaîne[] | Seulement générer ces chemins. `/users/*`) |
| `ExcludePaths` | chaîne[]

### Exemples de configuration avancées

**Filtrer par tags:**

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

**Filtrer par chemins:**

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

**Enable streaming:**

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

### Évaluation des Mocks OpenAPI

Configuration des spécifications OpenAPI:

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

Et une spécification définissant `GET /pet/{petId}` qui retourne un `Pet` object, vous pouvez tester

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

### Utilisation modulaire

Les modèles OpenAPI fonctionnent indépendamment de REST/GraphQLM SK1SignalR:

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

### Formats spéciaux supportés

- **OpenAPI 3.0** (JSON ou YAMLM SK1
- **OpenAPI 3.1** (JSON ou YAMLM SK1
- **Swagger 2.0** (JSON ou YAMLM SK1

### Faits clés

- **Production automatique d'un point final**: Tous les chemins et toutes les opérations de spec deviendront des points d'exécution modèles
- **Schema-Driven**: Formes de réponse dérivées des schémas de réponse OpenAPI
- **Paramètres du chemin**: Dispositifs `/users/{id}`, `/posts/{postId}/comments/{commentId}`, etcM SK1
- **Échantillons multiples**: Charger et monter plusieurs spécifications API simultanément
- **Filtration intelligente**: Inclure/exclure les opérations par balises ou chemins
- **Soutien à la diffusion**: Transmission optionnelle d'SSE pour n'importe quel point final
- **LLM-Powered**: Génie des données réalistes , variées appropriées pour chaque schéma

### Utiliser les cas

- **API- Premier développement**: Commencez à coder contre la spécification avant que le backend ne soit prêt
- **Frontend Prototyping**: Élaborer l’UI pendant que l’API est construit
- **Évaluation de l'intégration**: Tester le code client sans dépendance API réelle
- **Environnements de démonstration**: Présentation d’applications sans accès à l’API de production
- **Examen des contrats**: Vérifier que les clients manipulent correctement toutes les variations du schéma
- **Essais de chargement**: Gérer des données d'essai réalistes à l'échelle

### Limitations

- À l'heure actuelle, seuls les schémas de réponse sont supportés (la validation de la demande n'est pas exécutée)
- Les schémas de sécurité sont ignorés (pas d'authentification requise)
- Seule l'application/json type de contenu est supporté pour les réponses
- Les valeurs des paramètres du chemin ne sont pas validées contre les contraintes du schéma

### Évaluation de la gestion OpenAPI

L'inclusion `management.http` le fichier contient des exemples exhaustifs pour tous les points de gestion:

**Gestion des spécifications**:

- Charger des spécifications à partir d'un URL (Petstore, API de GitHub , etcM SK3
- Charger des spécifications de fichier local
- Charger des spécifications de JSON raw/YAML
- Liste de toutes les spécifications chargées
- Obtenir des détails spéciaux avec les points finals
- Recharger la spécification (refresh de source)
- Supprimer les spécifications

**Évaluation du point final**:

- Vérifier les points de fin GET avec des paramètres du chemin
- Évaluer les points de fin POST/PUT/DELETE
- Évaluer les points finals avec des paramètres de la demande
- Vérifier plusieurs points de fin dans une séquence

**Processus de travail avancés**:

- Charger plusieurs spécifications simultanément
- Comparaison des modèles OpenAPI avec les modèles réguliers
- Opérations par lots
- Erreur de traitement des exemples

**Exemple de la gestion.http**:

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

Voir le document complet [gestion.http](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMApi/management.http) fichier pour 20+ prêtM SK1à-utiliser des exemplesMSC3

### Applications de démonstration

Le paquet comprend des applications de démonstration complètes avec interfaces interactives comportant une gestion complète du contexte:

#### Client de bureau Windows (`LLMockApiClient/`) — Application du WPF (En développement)

> **⚠️ ÉTAT DU DÉVELOPPEMENT**: Le client de bureau Windows est actuellement en cours d’élaboration active . Bien que plusieurs fonctionnalités soient fonctionnelles M SK2 certaines fonctions peuvent être incomplètes ou susceptibles de changer . Utilisation à des fins d’essai et de développement

Une application de bureau WPF complète pour interagir avec l'API LLMock:

**Caractéristiques:**

- **Tableau de bord**: RealM SK1État de la connexion et surveillance du système
- **SignalR Real-Time**: Créer des contextes et abonner aux flux de données en direct
- **SSE Streaming**: Trois modes d'acheminement (tokens, objetsM SK3 éléments de tableauxMSC4
- **Gestionnaire OpenAPI**: Charger les spécifications des points d’essai URL/JSONM SK2
- **Services gRPC**: Soumettre à jour . fichiers de protocole, méthodes d'essai gRPC
- **Jouer avec les API**: Terrain de test HTTP interactif
- **Multi-Support du backend**: Configurer et passer entre plusieurs backends
- **Surveillance du trafic**: Demande HTTP en direct/logage des réponses
- **Dark/Thème clair**: Toggler entre les thèmes avec des transitions linéaires

**Documentation:** [LLMockApiClient README](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMockApiClient/README.md)

**Perfect pour:** Processus de travail d'essai de bureaux, exploration visuelle des API, développement et débugging

---

#### Démos basés sur le Web-

#### SignalR Demo (`/`) — Real- Streaming de données temporelles avec l'interface de gestion

**Nouveaux dans v1.1.0:** Établissement amélioré de la colonne 3- avec gestion du cycle de vie du contexte complet!

**Caractéristiques:**

- **Créer un panneau de contexte**: Inscrire des descriptions en anglais simples, le système produit un schéma JSON approprié
- **Panel de contextes actifs**:
  - Liste en direct de tous les contextes avec des badges d'état (ActiveM SK1Stopped)
  - affiche automatiquement les contextes des appsettings.json au démarrage
  - Cote de connexion réelle- pour chaque contexte
  - Per-contexte de commandes:ConnexionM SK2Disconnection ,StartMST4StopMSC5Délete
  - Auto-refresh sur les changements
- **Panel de données en direct**: RéelM SK1 mises à jour en temps réel des contextes abonnés (toutes MSC3 secondesMSc4
  - **Éclaircissement de la syntaxe JSON**: Pièce noireM SK1Display thématique avec couleur-éléments codés
  - Mots clés (rougeM SK1stringes (vert),numéraires MSC4orangeMSC5booleans MSC6cyanMNK7nuel S(purpleMRK9
  - Nettoyage, format lisible avec une affiche de temps appropriée
  - Aucune dépendance extérieure.

**Quick-Exemples de démarrage:** Un -cliquez sur les boutons pour 5 pré-- scénarios configurés:

- **Sensors IoT**: Capteurs de température avec ID d'appareilM SK1 Données de mesure, pourcentage de batterie
- **Marché des actions**: réel - prix à temps avec ticker, prixM SK3 pourcentage de variationMSC4 volume
- **E-ordonnances de commerce**: Obtenir des commandes avec l'IDMSC1 client, tableau d'articlesM SK3 état de la demandeMST4 total
- **Métrique du serveur**: Surveillance des données avec le nom de l'hôte , CPU, mémoireM SK3 disqueMSC4 connexions
- **Tableau de classement des jeux**: Statistiques relatives aux joueurs avec le nomM SK1 cote , rangMSC3 niveau, pays

**Perfect pour:** Tableaux d'affichage, surveillance en direct , simulations de l'IoT, réelsM SK3 feeds temps+, prototypage

#### SSE Streaming Demo (`/Streaming`) — Production progressive de JSON

**Nouveaux dans v1.1.0:** Quick-marrage des boutons d'exemple pour la diffusion instantanée!

**Caractéristiques:**

- Configurer la méthode HTTP, le chemin, et la forme JSON facultative
- Voir le JSON généré en token-parM SK1token en temps réel-
- Statistiques en direct: Nombre de blocs de donnéesM SK1 Durée de l’enquête, Taille des données
- Indicateurs de l'état de la connexion

**Quick-Exemples de démarrage:** Un-cliquez sur les boutons pour 4 scénarios de télédiffusion:

- **Liste des utilisateurs**: Array of user objects with ID, nameM SK2 email
- **Catalogue des produits**: Inventaire de produits avec SKU, nomM SK2 prixMSC3 état des stocks
- **Détails de commande**: Commandes ensérées avec des renseignements sur les clients et un tableau d'articles
- **Données météorologiques**: Conditions actuelles avec température, humiditéM SK2 vitesse de vent

**Perfect pour:** Observer la génération de LLM, les formes de débugging , comprendre le comportement d'acheminement des données, tester l'SSE

#### OpenAPI Manager Demo (`/OpenApi`) — Charge de spécifications dynamiques & Essai

**Nouvelle fonctionnalité:** Gestion interactive des spécifications OpenAPI avec mises à jour réelles

**Caractéristiques:**

- **Charger des spécifications dynamiquement**: De l'URL ou imposer JSON brute /YAML directement dans le navigateur
- **Mise à jour du temps réel-**: SignalR-avertissements en direct pour toutes les actions
- **La découverte d'un point final**: Extraction automatique de toutes les opérations de spec
- **In-Examen du navigateur**: Vérifier tout point final avec un seul clic , voir LLM-données de modèle produites
- **Gestion du cycle de vie**: ChargerM SK1 recharger , supprimer les spécifications sans redémarrer le serveur
- **Une interface très belle**: Color-méthodes HTTP codéesMSC2syntaxeM SK3réponses JSON hautement éclairées
- **État de la connexion**: Indicateur en direct montre l'état de la connexion SignalR
- **Aide globale**: Documentation en ligne et URLs d'exemple

**Quick-Exemples de démarrage:**

- Charger l'API Petstore à partir de URL
- Insérer le JSON OpenAPI personnalisé
- Voir tous les points de fin à partir du spec
- Tester les points finals directement sur la page
- Voir les données de simulation réalistes produites par LLM

**Perfect pour:** Élaboration de prototypes d'API, développement de frontendsM SK1 essais contractuels , validation des spécifications, démonstrations

**Effectuer les démonstrations:**

```bash
cd LLMApi
dotnet run
```

Naviger à:

- `http://localhost:5116` - SignalR réel-transmission de données en temps avec l'interface de gestion
- `http://localhost:5116/Streaming` - SSE génération progressive
- `http://localhost:5116/OpenApi` - Gestionnaire de spécifications OpenAPI avec charge dynamique

Toutes les démonstrations comprennent:

- Documentation en ligne complète
- Exemples de démarrage rapides interactifs-
- Pièces de code pour l'intégration
- Indicateurs de temps réels
- Contrôles du cycle de vie en contexte complet

## Caractéristiques avancées

### Écho du schéma de réponse (ShapeM SK1 Exportation

Vous pouvez optionnellement avoir l'écho du logiciel de middleware en retour à la forme JSON/schema qui a été utilisée pour générer la réponse prototype.

Configuration:

- Option: IncludeShapeInResponse (boolM SK2 fausse par défaut)
- Per-request override: add query parameter includeSchemaMSC2true M SK3or 1)
- Header émis: XM SK1Response -Schema (seulement lorsqu'une forme et une taille ont été fournies M SK4 4000 charsMSC6
- Streaming: l'événement final SSE comprend un champ de schéma lorsque activé

Exemples:

- Activer à l'échelle mondiale (appsettings.jsonM SK2

```json
{
  "mostlylucid.mockllmapi": {
    "IncludeShapeInResponse": true
  }
}
```

- Activer par requête (passe les commandes de configuration):

```bash
curl "http://localhost:5000/api/mock/users?shape=%7B%22id%22%3A0%2C%22name%22%3A%22string%22%7D&includeSchema=true"
```

Réponse inclut le titre:

```
X-Response-Schema: {"id":0,"name":"string"}
```

- Streaming: événement final contient un champ de schéma lorsqu'il est activé

```
...
data: {"content":"{full json}","done":true,"schema":{"id":0,"name":"string"}}
```

Notes:

- Si aucune forme n'a été fournie (par l'entremise de la demandeM SK1entête /corps),, le titre n'est pas ajouté
- Les formes très grandes (> 4000 charsM SK2 ne sont pas ajoutées à l'en-tête pour éviter les problèmes de transport, mais la réponse normale se poursuit

Cases à utiliser:

- Client-génération de type TypeScript côté
- Documentation API et validation du schéma
- Débugging de l'analyse des formes
- Validation du temps d'exécution

### Télécharger les fichiers

Supprimer les prompts par défaut avec votre propre :

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

Placeurs disponibles:

- `{method}` - Méthode HTTP
- `{path}` - Voie de demande complète avec chaîne de recherche
- `{body}` - Organe de demande
- `{randomSeed}` - Semences aléatoires générées
- `{timestamp}` - Timbre Unix
- `{shape}` - spécification de forme  s’il est fourniM SK2

### Simulation d'une erreur

Testez le traitement des erreurs de votre client' avec des capacités complètes de simulation d'erreurs.

**Quatre façons de configurer les erreurs** ( dans l’ordre de prioritéM SK1

1. **Paramètres de la demande** (priorité la plus élevéeM SK1

**INTÉRÊT**: Les valeurs des paramètres de la demande doivent être URL -encodée. Les espaces deviendront `%20`, `&` devient `%26`, `:` devient `%3A`, etcM SK1

```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. **Les en-têtes HTTP**:

```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. **Forme JSON** (utilisation `$error` propriété):

```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. **Organe de demande** (utilisation `error` propriété):

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

**Formats de réponse aux erreurs:**

Règlement/Contrôle de l’écoulement finalM SK1

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

GraphQL point final:

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

**Simulation de l'erreur SignalR:**

Configurer les erreurs dans les contextes de SignalR pour l'essai réel-manifestation des erreurs temporelles:

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

Ou dynamiquement via l’API de gestion:

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

**Codes de statut HTTP supportés:**

Le paquet comprend des messages par défaut pour les codes d'état HTTP communs:

- **4xx Erreurs de client**: 400 ≥(Requête défectueuse), ≤401 ±(Une demande non autoriséeM SK6 403 =(Prohibée~), ─404 (N'a pas été trouvée~
- **5xx Erreurs sur le serveur**: 500 \(Erreur de serveur interne), ♫501 |(Non mis en œuvreM SK6 ─502 (Gateway mal entretenueMSC9 ◦503 ‒(Service inapproprié~), −504 ¬(Excès d'accès à la passerelle~)

Messages personnalisés et détails supprimer les défauts.

**Utiliser les cases:**

- Essai de la logique du retry du client et arrêt exponentiel
- Valider l'affichage du message d'erreur dans la UI
- Authentication d'essai/Flois d'autorisation
- Simulation des scénarios de limitation du taux
- Pratiquer des modèles de dégradation gracieux
- Essai d'enregistrement et de surveillance des erreurs

Voir `LLMApi/LLMApi.http` pour des exemples exhaustifs de toutes les méthodes de simulation d'erreur.

### Instances multiples

Monter plusieurs APIs de modèle avec différentes configurations:

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

## Spécification de la forme

Trois façons de contrôler la structure de réponse:

1. **Intitulé** (recommandéM SK1 `X-Response-Shape: {"field":"type"}`
2. **Param de la demande**: `?shape=%7B%22field%22%3A%22type%22%7D` (URLM SK1JSON encoded)
3. **Champ du corps**: `{"shape": {...}, "actualData": ...}`

### Cacher plusieurs réponses par l'entremise de la forme

Vous pouvez instructer le logiciel intermédiaire à prégénérer et cacher plusieurs variantes de réponse pour une demande spécifique.

- La clé de cache est dérivée de la méthode HTTP + chemin (y compris la demande) + la forme sanitisée (avec S$le cache a été suppriméM SK6en utilisant le SystèmeMNK7IOMRK8Hashing XXHashMSC9
- Jusqu’à N des réponses sont préfetchées du LLM et stockées dans -memory (capped par MaxCachePerKey en options; par défaut 5).
- Les demandes d’acheminement non ultérieures pour la même clé sont fournies à partir d’une liste en déclin; lorsqu’elles sont épuisées, un nouveau lot de N est préfetché automatiquementM SK3
- Les terminaux de flux ne sont pas cachés.

Exemples

- Forme de l'en-tête:
  X-RéponseM SK1Shape: {"$cache+":3,"orderId=":"+string+","+status+MSC7+string&","+items+M SK9+[{"skuM SK1string ","qty":0}]}

- Forme du corps:
  {
  "formeM SK1  {
  "$cacheM SK1  5,
  "invoiceId":  "stringM SK3
  "customerM SK1 { ≥"id": ≤"stringMSC6 "name=": "string+"
  "itemsM SK1 [ { "skuM SK2 ≥"string", ≤"qtyMSC6 \ \ 0, | | "price
  "total
  }
  }

- Param de la question (URL-encodéM SK2
  ?formeMSC1BM SK2cache%22%3AMST4CMSS5useursMSP6A+MST7B+MSS8B=MST9idMSV10A&MST11C&MSS12nomMSSK13A*MST14stringMSR15D&MSR16D &MSR17D

Configuration

- MaxCachePerKey (intM SK1 par défaut 5): couvre le nombre demandé par "$cache" par cléMSC5

Notes

- L’indication "$cache" est retirée de la forme avant d’être envoyée au LLM
- Si "$cacheM SK1 est omitée ou 0,, la demande se comporte comme avant CSK3pas de cacheMSC4warmup).
- Les variantes cachées sont conservées dans la mémoire de l’application.

## Évaluation

### Trousse d'outils d'essai (NEW!)

**mostlylucid.mockllmapiM SK1Testing** - Un paquet NuGet conjoint qui rend encore plus facile le test avec l'API de modèle.

```bash
dotnet add package mostlylucid.mockllmapi.Testing
```

**Exemple rapide:**

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

**Faits clés:**

- **API fluide**: Configuration facile avec `WithShape()`, `WithError()`, `WithCache()`, etcM SK1
- **Intégration des clients Http**: Travaille sans fil avec `HttpClient` et `IHttpClientFactory`
- **Plusieurs points de fin**: Configurer différents comportements pour différentes voies
- **Simulation d'une erreur**: Traitement des erreurs d'essai avec divers codes de situation
- **Soutien à la diffusion**: Points de fin d'écoulement des essais SSE
- **Injection de dépendance**: Built-in support for typed and named clients

**Exemples de configuration:**

```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<IUserApiClient>(
    baseApiPath: "/api/mock",
    configure: handler => handler
        .ForEndpoint("/users", config => config.WithShape(...))
);
```

**Comment il fonctionne:**
L'article 5 de la Loi sur l'immigration et le statut des réfugiés `MockLlmHttpHandler` est un `DelegatingHandler` qui intercepte les demandes HTTP et applique automatiquement votre configuration par le biais de paramètres de recherche et d’entêtes avant de transmettre à l’API mock. Cela signifie que vous pouvez utiliser `HttpClient` instances dans vos tests tout en contrôlant le comportement de modèle de façon déclarative.

**Voir le [Évaluation du paquet README](https://github.com/scottgal/LLMApi/blob/refs/heads/master/mostlylucid.mockllmapi.Testing/README.md) pour une documentation complète et des exemples.**

### Examen des fichiers HTTP

Utiliser l'inclusion `LLMApi.http` fichier avec:

- Visual Studio / Client HTTP Rider
- VS Code REST Extension de client
- Tout client HTTP

### Essais d'unité

Le projet comprend des essais unitaires complets:

```bash
# Run all tests
dotnet test

# Run with detailed output
dotnet test --verbosity detailed
```

**Catégorie d'essai (228 tests, 100% taux de passageM SK3**

- **Lecture du corps** ( vides , Contenu de JSONM SK2 corps de formulaires, téléchargements des fichiers )
- **Partage du corps de forme** (valeurs uniquesM SK1valences multiples , caractères spéciaux)
- **Données sur les formulaires multipartites** (métadonnées de fichiers , champs et fichiers mixtes)
- **Évacuation de JSON** (quotesMSC1backslashes,newlinesM SK3 tabs , unicode
- **Extraction de contenu** (Format OpenAIM SK1JSON ensemencée complexe ,manifestation des erreurs)
- **Construction manuelle de JSON** (données de formeM SK1arrées,structures ensemencées )
- **Extraction de formes** (param de la demandeM SK1en-tête , champ du corps, préséanceMSC4
- **Production rapide** (randomitéM SK1inclusion de la forme ,modes d'écoulement)
- **Bâtiment de demande** (températureM SK1modèle
- **Cases à bord** (JSON invalidM SK1données manquantes , caractères spéciaux)
- **Essais d'intégration** (flow de travail HTTP complet, présentations de formulairesM SK2 téléchargements de fichiers , voies profondes )

**Nouveaux dans v2.3.0:**

- **FormBodyHandlingTests.cs** - 12 essais pour le partage des corps de forme et la construction JSON
- **JsonHandlingTests.cs** - 25 essais pour l'évacuation de JSONM SK2 extraction, et cases à bord
- **Tests d'intégration.cs** - Cadre d'essai d'intégration pour l'analyse complète des points finals HTTP

Voir [TEST_SUMMARYM SK1md](https://github.com/scottgal/LLMApi/blob/refs/heads/master/TEST_SUMMARY.md) pour la documentation complète des essais et les mesures de couverture.

## Architecture

Voir [Aperçu de l'architecture](#architecture-overview) ci-dessus pour le diagramme de système et la description des composants à haut niveau-

### Flux de demande détaillé

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

### Flow de contrôle des formes

```mermaid
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
```

**Projets:**

- `mostlylucid.mockllmapi`: NuGet package library
- `LLMApi`: Application de démonstration
- `LLMApi.Tests`: suite d'essai xUnit (228 essais

## Pourquoi utiliser le plus souventlucid.mockllmapi?

- **Prototypage rapide**: Développement de frontend sans attendre le backend
- **Soutien HTTP complet**: JSONM SK1 organes de formulaires, téléchargements des fichiers - tous les types de contenu couverts
- **Flux de travail cohérents**Les contextes API de : maintiennent des relations réalistes à travers les processus multi-procédures -
- **Démos**: Montrer des flux de données réalistes sans fixtures codées
- **Évaluation**: Gérer des données d'essai variées pour les cas de bord - ou des données cohérentes avec les contextes
- **Memory-Safe**: Les téléchargements des fichiers sont en train de se faire et d’être dédoupés.
- **Conception de l'API**: Expérimenter les formes de réponse avant la mise en œuvre
- **Apprentissage**: Exemple d'intégration du LLM dans les API minimales de .NET
- **Entretien zéro**: Aucune base de donnéesM SK1 aucun état, aucun fichier d'information à entretenir
- **Flexible**: Utiliser toute combinaison des spécifications RESTM SK1 GraphQL, SSE , SignalRMSC4 ou OpenAPI
- **Production-Ready**: 228 essais, ≥100% taux de passageM SK4 documentation détaillée

## Établissement du paquet NuGet

```bash
cd mostlylucid.mockllmapi
dotnet pack -c Release
```

Le paquet sera en `bin/Release/mostlylucid.mockllmapi.{version}.nupkg`

## Contribuer

Il s’agit d’un projet-échantillon qui démontre l’utilisation de LLM-APIs mock à moteur.Assez libre de forcer et de personnaliser

## Licence

Il s’agit d’un logiciel gratuit et sans entrave publié dans le domaine public. Voir [LICENCE](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LICENSE) pour plus de détails ou visite [sans licence.org](https://unlicense.org).

This is a preview from the server running through my markdig pipeline

AI API ASP.NET Core LLM LLMApi mockllmapi Nuget

LLMApi: Utilisation de LLM locaux pour simuler automatiquement les API dans ASP.NET Core MinimalAPI

Sunday, 02 November 2025

Introduction

Une de mes obsessions constantes est l’échantillonnage des données. Combiné à mon amour actuel de 'AI assisté ' codage d’idées aléatoires il' a conduit à la mise en place d’un petit générateur de données d’essai activé par LLM ainsi qu’à un paquet nuget avec un middleware qui peut générer des réponses API simulées au moyen d’une API

Vous pouvez trouver le GitHub ici pour le projet, tous les domaines publics, etc.

Concept

Comme pour beaucoup d’idées de codage "AI Assisted" il a commencé par une idée sur la simulation des résultats à l’aide de LLMsM SK2 J’étais en train de travailler sur un autre projet (LucidForums, une expérience de forum basée sur l’autopopulation LLM qui est hilarément dysfonctionnelle ) et les LLMs sont vraiment bons ( si un peu lentement) à produire des données d’échantillonnage. ce qui se passerait si Je peux les utiliser pour simuler n'importe quel API.

Exigences

Il devrait être simple de mettre en œuvre dans un ASP.NET Core App.
Les données devraient être assez réalistes.
Les données devraient être aléatoires
Il peut accepter JSON 'shapes' qui indiquent au LLM quelle devrait être la réponse.
Il peut utiliser des LLM de source ouverte locale
Il devrait être gratuit d'utiliser le contrôle Nuget

C’est ce que j’ai trouvé.

Les ajouts futurs incluront vraisemblablement le caching en cas de besoin plus rapide perf.

Voici le readme du paquet (fetched automatically).

mostlylucid.mockllmapi

Ce qu'il fait: Une production-ready ASP.NET Core mocking platform for generating realistic mock API responses using LLMsM SK2

Pourquoi l’utilisez-vous ? Ajouter des paramètres de modèle intelligents à tout projet avec seulement 2 lignes de code—pas de bases de donnéesM SK2 pas d'installations codées durementMSC3 pas de maintenance .

Companion Package: mostlylucid.mockllmapiM SK1Testing - Utilisations d'essai avec une intégration HttpClient fluide

Comment lire ce README

Ce README est complet par design. Choisissez votre chemin:

"Je veux essayer cela en 5 minutes" → Passer à Démarrage rapide
"Je veux savoir ce que cela peut faireM SK1 → Voir Aperçu des caractéristiques et Architecture
"Je veux comprendre comment cela fonctionne" → Lire Documentation sur les caractéristiques et Caractéristiques avancées

Qu’est-ce que ' Nouveau - TLM SK2DR

Le plus récent: AutoShape (Shape Memory) - Conséquence automatique de la structure JSON à travers les appels en point final v2.5.0: Améliorations de la sécurité, AOT/appui à l'enlèvement par le retrait des dépendances de serialisation v2.3.0: Soutien du type de contenu complet - organes de formulaires, téléchargement des fichiers , essais exhaustifs v2.2.0: Outils pluggables pour l'intégration des API, pré-APIs REST configurésM SK2 expiration automatique de la mémoire contextuelle v2.1.0: Limitation du taux, battage, nM SK2achèvements avec plusieurs stratégies d'exécution

Click for detailed v2.5.0 feature breakdown

Version 2.5.0 Détails

Concentration: Améliorations de sécurité et AOT/appui à l'amorçage en supprimant les dépendances liées à la serialisation . Compatible avec v intégralement arrièreM SK3

1. AOT/Support à l'écoulement - Remplacement de toutes les dépendances de réflectation fondées sur la serialisationM SK1:

Élimination System.Text.Json utilisation de la réflexion
Construction manuelle de JSON dans toute la base de code
Compatibilité complète avec .NET 8.0+ AOT et trimming
Aucun problème de résolution du type runtime
Plus petite taille binaire et meilleure performance de démarrage

2. Sécurité améliorée - Amélioration complète de la sécuritéM SK1

On a supprimé toutes les séries basées sur la réflexion- qui pourraient exposer l'information de type.
Élimination des vulnérabilités liées à l'inférence de type potentiel
Gestion plus sûre de JSON avec des contraintes explicites du type
Surface d'attaque réduite pour les exploits basés sur la serialisation-
Une meilleure protection contre les attaques de déserialisation

3. Optimisations du rendement - Performance améliorée du temps d'exécutionM SK1

Construction plus rapide de JSON sans réflexion au-dessus
Réduction des affectations de mémoire
Améliorer la localité du cache
Amélioration du temps de démarrage pour les applications trimmées
Imprint inférieur de la mémoire

Compatibilité - Soutien complet pour les constructions de préview .NET

Construction manuelle de JSON tout au long afin d’éviter les problèmes de séries basés sur la réflexion-
Tous les éléments testés et utilisés sur .NET 10 préview builds
Aucune modification de la fonctionnalité existante

5. Amélioration des essais - Protection des essais amélioréeM SK1

Essais additionnels pour les scénarios de trimming AOT/
Sécurité-essais axés sur les unités
Essais de comparaison du rendement
100% taux de passage avec tous les nouveaux tests

Pour plus de détails, voir TEST_SUMMARYM SK1md et IMPLEMENTATION_SUMmARY .md.

Click for detailed v2.3.0 feature breakdown

Version 2.3.0 Détails

Concentration: Soutien complet du type de contenu pour tous les formats de demande HTTP communs . Compatible à l'arrière-plan avec v2.2.0.

1. Forme de soutien du corps - Soutien complet pour application/x-www-form-urlencoded type de contenu. valeurs uniques et multiples , conversion automatique JSONM SK2 construction manuelle pour .NET MSC4 compatibilitéMSC5 parfait pour tester les formulaires HTML et les applications Web traditionnellesMST6

Soutien au téléchargement de fichiers 2. - Soutien complet pour multipart/form-data Incluant les téléchargements de fichiers. MémoireM SK1Traitement sécuritaire (8Buffer KB), Extraction des métadonnées MNK4Nom du fichier MNK5 tailleMKK6 type de contenuMMK7 champs et fichiers à forme mixteMRK8 Le contenu est dédoupé pour éviter une blotte de mémoireMCK9

3. Longueurs arbitraires des voies - Soutien à la nidification par voie profonde via {**path} catch-total routing. Étudié avec 9-pathes profonds de segment et chaînes complexes de demandesM SK3 Aucune limite pratique sur la profondeur du chemin MSC4 jusqu’à ASP

4. Suite d'essai approfondie - 228 essais 37 nouveauM SK3 couvrant toutes les fonctionnalités. Partage du corps de forme M(12 essaiMS), manipulation JSON (25 testsM), tests d'intégration pour des flux de travail HTTP completsMSC9 MMSC10 taux de passageM MSC11 régression zéro MMSC12

Compatibilité - Construction manuelle de JSON tout au long du processus afin d'éviter les réflexions- problèmes de serialisation basés sur . Toutes les fonctionnalités testées et utilisées sur .NET

Pour plus de détails, voir TEST_SUMMARYM SK1md et IMPLEMENTATION_SUMmARY .md.

Click for detailed v2.2.0 feature breakdown

Version 2.2.0 Détails

Concentration: Outils pluggables pour l'intégration des API, préM SK2APIs REST configurés , et mémoire contextuelle intelligente

1. Outils pluggables & Système d'actions - Demander à des API externes REST ou à des points d'extrémité de modèles de chaîne pour créer des flux de travail et des arbres décisionnels réalistes Dossiers complets →

2. Pré-APIs REST Configurés - Définir les configurations API complètes une fois qu’on a appelé , appel par nom . Référence à la spécification de Shape ou OpenAPI , Gestion du contexte partagée , Intégration des outils . Voir appsettings.Full.json pour les exemples complets de 8

3. Gestion de la mémoire en contexte dynamique - Les contextes expirent maintenant après 15 minutes d'inactivité

4. Extraction intelligente de données partagées - Extrait automatiquement TOUS les champs des réponses à n'importe quel niveau de nidification . Objets nichés M SK2 Traçage d'arréaux , Données sur le premier article MSC4 Champs personnalisés MST5 Tous suivis automatiquement Mst6

5. Documentation améliorée - Nouveaux guides complets pour Outils & Actions, Limitation du taux, et Contextes de l'API.

Voir RELEASE_NOTES.md pour plus de détails

---

Table des matières

Concepts fondamentaux

Aperçu des caractéristiques - Ce que ce système peut faire
Démarrage rapide - Sortir en 5 minutes
Architecture - Comment cela allègue-t-il ensemble
Non-Objectifs M SK1 Limites - Ce qui n'est pas

Architecture avancée &

Options de configuration
Documentation sur les caractéristiques - Dans les guides de profondeur
Caractéristiques avancées
Applications de démonstration
Évaluation

Aperçu de l'architecture

Un moteur, protocoles multiples , infrastructure partagée. Toutes les fonctionnalités partagent la même génération, contexte , et systèmes de contrôle— vous offrant un comportement cohérent à travers RESTM SK3 GraphQLMska4 SSEMka5 SignalRM Ska6 OpenAPIM ska7 et gRPCMske8

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

Components clés:

Client unique LLM: Tous les protocoles utilisent la même intégration LLM avec des politiques de résilience
Mémoire de contexte partagé: Les contextes API fonctionnent à travers RESTM SK1 GraphQL , SignalR, et OpenAPI
Faits généraux: Limitation des vitesses , caching, simulation d'erreursM SK3 et gestion des tokens s'appliquent à tous
Modèle modulaire: Utilisez n’importe quelle combinaison—ajouter seulement ce dont vous avez besoin

Voir diagrammes d'architecture détaillés ci-dessous pour le contrôle du flux et de la forme des demandes.

Caractéristiques

Ce paquet fournit six caractéristiques indépendantes - utiliser toute combinaison dont vous avez besoin voir Exemples modulaires pour le protocole-systèmes spéciaux):

1. Mocking de l'API REST

Super Simple: AddLLMockApi() + MapLLMockApi("/api/mock") = API de simulation instantanée
Contrôle de la forme: Préciser la structure exacte de JSON par l'en-têteM SK1 param de demande, ou corps de demande
Tous les méthodes HTTP: Appuie GETM SK1 POST, PUT , DELETEMSC4 PATCH
Routage de cartes sauvages: Tout chemin sous votre point final choisi fonctionne
Soutien complet du type de contenu (NEW dans vM SK1
- JSON (application/json) - Organes de demande standard JSON
- Organes de forme (application/x-www-form-urlencoded) - Présentation de formulaire HTML
- Les téléchargements de fichiers (multipart/form-data) - Les fichiers téléchargés avec extraction de métadonnées
- Memory-Safe: Contenu du fichier transmis et détourné ( seules les métadonnées conservées
Longueurs arbitraires du chemin: La nidification par voie profonde est entièrement appuyée (/api/mock/v1/api/products/electronics/computers/laptops/gaming/...)

2. GraphQL Mocking API

Soutien GraphQL autochtone: POSTE à /api/mock/graphql avec les demandes GraphQL standard
Question-Formes dirigés: La demande GraphQL elle-même définit la structure de réponse
Variables & Opérations: Soutien complet pour les variables, noms d'opérations , et fragments
Traitement d'une erreur appropriée: Retourne les erreurs GraphQL-formatées avec data et errors Les champs

3. ServeurM SK1 Événements envoyés (SSE) Enregistrement

Enregistrement progressif: Soutien SSE avec génération progressive de JSON
Mise à jour en temps réel-: Token de données d'acheminement-parM SK2token vers les clients
Travaux autonomes: Aucune configuration de l'API REST n'est requise
Guide SSE complet | Enregistrement continu

4. SignalR Real-Traitement de temps

WebSocket Streaming: Données de simulation continues réelles-temps via SignalR
Contextes multiples: Effectuer plusieurs flux de données indépendants simultanément
Gestion du cycle de vie: Start/arrêter les contextes dynamiquement avec l'API de gestion
Travaux autonomes: Aucune configuration de l'API REST n'est requise
Guide de démonstration de SignalR

5. OpenAPI Swagger Mock Generation

Production automatique d'un point final: Indiquer à n'importe quel OpenAPIM SK1Swagger spec (URL ou fichier)
Toutes les opérations sont supprimées: Chaque chemin et méthode de spec devient un point final en direct
Tableau de diagramme-Découlement des données: LLM produit des données réalistes correspondant à vos schémas
Échantillons multiples: Charger et monter plusieurs spécifications API simultanément
Travaux autonomes: Aucune configuration de l'API REST n'est requise
Guide des fonctionnalités de l'OpenAPI

6. Motage du service gRPC (NEW dans v1.7.0)

Mise à jour du fichier Proto: charger les fichiers de protocole . pour générer des modèles de service gRPC
Soutien du protocole double: JSON sur HTTP pour l'essaiM SK1 Protobuf binaire pour la production- mocking de niveau
Serialisation dynamique: Encodage de Protobuf en temps d'exécution sans production de code
LLM-Données électriques: Réponses réalistes correspondant aux définitions de votre message proto
Travaux autonomes: Aucune configuration de l'API REST n'est requise
Guide de soutien gRPC

Faits généraux

Configurable: appsettings .json ou configuration en ligne
Données très variables: Chaque demande/update produit des données réalistes complètement différentes
NuGet Package: Facile à ajouter aux projets existants
AutoShape (Memorie de la forme): Remarque automatiquement la structure de JSON à partir de la première réponse , garantissant des schémas cohérents dans toutes les demandes subséquentes jusqu'au même point final Voir Guide d'autoformation
Contextes de l'API: Maintenir la cohérence entre les demandes connexes - Guide complet
Simulation d'une erreur: Essais d'erreur approfondis avec des codes de situation 4xx/5xx, messages personnalisés
Utilités d'essai: Companion package mostlylucid.mockllmapi.Testing pour une intégration facile de HttpClient dans les essais - Voir Section des essais

Non-Objectifs M SK1 Limites

Qu'est-ce que ce soit:

Un outil d'élaboration et de prototype pour la production réaliste de données modèles
Perfectieux pour le développement de frontend, conception API, démonstration de , et essais
Zero-alternative à l'entretien des appareils et de la base de données codés sur support dur

Qu'est-ce que ce n'est pas:

N'est pas une source de données de production - Les données produites sont réalistes mais synthétiques
Pas de remplacement pour les essais contractuels - Utilisez-le pour le développement; valider séparément les API réels
Non pour le trafic de production non validé - L'entrée de l'utilisateur va directement aux prompts LLM (injection rapide possible)
N'est pas une base de données ou un stock persistant - Aucun état n'est maintenu entre les demandes (à l'exception des contextes API facultatifs)
Il ne s'agit pas d'un remplacement de la logique réelle du backend. - Règles d’affaires, validationM SK2 et flux de travail restent simplifiés

Quand l'utiliser:

Élaboration de frontends avant que les backends ne soient prêts
Créer des démonstrations réalistes sans accès aux données de production
Évaluation des composants de l'interface avec divers scénarios de données
Prototyping API designs and experimenting with response shapes
Apprentissage des modèles d'intégration LLM dans .NET

Quand ne pas l'utiliser:

Dans les milieux de production qui servent des utilisateurs réels
Pour tester l'authentification/logice d'authorisation M SK1 schémas de sécurité ignorés)
Lorsque les données doivent se conformer aux règles commerciales strictes ou à la validation
Pour la mise à l'essai de performance réelle du backend
Lorsque des données déterministes, reproductibles sont requises à travers les essais

Documentation sur les caractéristiques

Pour des guides détaillés avec diagrammes d'architecture, cas d'utilisationM SK1 et détails de mise en œuvre:

Guide de déploiement du Docker - Installation et déploiement complets du Docker
- Démarrage rapide avec Docker Compose + Ollama
- Fin-to-exemplaire de fin avec llmM SK2model
- Méthodes de configuration (env varsM SK1 cartographie du volume, . fichiers envMSC4
- Support GPU, multi-configuration du backend
- Considérations de production et résolution des problèmes
Référence à l'API de backend - Documentation complète sur les points finals de gestion
- Points finals de gestion OpenAPI
- Gestion du contexte de l'API
- gRPC gestion proto
- Centres de signalisation R
- Demande complète/exemples de réponse
Guide de backends multiple LLM - Soutien à plusieurs fournisseurs
- Connectez simultanément Ollama, OpenAI, et LM Studio
- Per-request backend selection via headers/query params
- Compatibilité ultérieure complète avec les configurations traditionnelles
- Fournisseur-exemples et pratiques exemplaires spécifiques
Guide des contextes de l'API - NOUVEAUM SK1
- Mémoire partagé à travers les demandes pour des flux de travail uniformes multi-
- E- flux commerciauxM SK1 tickers de stocks , exemples d’état des jeux
- Gestion des tokens et truncation intelligente
- Diagrammes d'architecture Mermaid
Limitation du taux & Guide de mise en charge - NOUVEAU dans vM SK1
- N-completions support pour générer plusieurs variantes de réponse
- Per-Statistiques de pointe suivies avec moyennes en mouvement
- Trois stratégies de mise en lots (Sequential,ParallèleM SK2StreamingMSC3
- Encadrements détaillés sur le calendrier des essais de performance
- Perfect pour tester les stratégies de retrait et les scénarios d'échéance
Outils pluggables & Guide des actions - NOUVEAU dans vM SK1
- MCP-architecture compatible pour l'intégration d'outils élargisables
- Outils HTTP pour appeler des API externes avec authentification
- Mock outils pour créer des arbres de décision et des flux de travail
- Substitution de modèles avec un support pour les variables environnementales
- Chaînement d'outils avec limites de sécurité et cache des résultats
- Phase 1 (ExplicitM SK2 Phase ≥2 (LLMMSC5driven), Phase
Guide de soutien gRPC - NOUVEAU dans vM SK1
- Télécharger les fichiers .proto pour le montage automatique du service gRPC
- Soutien double: JSON sur HTTP et Protobuf binaire
- LLM-génération d'une réponse réaliste
- Détails complets de la mise en œuvre et stratégies d'essai
Guide des fonctionnalités de l'OpenAPI
- chargement dynamique des spécifications provenant de fichiers URL, , ou JSON en ligne
- Production automatique d'un point final avec des paramètres de chemin
- Demande/exemples de réponse avec l'API Petstore
- Intégration de SignalR pour les mises à jour en temps réel
Exemples d'architecture modulaire
- REST-seulementM SK1 GraphQL-seuls , SignalRMSC4seules configurations
- Stratégies d'optimisation de la mémoire
- Mélanger et correspondre les protocoles
Guide de démonstration de SignalR
- Établissement de la diffusion de données en temps réel
- Gestion du cycle de vie dans le contexte
- Exemples de connexion avec un client
Notes de diffusion
- Historique complète de la version
- Débrouillage des changements (pas depuis vM SK1
- Guides de migration
Résumé de l'essai - NOUVEAU dans vM SK1
- Documentation complète sur la couverture des essais
- Essais 228 avec ventilation détaillée
- Mesures de rendement et validation
- Toutes les catégories d'essai expliquées
Résumé de la mise en œuvre - NOUVEAU dans vM SK1
- Form body and file upload implementation details
- Construction manuelle de JSON pour .NET 10
- Memory-architecture de gestion des fichiers sécuritaire
- Modifications complètes du code et justification

Démarrage rapide

Installation

Package principal:

dotnet add package mostlylucid.mockllmapi

Utilités d'essai (Optionnelles):

dotnet add package mostlylucid.mockllmapi.Testing

Offre une API fluide pour la configuration facile de HttpClient dans les essais. Voir Section des essais pour plus de détails.

Démarrage rapide avec le Docker (Recommandé)

La façon la plus rapide de démarrer - pas . Installation NET ou Ollama requise!

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

Ce n’est pas le cas. L'API est en cours à http://localhost:5116 avec Ollama backend.

Voir le Guide Docker complet pour:

Options de configuration (env varsM SK1 cartographie du volume)
Utilisation de différents modèles (gemma3:4bM SK2 mistralMSC3nemoMST4
Soutien GPU
Déploiement de la production
Troubleshooting

Exigences (Développement local)

Si vous n'utilisez pas Docker:

Installer .NET 8.0 SDK ou plus tard
Installer Ollama et retirer un modèle:
```
ollama pull ministral-3:3b
```

Choix d'un modèle LLM

Ce paquet était a été mis au point et testé avec ministral-3:3b (3Paramètres BM SK1 qui fournit des résultats excellents pour toutes les fonctions avec une performance très rapide. CependantMSC3 il fonctionne avec tout modèle OllamaMST4compatibleMSS5

Modèles recommandés

Modèle MSC1 Taille MSC2 Accès SMC3 Qualité SMC4 Contexte ESC5 Le meilleur pour SMC6
Ministre-3:3b (défaultM SK1			3	B	4	V	5	Fast	6	Excellent	7	8	K	9	KILLER pour JSON! Fast, exactM SK2 grand contexte
3:4b gemma	4B S	rapide	bon			5	K		solution de rechange pour les machines inférieures
3	MSC1B MSC2 Moyenne SMC3 Très bonne ESC4		5	K	SMC6	Utilisation générale	MSC7	Production	MSC8
Mistral-nemo	MSC1B SMC2 Moins lentement MSC3 Excellente	≥MSC5K SMC6 Qualité élevée, ensembles de données massifs
Mistral:7b	7B S	Moyenne	Très bonne			5	K			Solutions de rechange à llm	-	modèle
3	MSC1B MSC2 Rapide SMC3 Bonne SMC4		5	6	Élaboration rapide de prototypes	SMC7
de l'eau potable	MSC1B MSC2 Très rapide SMC3 Basique SMC4		5	6	Ressource ultra	SMC7	restreint

RECOMMANDÉ: Qwen M SK1 Coder (3B) - Perfect pour le développementMSC5

Qwen 2.5 Coder est KILLER pour la génération JSON - ultraM SK1 rapide , extrêmement précis, contexte largeMSC4

ollama pull ministral-3:3b

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

Pourquoi ce n’est-ce qu’un excellent travail?

Exceptionnellement rapide sur tout matériel (3-4GB RAM)
Exactitude de génération JSON de la classe Best-in-
256K fenêtre contextuelle ( manipule des structures ensemencées complexes
Formé spécialement pour les données structurées de code/
Perfect pour les pipelines et le développement de CI/CD
Hallucinations minimales par rapport aux modèles généraux

PRODUCTION: MistralM SK1Nemo - La meilleure qualité & Contextes massifs

Pour la production-essais similaires avec des schémas complexes:

ollama pull mistral-nemo

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

Pourquoi ce n’est-ce qu’un excellent travail?

Production de données réalistes de la plus haute qualité
128K fenêtre contextuelle (exige Configuration Ollama)
Le meilleur pour les structures ensemencées complexes et les grands ensembles de données
Variation plus créative des données générées
Remarque: Besoins de ressources supplémentaires

Modèle-Configuration spécifique

Pour le ministre-3:3b M SK1Recommandé - défaut):

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

Pour gemma3:4b ou llama3:

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

Pour le mistral-nemo (HighM SK2production de qualité):

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

Note: Mistral-nemo requiert Configuration du contexte Ollama pour 128K contexts.

Où trouver MaxContextWindow:

# Check model info
ollama show {model-name}

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

Pour les modèles plus petits (phiM SK1 tinyllama):

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

Pourquoi la température est importante:

Modèles plus gros (7BM SK1 peut gérer des températures élevées (1.0-1.5) tout en maintenant un JSON valide
Modèles plus petits (<4BM SK1 Il faut des températures plus basses (0.6-0.8) pour éviter
- Syntaxe JSON invalide (quotes manquantesM SK1 crochets)
- Réponses tronquées avec ellipse ("...")
- Noms de champ ou structures hallucinatoires
Température inférieure = rendement plus prévisible , moins de variété
Température plus élevée = output plus créativeM SK1 plus de variété ( mais plus risqué pour les petits modèles)

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

Limites importantes:

Modèles plus petits (tinyllama, phi3) fonctionne, mais peut fonctionner
- générer des données plus simples/ sans variations
- Lutte contre les questions complexes de GraphQL
- Besoin d'autres tentatives de retry
- Travailler avec des questions simples et de petites tailles de réponse
Tous les modèles peut faire face à:
- Très complexe/questions de GraphQL ensemencées profondément (>5 Niveaux profonds
- Nombre de champs par objet (>10 champsM SK1
- Large array requests - Limite à 2-5 pour les articles de fiabilité
Si vous voyez des erreurs sur le JSON tronqué ("...") ou les commentaires ("//"):
- Température inférieure à 0.8 ou moins
- Simplifier votre demande GraphQL (moins champs, moins nidificationM SK2
- Accroître MaxRetryAttempts à 5 ou plus

Usage de base

Programme.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.jsonM SK1

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

Que'c'est ce qu'il est! Maintenant, toutes les demandes de /api/mock/** Retour des données de modèle intelligente.

AutoShape (Memorie de la forme)

Maintenir automatiquement des structures JSON cohérentes à travers les demandes au même point final.

Ce qu'elle fait

Systèmes de réponse cohérents à travers plusieurs appels
Aucune dérive du schéma pendant le développement
Utilisation prévisible de l'API pour les essais

Exemple rapide

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

Configuration

Activé par défaut dans appsettings.json:

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

Per-Contrôle de demande

Disabler pour une demande spécifique:

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

Renouveler une mauvaise forme:

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

Normalisation du chemin

Tous ces demandes ont la même forme (normalisée à /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

Faits clés

✅ activé par défaut - fonctionne hors de la boîte
🔄 Renouvellement de forme - Fixer les mauvaises formes avec ?renewshape=true
⏱️ Auto-expiration - Les formes expirent après l'inactivité.
🎯 Normalisation intelligente - Identités différentes pour les mêmes formes de partage du point final
🚫 Supprimer explicitement - Fourniture de la forme explicite par l'entremise de la demandeM SK1header/body skips autoshape
✨ Travaille partout - RESTM SK1 Streaming, et GraphQL finpoints

Quand utiliser

Perfect pour:

Développement de frontend nécessitant des structures de données modèles cohérentes
Essais d'intégration nécessitant des schémas prévisibles
Démos où la structure des données ne devrait pas changer entre les demandes
Fabrication de prototypes d'API avec des formes évolutives mais cohérentes

N'est pas nécessaire lorsque:

Utilisation de formes explicites (elles ont la préséance en tout état de cause
Besoin d'une variété maximale dans chaque réponse
Évaluation des scénarios d'évolution du schéma

Troubleshooting

Formes non appliquées?

Vérifier EnableAutoShape: true dans la configuration
Vérifiez qu'il n'y a pas de forme explicite fournie (query/headerM SK2bodyMSC3
Vérifier le temps d'expiration (défault 15 minutesM SK2

Besoin de changer une forme?

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

Supprimer toutes les formes de façon programmatique:

// Inject AutoShapeManager
autoShapeManager.ClearAllShapes();

Pour obtenir la documentation complète,, voir CLAUDE.md AutoShape Section.

Couverture d'essai: 39 essais couvrant toutes les fonctions d'autoformation ✅

Options de configuration

📘 Référence de configuration complète: Voir Guide de référence pour la configuration pour toutes les options 📄 Exemple complète: Voir appsettings.FullM SK1json - démontre tous les option de configuration

Par l'intermédiaire des réglages d'application.json M SK1Recommandé)

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

Modèle- Limites spécifiques des tokens: Voir LLMApi/appsettings.json pour des exemples de configuration pour différents modèles (Llama 3, TinyLlama, MistralMSC3 etcM SK4 Chaque modèle a différentes tailles de fenêtres contextuelles MaxInputTokens par conséquent.

Contextes de l'API: Pour de plus amples renseignements sur l’utilisation des contextes pour maintenir la cohérence entre les demandes, voir le Guide des contextes de l'API.

Politiques de résilience

Nouveaux dans v1.2.0: Élaboré-Les politiques de résilience Polly protègent votre application contre les défaillances du service LLM!

Le paquet comprend deux modèles de résistance activés par défaut:

Réessai de déblocage exponentiel

Récupération automatique des demandes de LLM qui ont échoué avec retards exponentiels (1s,
Inclure le tremblement pour empêcher les problèmes de troupe d'écrasement
Génie les erreurs de connexion, les arrêts de temps , et non-codes d'état de réussite
Défault: M SK1 tentatives avec 1 deuxième retard de base

Réparateur de circuits

Ouverture après des défaillances consécutives pour empêcher la cascade
Reste ouvert pendant une durée configurée avant de permettre les demandes d'essai
Trois états: Fermé M SK1Normal), Ouvert (Rejet ),Half SSK5 Ouverture S(ÉvaluationMSC7
Défault: Ouverture après M SK1 défaillances consécutives, reste ouverte pendant 30 secondes

Configuration:

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

Enregistrement:

Les politiques de résilience enregistrent toutes les tentatives de répétition et les changements d’état du brise-circuit:

[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

Quand ajuster:

Slow LLM? Accroître MaxRetryAttempts ou RetryBaseDelaySeconds
Récupération agressive? Réduire CircuitBreakerDurationSeconds
Nombre d'erreurs transitoires? Accroître CircuitBreakerFailureThreshold
Disabler les essais locaux? Établir les deux EnableRetryPolicy et EnableCircuitBreaker à false

Par le biais du code

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

Paramètres de point final personnalisés

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

Exemples d'utilisation

Demande de base

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

Retourne les données réalistes de l'utilisateur générées par le LLM.

Formulaire des demandes de corps (NEW dans vM SK1

Présentation du formulaire HTML:

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"

Les données du formulaire sont automatiquement converties en JSON et transmises au LLM pour la génération de réponses réalistes.

Formulaire avec plusieurs valeurs:

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"

Plusieurs valeurs pour le même nom de champ sont converties en tableaux automatiquement.

Demandes de téléchargement des fichiers (NEW dans v2.3.0)

Upload de fichier unique:

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

Plusieurs fichiers avec des données du formulaire:

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

Comment fonctionnent les téléchargements de fichiers:

Le contenu du fichier est transmis par un tampon 8KB et rejeté (non stocké en mémoire)
Seuls les métadonnées sont conservés: nom du fichier , type de contenuM SK2 taille, lecture des bytes
LLM reçoit des métadonnées de fichier et génère une réponse appropriée
Memory-safe for large files (tested with 100MBM SK3

Réponse par exemple:

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

Ensemencement de voies profondes (NEW dans v2.3.0)

Voies Nested complexes:

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

Le LLM intègre tous les segments de cheminement et les paramètres de demande dans la génération réaliste des réponses. Aucune limite pratique sur la profondeur du cheminementM SK1

Contexte API (NEW dans v1.5.0)

Utiliser des contextes pour maintenir la cohérence entre plusieurs demandes connexes:

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

Chaque demande dans le même contexte affiche les demandes antérieures, assurant des ID cohérentsM SK1 noms , et relations de données. parfaite pour les flux de travail à plusieurs étapes Guide des contextes de l'API pour des exemples complets.

Avec le contrôle de la forme

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 génère des données correspondant à votre spécification exacte de forme.

Enregistrement (SSE - ServeurM SK2 Événements envoyés)

SSE streaming fait partie de l'API REST - il est seulement possible d'en ouvrir lors de la cartographie des points finals:

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

Usage:

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

Retourne le serveur-Les événements envoyés en tant que JSON sont générés par un token

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

Exemple de 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);
    }
};

Avec contrôle de forme:

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

Le point final d'écoulement appuie toutes les mêmes fonctionnalités que les points terminaux réguliers:

Contrôle de la forme (param de demandeM SK1en-tête , ou corps)
Soutien du schéma JSON
Demandes de renseignements personnalisés
Tous les méthodologies HTTP (GET, POST , PUTM SK3 DELETEMSC4 PATCHMST5

GraphQL API Mocking

Nouveaux dans v1.2.0: Soutien GraphQL natif avec la demande-génération de données mock dirigées!

Démarrage rapide avec GraphQL

Le point final GraphQL est automatiquement disponible lorsque vous cartographiez l’API LLMock:

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

Ceci crée un point final GraphQL à /api/mock/graphql.

Usage de base

Question simple:

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

Réponse:

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

Avec des variables

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

Demandes en positionnement

GraphQL's puissance brille avec les données ensemencées:

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

Le LLM génère des données réalistes correspondant à votre structure exacte de demande - y compris toutes les relations entamées.

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

Erreur de manutention

Les erreurs GraphQL sont retournées dans le format standard:

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

Comment cela fonctionne

Tracer la demande: Extraire la demande de GraphQL, variablesM SK2 et nom d'opération
Établissement rapide: Envoyer la structure de demande au LLM avec des instructions pour produire les données correspondantes
Générer les données: LLM crée des données réalistes qui correspondent exactement aux champs de demande
Réponse à l'enveloppe: Retourne les données dans le format GraphQL { "data": {...} }

Avantages clés

Aucune spécification de forme n'est requise: La demande GraphQL définit la structure
Type Sécurité: Demande explicitement des champs de demande par nom
Relations nichées: Soutien naturel pour les structures de données nested complexes
Format normalisé: Travaille avec toute bibliothèque de clients GraphQL
Données réalistes: LLM produit des données contextuellement appropriées pour chaque champ

Évaluation de GraphQL

Utiliser l'inclusion LLMApi.http fichier qui contient 5 prêtM SK1à-utiliser des exemples de GraphQL :

Demande simple de l'utilisateur
Demande avec des variables
Champs nichés avec des tableaux
E-catalogue de produits du commerce
Données organisationnelles complexes

Voir le Exemples de GraphQL dans LLMApi.http pour des exemples de travail complets.

Configuration de GraphQL

Limites des symboles et sélection du modèle

Les réponses de GraphQL peuvent devenir importantes avec des questions profondément nichées. Pour empêcher les erreurs de truncation JSON, configurez la GraphQLMaxTokens option:

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

Lignes directrices sur les limites des symboles:

Modèle
Modèle	300-500 ≥	Le meilleur équilibre de la vitesse et de la complexité
Mistral:7b	300-500 ≥	Génie bien les structures ensemencées.
3	200-300 ≥	Gardez les demandes simples
de l'eau potable	150-200 ≥	Utiliser uniquement les demandes de renseignements superficiels

Pourquoi un niveau inférieur est meilleur:

La priorité est donnée à la demande. correction par rapport à la longueur
Les limites inférieures obligent le LLM à générer un JSON plus simple, complet
Limites plus élevées risquent de réduire les réponses (invalid JSONM SK1
Si vous voyez les erreurs "Invalid JSON from LLM Réduire les GraphQLMaxTokens

Pour les demandes complexes Nested:

Utilisez des modèles plus grands (llmM SK1model, mistral :7bMSC4
Augmenter GraphQLMaxTokens à 500-1000
Garder les tailles des tableaux petites (2 items max par défaut)
Surveiller les registres pour les avertissements de truncation

Exemple de configuration pour les demandes complexes:

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

SignalR Real-Traitement de données en temps réel

L'API LLMock comprend un support SignalR facultatif pour la production de données continues , réelles - d'un modèle de temps

Prototypes de tableaux appelant des mises à jour en direct
Évaluation des composants de l'interface real-time
Démos avec des données en constante évolution
Test d'intégration WebSocket/SignalR

Démarrage rapide avec SignalR

SignalR fonctionne indépendamment - vous n'avez pas besoin de l'interface REST API pour utiliser le flux signalR.

1. Signal minimalRM SK1Système de configuration seulement:

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

Optionnel: Ajouter REST API aussi

Si vous voulez aussi les points de fin REST API, ajouter ces lignes:

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

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

2. Configurer dans les paramètres d'applicationM SK1json:

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

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

3. Connexion à partir du client

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

Configuration du contexte de l'Hub

Chaque contexte de hub simule une demande API complète et génère des données continuellement:

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

Recommended: Utiliser des descriptions en anglais simples

Laissez le LLM générer automatiquement des structures JSON appropriées:

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

Le LLM génère automatiquement un schéma JSON approprié de votre description.

API de création du contexte dynamique

Créer et gérer les contextes de SignalR au moment du démarrage en utilisant l’API de gestion:

Créer un contexte

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

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

Réponse:

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

Liste de tous les contextes

GET /api/mock/contexts

Réponse:

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

Obtenir un contexte spécifique

GET /api/mock/contexts/weather

Réponse:

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

Supprimer le contexte

DELETE /api/mock/contexts/crypto

Réponse:

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

Démarrer le contexte (Resumer la génération de données)

POST /api/mock/contexts/crypto/start

Réponse:

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

Commence à produire des données pour un contexte interrompu sans affecter les clients connectés.

Stop Contexte (Pause Data Generation)

POST /api/mock/contexts/crypto/stop

Réponse:

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

Cesse de produire de nouvelles données mais garde le contexte enregistré. Les clients demeurent connectés mais ne reçoivent aucune mise à jour jusqu’à ce qu’ils soient relancés.

Exemple de client complet

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

Création du contexte dynamique à partir de l'interface

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!");
}

Méthodes d'appui de SignalR

L'article 5 de la Loi sur l'immigration et le statut des réfugiés MockLlmHub appuie les méthodes suivantes:

SubscribeToContext(contexte de chaînes)

Inscrire le client pour recevoir des mises à jour de données pour un contexte particulier
Le client recevra DataUpdate événements avec des données générées
Nouveaux dans v1.1.0: Augmente automatiquement le nombre de connexions du contexte'

Désubscrire à partir du contexte(contexte de chaînes)

Désubscrire le client à partir d'un contexte
Le client ne recevra plus de mises à jour pour ce contexte.
Nouveaux dans v1.1.0: Réduira automatiquement le nombre de connexions du contexte'

Événements reçus par le client:

Mise à jour des données - Contient des données de modèle générées

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

Adhésion - Confirmation de l'abonnement

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

Non appuyé - Confirmation de non-abonnement

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

Options de configuration

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

Soutien du schéma JSON

Les contextes de l’hub appuient à la fois les formes simples JSON et le schéma complet JSON:

Forme simple:

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

Système JSON:

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

Le système auto- détecte le schéma JSON en cherchant $schema, type, ou properties champs.

Architecture

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

Components:

MockLlmHub: Le hub SignalR traite des connexions et des abonnements clients
MockDataBackgroundService: Service hébergé produisant continuellement des données
DynamicHubContextManager: Thread- gestionnaire sécuritaire pour l'enregistrement du contexte de temps d'exécution
Configuration du contexte Hub: Modèle de configuration pour chaque contexte de données

Utiliser les cas

1. Prototypage du tableau de bord

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

2. Simulation de l'IoT

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

3. Données financières

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

4. Tableau de bord des jeux

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

Contexte Gestion du cycle de vie

Nouveaux dans v1.1.0: Contrôle complet du cycle de vie sur les contextes SignalR avec le suivi réel-de l'état d'avancement du temps!

Chaque contexte a les propriétés suivantes:

Il est actif: Si le contexte génère des données
Nombre de connexions: Nombre de clients actuellement connectés (autoM SK2tracked)

Contextes peuvent être dans deux états:

Activité: Le service d’information produit chaque fois de nouvelles données SignalRPushIntervalMs (défaultM SK1 5 secondes)
Arrêtée: Contexte demeure enregistréM SK1 clients restent connectés, mais aucune nouvelle donnée n'est générée

Faits clés:

Démarrer/arrêter les contextes sans déconnecter des clients
Surveillance du nombre réel de connexions
Insignes de situation montrant l'état actif/État arrêté
Prévention du contexte
Contextes des appsettings.json apparaissent automatiquement dans l'interface

Cache de réponse pour SignalR: Nouveaux dans v1.1.0: Le caching intelligent réduit la charge de LLM et améliore la cohérence!

Préalimentation en lots: Génie simultanément des réponses 5-10 (configurables via MaxCachePerKey)
Per-Context Queues: Chaque contexte maintient son propre cache des réponses générées avant -
Renouvellement du contexte: Remplit automatiquement le cache lorsqu'il tombe sous la capacité 50%
Calendrier intelligent: Réduise les appels LLM tout en maintenant la fraîcheur des données

Cela réduit considérablement la charge de LLM pour les contextes à fréquence élevée- , particulièrement avec plusieurs clients.

Exemple de travail:

# 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 / Production de boucles d'évacuateur

Nouvelle fonctionnalité: Gérer automatiquement des paramètres de clôture à partir d'OpenAPI/Swagger spécifications! Pointer sur n'importe quel OpenAPI M SK2SWAgger 2.0 spec (URL ou fichierMSC5 et la bibliothèque créera des parameters de cloison pour toutes les opérations définies

Démarrage rapide avec OpenAPI

dotnet add package mostlylucid.mockllmapi

Programme.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.jsonM SK1

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

Que's it! Tous les points de fin provenant de votre spécification OpenAPI sont maintenant disponibles en tant que modèles intelligents LLM

Comment cela fonctionne

Établissement de spécifications: Charge les spécifications OpenAPI à partir d'URLs ou de fichiers locaux (JSON ou YAML)
Conversion du schéma: Convert les schémas OpenAPI à des modèles de forme JSON
La cartographie des points finals: Carte automatiquement toutes les opérations aux points de départ ASP.NET Core
Production de LLM: Utilise LLM pour produire des données de modèle réalistes correspondant au schéma
Paramètres du chemin: Génie les paramètres du chemin comme /users/{id} Automatiquement

Options de configuration

Chaque spécification OpenAPI appuie ces options de configuration:

Propriété	Type MSC2 Description SMC3
`Name`	chaîne	Identificateur unique pour cette spécification
`Source`	chaîne	URL ou chemin de fichier à OpenAPI spécification
`BasePath`	chaîne	Insérer le chemin de base ≥(defaultM SK3 utilise les spécifications's `servers[0].url`)
`EnableStreaming`	bool	Ajouter `/stream` suffix pour SSE streaming (default:fausseM SK2
`IncludeTags`	chaîne[]	générer uniquement les points de fin avec ces balises.
`ExcludeTags`	chaîne[]	Passer les points finals avec ces balises
`IncludePaths`	chaîne[]	Seulement générer ces chemins. `/users/*`)
`ExcludePaths`	chaîne[]

Exemples de configuration avancées

Filtrer par tags:

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

Filtrer par chemins:

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

Enable streaming:

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

Évaluation des Mocks OpenAPI

Configuration des spécifications OpenAPI:

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

Et une spécification définissant GET /pet/{petId} qui retourne un Pet object, vous pouvez tester

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

Utilisation modulaire

Les modèles OpenAPI fonctionnent indépendamment de REST/GraphQLM SK1SignalR:

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

Formats spéciaux supportés

OpenAPI 3.0 (JSON ou YAMLM SK1
OpenAPI 3.1 (JSON ou YAMLM SK1
Swagger 2.0 (JSON ou YAMLM SK1

Faits clés

Production automatique d'un point final: Tous les chemins et toutes les opérations de spec deviendront des points d'exécution modèles
Schema-Driven: Formes de réponse dérivées des schémas de réponse OpenAPI
Paramètres du chemin: Dispositifs /users/{id}, /posts/{postId}/comments/{commentId}, etcM SK1
Échantillons multiples: Charger et monter plusieurs spécifications API simultanément
Filtration intelligente: Inclure/exclure les opérations par balises ou chemins
Soutien à la diffusion: Transmission optionnelle d'SSE pour n'importe quel point final
LLM-Powered: Génie des données réalistes , variées appropriées pour chaque schéma

Utiliser les cas

API- Premier développement: Commencez à coder contre la spécification avant que le backend ne soit prêt
Frontend Prototyping: Élaborer l’UI pendant que l’API est construit
Évaluation de l'intégration: Tester le code client sans dépendance API réelle
Environnements de démonstration: Présentation d’applications sans accès à l’API de production
Examen des contrats: Vérifier que les clients manipulent correctement toutes les variations du schéma
Essais de chargement: Gérer des données d'essai réalistes à l'échelle

Limitations

À l'heure actuelle, seuls les schémas de réponse sont supportés (la validation de la demande n'est pas exécutée)
Les schémas de sécurité sont ignorés (pas d'authentification requise)
Seule l'application/json type de contenu est supporté pour les réponses
Les valeurs des paramètres du chemin ne sont pas validées contre les contraintes du schéma

Évaluation de la gestion OpenAPI

L'inclusion management.http le fichier contient des exemples exhaustifs pour tous les points de gestion:

Gestion des spécifications:

Charger des spécifications à partir d'un URL (Petstore, API de GitHub , etcM SK3
Charger des spécifications de fichier local
Charger des spécifications de JSON raw/YAML
Liste de toutes les spécifications chargées
Obtenir des détails spéciaux avec les points finals
Recharger la spécification (refresh de source)
Supprimer les spécifications

Évaluation du point final:

Vérifier les points de fin GET avec des paramètres du chemin
Évaluer les points de fin POST/PUT/DELETE
Évaluer les points finals avec des paramètres de la demande
Vérifier plusieurs points de fin dans une séquence

Processus de travail avancés:

Charger plusieurs spécifications simultanément
Comparaison des modèles OpenAPI avec les modèles réguliers
Opérations par lots
Erreur de traitement des exemples

Exemple de la gestion.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"
}

Voir le document complet gestion.http fichier pour 20+ prêtM SK1à-utiliser des exemplesMSC3

Applications de démonstration

Le paquet comprend des applications de démonstration complètes avec interfaces interactives comportant une gestion complète du contexte:

Client de bureau Windows (`LLMockApiClient/`) — Application du WPF (En développement)

⚠️ ÉTAT DU DÉVELOPPEMENT: Le client de bureau Windows est actuellement en cours d’élaboration active . Bien que plusieurs fonctionnalités soient fonctionnelles M SK2 certaines fonctions peuvent être incomplètes ou susceptibles de changer . Utilisation à des fins d’essai et de développement

Une application de bureau WPF complète pour interagir avec l'API LLMock:

Caractéristiques:

Tableau de bord: RealM SK1État de la connexion et surveillance du système
SignalR Real-Time: Créer des contextes et abonner aux flux de données en direct
SSE Streaming: Trois modes d'acheminement (tokens, objetsM SK3 éléments de tableauxMSC4
Gestionnaire OpenAPI: Charger les spécifications des points d’essai URL/JSONM SK2
Services gRPC: Soumettre à jour . fichiers de protocole, méthodes d'essai gRPC
Jouer avec les API: Terrain de test HTTP interactif
Multi-Support du backend: Configurer et passer entre plusieurs backends
Surveillance du trafic: Demande HTTP en direct/logage des réponses
Dark/Thème clair: Toggler entre les thèmes avec des transitions linéaires

Documentation: LLMockApiClient README

Perfect pour: Processus de travail d'essai de bureaux, exploration visuelle des API, développement et débugging

Démos basés sur le Web-

SignalR Demo (`/`) — Real- Streaming de données temporelles avec l'interface de gestion

Nouveaux dans v1.1.0: Établissement amélioré de la colonne 3- avec gestion du cycle de vie du contexte complet!

Caractéristiques:

Créer un panneau de contexte: Inscrire des descriptions en anglais simples, le système produit un schéma JSON approprié
Panel de contextes actifs:
- Liste en direct de tous les contextes avec des badges d'état (ActiveM SK1Stopped)
- affiche automatiquement les contextes des appsettings.json au démarrage
- Cote de connexion réelle- pour chaque contexte
- Per-contexte de commandes:ConnexionM SK2Disconnection ,StartMST4StopMSC5Délete
- Auto-refresh sur les changements
Panel de données en direct: RéelM SK1 mises à jour en temps réel des contextes abonnés (toutes MSC3 secondesMSc4
- Éclaircissement de la syntaxe JSON: Pièce noireM SK1Display thématique avec couleur-éléments codés
- Mots clés (rougeM SK1stringes (vert),numéraires MSC4orangeMSC5booleans MSC6cyanMNK7nuel S(purpleMRK9
- Nettoyage, format lisible avec une affiche de temps appropriée
- Aucune dépendance extérieure.

Quick-Exemples de démarrage: Un -cliquez sur les boutons pour 5 pré-- scénarios configurés:

Sensors IoT: Capteurs de température avec ID d'appareilM SK1 Données de mesure, pourcentage de batterie
Marché des actions: réel - prix à temps avec ticker, prixM SK3 pourcentage de variationMSC4 volume
E-ordonnances de commerce: Obtenir des commandes avec l'IDMSC1 client, tableau d'articlesM SK3 état de la demandeMST4 total
Métrique du serveur: Surveillance des données avec le nom de l'hôte , CPU, mémoireM SK3 disqueMSC4 connexions
Tableau de classement des jeux: Statistiques relatives aux joueurs avec le nomM SK1 cote , rangMSC3 niveau, pays

Perfect pour: Tableaux d'affichage, surveillance en direct , simulations de l'IoT, réelsM SK3 feeds temps+, prototypage

SSE Streaming Demo (`/Streaming`) — Production progressive de JSON

Nouveaux dans v1.1.0: Quick-marrage des boutons d'exemple pour la diffusion instantanée!

Caractéristiques:

Configurer la méthode HTTP, le chemin, et la forme JSON facultative
Voir le JSON généré en token-parM SK1token en temps réel-
Statistiques en direct: Nombre de blocs de donnéesM SK1 Durée de l’enquête, Taille des données
Indicateurs de l'état de la connexion

Quick-Exemples de démarrage: Un-cliquez sur les boutons pour 4 scénarios de télédiffusion:

Liste des utilisateurs: Array of user objects with ID, nameM SK2 email
Catalogue des produits: Inventaire de produits avec SKU, nomM SK2 prixMSC3 état des stocks
Détails de commande: Commandes ensérées avec des renseignements sur les clients et un tableau d'articles
Données météorologiques: Conditions actuelles avec température, humiditéM SK2 vitesse de vent

Perfect pour: Observer la génération de LLM, les formes de débugging , comprendre le comportement d'acheminement des données, tester l'SSE

OpenAPI Manager Demo (`/OpenApi`) — Charge de spécifications dynamiques & Essai

Nouvelle fonctionnalité: Gestion interactive des spécifications OpenAPI avec mises à jour réelles

Caractéristiques:

Charger des spécifications dynamiquement: De l'URL ou imposer JSON brute /YAML directement dans le navigateur
Mise à jour du temps réel-: SignalR-avertissements en direct pour toutes les actions
La découverte d'un point final: Extraction automatique de toutes les opérations de spec
In-Examen du navigateur: Vérifier tout point final avec un seul clic , voir LLM-données de modèle produites
Gestion du cycle de vie: ChargerM SK1 recharger , supprimer les spécifications sans redémarrer le serveur
Une interface très belle: Color-méthodes HTTP codéesMSC2syntaxeM SK3réponses JSON hautement éclairées
État de la connexion: Indicateur en direct montre l'état de la connexion SignalR
Aide globale: Documentation en ligne et URLs d'exemple

Quick-Exemples de démarrage:

Charger l'API Petstore à partir de URL
Insérer le JSON OpenAPI personnalisé
Voir tous les points de fin à partir du spec
Tester les points finals directement sur la page
Voir les données de simulation réalistes produites par LLM

Perfect pour: Élaboration de prototypes d'API, développement de frontendsM SK1 essais contractuels , validation des spécifications, démonstrations

Effectuer les démonstrations:

cd LLMApi
dotnet run

Naviger à:

http://localhost:5116 - SignalR réel-transmission de données en temps avec l'interface de gestion
http://localhost:5116/Streaming - SSE génération progressive
http://localhost:5116/OpenApi - Gestionnaire de spécifications OpenAPI avec charge dynamique

Toutes les démonstrations comprennent:

Documentation en ligne complète
Exemples de démarrage rapides interactifs-
Pièces de code pour l'intégration
Indicateurs de temps réels
Contrôles du cycle de vie en contexte complet

Caractéristiques avancées

Écho du schéma de réponse (ShapeM SK1 Exportation

Vous pouvez optionnellement avoir l'écho du logiciel de middleware en retour à la forme JSON/schema qui a été utilisée pour générer la réponse prototype.

Configuration:

Option: IncludeShapeInResponse (boolM SK2 fausse par défaut)
Per-request override: add query parameter includeSchemaMSC2true M SK3or 1)
Header émis: XM SK1Response -Schema (seulement lorsqu'une forme et une taille ont été fournies M SK4 4000 charsMSC6
Streaming: l'événement final SSE comprend un champ de schéma lorsque activé

Exemples:

Activer à l'échelle mondiale (appsettings.jsonM SK2

{
  "mostlylucid.mockllmapi": {
    "IncludeShapeInResponse": true
  }
}

Activer par requête (passe les commandes de configuration):

curl "http://localhost:5000/api/mock/users?shape=%7B%22id%22%3A0%2C%22name%22%3A%22string%22%7D&includeSchema=true"

Réponse inclut le titre:

X-Response-Schema: {"id":0,"name":"string"}

Streaming: événement final contient un champ de schéma lorsqu'il est activé

...
data: {"content":"{full json}","done":true,"schema":{"id":0,"name":"string"}}

Notes:

Si aucune forme n'a été fournie (par l'entremise de la demandeM SK1entête /corps),, le titre n'est pas ajouté
Les formes très grandes (> 4000 charsM SK2 ne sont pas ajoutées à l'en-tête pour éviter les problèmes de transport, mais la réponse normale se poursuit

Cases à utiliser:

Client-génération de type TypeScript côté
Documentation API et validation du schéma
Débugging de l'analyse des formes
Validation du temps d'exécution

Télécharger les fichiers

Supprimer les prompts par défaut avec votre propre :

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

Placeurs disponibles:

{method} - Méthode HTTP
{path} - Voie de demande complète avec chaîne de recherche
{body} - Organe de demande
{randomSeed} - Semences aléatoires générées
{timestamp} - Timbre Unix
{shape} - spécification de forme s’il est fourniM SK2

Simulation d'une erreur

Testez le traitement des erreurs de votre client' avec des capacités complètes de simulation d'erreurs.

Quatre façons de configurer les erreurs ( dans l’ordre de prioritéM SK1

Paramètres de la demande (priorité la plus élevéeM SK1

INTÉRÊT: Les valeurs des paramètres de la demande doivent être URL -encodée. Les espaces deviendront %20, & devient %26, : devient %3A, etcM SK1

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

# More complex example with special characters
# Decoded: "Invalid input: email & phone required"
curl "http://localhost:5000/api/mock/users?error=400&errorMessage=Invalid%20input%3A%20email%20%26%20phone%20required"

Les en-têtes HTTP:

curl -H "X-Error-Code: 401" \
     -H "X-Error-Message: Unauthorized" \
     -H "X-Error-Details: Token expired" \
     http://localhost:5000/api/mock/users

Forme JSON (utilisation $error propriété):

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

Organe de demande (utilisation error propriété):

curl -X POST http://localhost:5000/api/mock/users \
  -H "Content-Type: application/json" \
  -d '{
    "error": {
      "code": 409,
      "message": "Conflict",
      "details": "User already exists"
    }
  }'

Formats de réponse aux erreurs:

Règlement/Contrôle de l’écoulement finalM SK1

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

GraphQL point final:

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

Simulation de l'erreur SignalR:

Configurer les erreurs dans les contextes de SignalR pour l'essai réel-manifestation des erreurs temporelles:

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

Ou dynamiquement via l’API de gestion:

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

Codes de statut HTTP supportés:

Le paquet comprend des messages par défaut pour les codes d'état HTTP communs:

4xx Erreurs de client: 400 ≥(Requête défectueuse), ≤401 ±(Une demande non autoriséeM SK6 403 =(Prohibée~), ─404 (N'a pas été trouvée~
5xx Erreurs sur le serveur: 500 (Erreur de serveur interne), ♫501 |(Non mis en œuvreM SK6 ─502 (Gateway mal entretenueMSC9 ◦503 ‒(Service inapproprié~), −504 ¬(Excès d'accès à la passerelle~)

Messages personnalisés et détails supprimer les défauts.

Utiliser les cases:

Essai de la logique du retry du client et arrêt exponentiel
Valider l'affichage du message d'erreur dans la UI
Authentication d'essai/Flois d'autorisation
Simulation des scénarios de limitation du taux
Pratiquer des modèles de dégradation gracieux
Essai d'enregistrement et de surveillance des erreurs

Voir LLMApi/LLMApi.http pour des exemples exhaustifs de toutes les méthodes de simulation d'erreur.

Instances multiples

Monter plusieurs APIs de modèle avec différentes configurations:

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

Spécification de la forme

Trois façons de contrôler la structure de réponse:

Intitulé (recommandéM SK1 X-Response-Shape: {"field":"type"}
Param de la demande: ?shape=%7B%22field%22%3A%22type%22%7D (URLM SK1JSON encoded)
Champ du corps: {"shape": {...}, "actualData": ...}

Cacher plusieurs réponses par l'entremise de la forme

Vous pouvez instructer le logiciel intermédiaire à prégénérer et cacher plusieurs variantes de réponse pour une demande spécifique.

La clé de cache est dérivée de la méthode HTTP + chemin (y compris la demande) + la forme sanitisée (avec S$le cache a été suppriméM SK6en utilisant le SystèmeMNK7IOMRK8Hashing XXHashMSC9
Jusqu’à N des réponses sont préfetchées du LLM et stockées dans -memory (capped par MaxCachePerKey en options; par défaut 5).
Les demandes d’acheminement non ultérieures pour la même clé sont fournies à partir d’une liste en déclin; lorsqu’elles sont épuisées, un nouveau lot de N est préfetché automatiquementM SK3
Les terminaux de flux ne sont pas cachés.

Exemples

Forme de l'en-tête: X-RéponseM SK1Shape: {"$cache+":3,"orderId=":"+string+","+status+MSC7+string&","+items+M SK9+[{"skuM SK1string ","qty":0}]}
Forme du corps: { "formeM SK1 { "$cacheM SK1 5, "invoiceId": "stringM SK3 "customerM SK1 { ≥"id": ≤"stringMSC6 "name=": "string+" "itemsM SK1 [ { "skuM SK2 ≥"string", ≤"qtyMSC6 \ \ 0, | | "price "total } }
Param de la question (URL-encodéM SK2 ?formeMSC1BM SK2cache%22%3AMST4CMSS5useursMSP6A+MST7B+MSS8B=MST9idMSV10A&MST11C&MSS12nomMSSK13A*MST14stringMSR15D&MSR16D &MSR17D

Configuration

MaxCachePerKey (intM SK1 par défaut 5): couvre le nombre demandé par "$cache" par cléMSC5

Notes

L’indication "$cache" est retirée de la forme avant d’être envoyée au LLM
Si "$cacheM SK1 est omitée ou 0,, la demande se comporte comme avant CSK3pas de cacheMSC4warmup).
Les variantes cachées sont conservées dans la mémoire de l’application.

Évaluation

Trousse d'outils d'essai (NEW!)

mostlylucid.mockllmapiM SK1Testing - Un paquet NuGet conjoint qui rend encore plus facile le test avec l'API de modèle.

dotnet add package mostlylucid.mockllmapi.Testing

Exemple rapide:

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

Faits clés:

API fluide: Configuration facile avec WithShape(), WithError(), WithCache(), etcM SK1
Intégration des clients Http: Travaille sans fil avec HttpClient et IHttpClientFactory
Plusieurs points de fin: Configurer différents comportements pour différentes voies
Simulation d'une erreur: Traitement des erreurs d'essai avec divers codes de situation
Soutien à la diffusion: Points de fin d'écoulement des essais SSE
Injection de dépendance: Built-in support for typed and named clients

Exemples de configuration:

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

Comment il fonctionne: L'article 5 de la Loi sur l'immigration et le statut des réfugiés MockLlmHttpHandler est un DelegatingHandler qui intercepte les demandes HTTP et applique automatiquement votre configuration par le biais de paramètres de recherche et d’entêtes avant de transmettre à l’API mock. Cela signifie que vous pouvez utiliser HttpClient instances dans vos tests tout en contrôlant le comportement de modèle de façon déclarative.

Voir le Évaluation du paquet README pour une documentation complète et des exemples.

Examen des fichiers HTTP

Utiliser l'inclusion LLMApi.http fichier avec:

Visual Studio / Client HTTP Rider
VS Code REST Extension de client
Tout client HTTP

Essais d'unité

Le projet comprend des essais unitaires complets:

# Run all tests
dotnet test

# Run with detailed output
dotnet test --verbosity detailed

Catégorie d'essai (228 tests, 100% taux de passageM SK3

Lecture du corps ( vides , Contenu de JSONM SK2 corps de formulaires, téléchargements des fichiers )
Partage du corps de forme (valeurs uniquesM SK1valences multiples , caractères spéciaux)
Données sur les formulaires multipartites (métadonnées de fichiers , champs et fichiers mixtes)
Évacuation de JSON (quotesMSC1backslashes,newlinesM SK3 tabs , unicode
Extraction de contenu (Format OpenAIM SK1JSON ensemencée complexe ,manifestation des erreurs)
Construction manuelle de JSON (données de formeM SK1arrées,structures ensemencées )
Extraction de formes (param de la demandeM SK1en-tête , champ du corps, préséanceMSC4
Production rapide (randomitéM SK1inclusion de la forme ,modes d'écoulement)
Bâtiment de demande (températureM SK1modèle
Cases à bord (JSON invalidM SK1données manquantes , caractères spéciaux)
Essais d'intégration (flow de travail HTTP complet, présentations de formulairesM SK2 téléchargements de fichiers , voies profondes )

Nouveaux dans v2.3.0:

FormBodyHandlingTests.cs - 12 essais pour le partage des corps de forme et la construction JSON
JsonHandlingTests.cs - 25 essais pour l'évacuation de JSONM SK2 extraction, et cases à bord
Tests d'intégration.cs - Cadre d'essai d'intégration pour l'analyse complète des points finals HTTP

Voir TEST_SUMMARYM SK1md pour la documentation complète des essais et les mesures de couverture.

Architecture

Voir Aperçu de l'architecture ci-dessus pour le diagramme de système et la description des composants à haut niveau-

Flux de demande détaillé

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

Flow de contrôle des formes

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

Projets:

mostlylucid.mockllmapi: NuGet package library
LLMApi: Application de démonstration
LLMApi.Tests: suite d'essai xUnit (228 essais

Pourquoi utiliser le plus souventlucid.mockllmapi?

Prototypage rapide: Développement de frontend sans attendre le backend
Soutien HTTP complet: JSONM SK1 organes de formulaires, téléchargements des fichiers - tous les types de contenu couverts
Flux de travail cohérentsLes contextes API de : maintiennent des relations réalistes à travers les processus multi-procédures -
Démos: Montrer des flux de données réalistes sans fixtures codées
Évaluation: Gérer des données d'essai variées pour les cas de bord - ou des données cohérentes avec les contextes
Memory-Safe: Les téléchargements des fichiers sont en train de se faire et d’être dédoupés.
Conception de l'API: Expérimenter les formes de réponse avant la mise en œuvre
Apprentissage: Exemple d'intégration du LLM dans les API minimales de .NET
Entretien zéro: Aucune base de donnéesM SK1 aucun état, aucun fichier d'information à entretenir
Flexible: Utiliser toute combinaison des spécifications RESTM SK1 GraphQL, SSE , SignalRMSC4 ou OpenAPI
Production-Ready: 228 essais, ≥100% taux de passageM SK4 documentation détaillée

Établissement du paquet NuGet

cd mostlylucid.mockllmapi
dotnet pack -c Release

Le paquet sera en bin/Release/mostlylucid.mockllmapi.{version}.nupkg

Contribuer

Il s’agit d’un projet-échantillon qui démontre l’utilisation de LLM-APIs mock à moteur.Assez libre de forcer et de personnaliser

Licence

Il s’agit d’un logiciel gratuit et sans entrave publié dans le domaine public. Voir LICENCE pour plus de détails ou visite sans licence.org.