# LLMApi: Notes de diffusion

<!--category-- AI, LLM, LLMAPi, ASP.NET Core, API, Nuget, mockllmapi-->
<datetime class="hidden">2025-11-02T12:30</datetime>

> NOTE: Il s'agit des notes de diffusion en direct de gitHub.

# Intorduction

Just the release notes from this nuget package. This is 'liveM SK2 from GitHub so will update frequently.

[TOC]

# Notes de diffusion

## v2.3.0 - Soutien du type de contenu complet

**Remise en liberté**: Décembre
**Concentration**: Soutien complet du type de contenu HTTP - formulairesM SK2 téléchargement des fichiers , voies profondes

Cette version ajoute un support complet pour tous les types de contenu HTTP communs, rendant l'API-ébauche compatible avec les formulaires HTML, téléchargements de fichiers , et des chemins ensemblés complexesSSK3 Toutes les fonctionnalités utilisent la construction manuelle JSON pour M SK4NET 10 compatibilité

### Principales caractéristiques

#### 1. Forme de soutien du corps `application/x-www-form-urlencoded`) 🔥

**Le problème est résolu**: Aucun soutien pour les présentations de formulaire HTML - un type de contenu HTTP fondamental.

**Solution**: Conversion automatique des données du formulaire à JSON avec un évacuation approprié

**Exemple d'utilisation**:

```bash
curl -X POST http://localhost:5116/api/mock/users/register \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "username=john_doe&email=john@example.com&age=30"
```

**Caractéristiques**:

- Valeurs simples et multiples (arrays)
- Évacuation de caractères spéciaux (quotesM SK1backslashes,newlinesMSC3tabs )
- Support de Unicode et d'emojis
- Construction manuelle de JSON (sans réflexionM SK1
- Traitement des valeurs vides

**Valeurs multiples**:

```bash
curl -X POST http://localhost:5116/api/mock/posts \
  -d "title=My Post&tags=tech&tags=programming&tags=llm"
```

Tag automatically converted to JSON array: `["tech", "programming", "llm"]`

#### 2. Soutien au téléchargement des fichiers `multipart/form-data`) 🔥

**Le problème est résolu**: Aucun support pour les téléchargements de fichiers - essentiel à l'essai du document/interfaces d'affichage des imagesM SK3

**Solution**: Memory-Safe streaming de fichiers avec extraction des métadonnées

**Exemple d'utilisation**:

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

**Caractéristiques**:

- **Memory-Safe Streaming**: Les fichiers sont lus par le biais d’un tampon de 8KB et détournés.
- **Extraction de métadonnées**: Nom du fichier , type de contenu M SK2 taille , lecture des octets
- **Plusieurs fichiers**: charger plusieurs fichiers dans une seule demande
- **Contenu mixte**: Champs de formulaire + fichiers ensemble
- **Soutien de fichiers importants**: Étudié avec des fichiers 100MBM SK2
- **Variété du type de contenu**: TexteM SK1 PDF, JPEGMSC3 binaire - tous supportés

**Comment cela fonctionne**:

- Le contenu des fichiers est transmis et discardé (empêche le bloat de la mémoire)
- Seuls les métadonnées sont conservés et transmis à LLM
- LLM génère une réponse appropriée en fonction du contexte d'un téléchargement

**Réponse par exemple**:

```json
{
  "message": "File uploaded successfully",
  "file": {
    "fieldName": "image",
    "fileName": "photo.jpg",
    "contentType": "image/jpeg",
    "size": 524288,
    "processed": true
  }
}
```

#### 3. Longueurs arbitraires des voies de cheminement 🔥

**Le problème est résolu**: Soutien à la profondeur des voies limitées - Les APIs RESTful utilisent souvent le nidage de profondeur

**Solution**: Soutien complet pour les voies profondes via `{**path}` catch-all routing

**Exemple d'utilisation**:

```bash
# 9-segment deep path
curl "http://localhost:5116/api/mock/v1/api/products/electronics/computers/laptops/gaming/high-end/2024/details"

# RESTful resource structure
curl "http://localhost:5116/api/mock/v2/organizations/org-123/departments/dept-456/employees/emp-789/reviews"

# With complex query string
curl "http://localhost:5116/api/mock/products/search?category=electronics&brand=Dell&model=XPS15&price_min=1000&price_max=2500"
```

**Caractéristiques**:

- Aucune limite pratique sur la profondeur du chemin (testée à 21 segmentsM SK2
- Paramètres de la demande entièrement préservés
- Fonctionne avec toutes les méthodes HTTP (GETM SK1 POST, PUTMSC3 DELETEMST4 PATCHMst5
- Compatible avec les formulaires et les téléchargements de fichier
- LLM incorpore les segments de cheminement dans des réponses réalistes

### Mise en œuvre technique

#### .NET  10 Compatibilité

Utilisation de toutes les caractéristiques **construction manuelle de JSON** pour éviter les réflexions-sérialisation basée:

```csharp
// Manual JSON escaping
private static string EscapeJsonString(string str)
{
    return "\"" + str
        .Replace("\\", "\\\\")
        .Replace("\"", "\\\"")
        .Replace("\n", "\\n")
        .Replace("\r", "\\r")
        .Replace("\t", "\\t")
        + "\"";
}
```

**Pourquoi le manuel?**:

#### Mémoire-Gestion de fichiers sécuritaire

```csharp
// Stream and dump file content
var buffer = new byte[8192];
long totalRead = 0;
int bytesRead;

while ((bytesRead = await stream.ReadAsync(buffer)) > 0)
{
    totalRead += bytesRead;
    // Content is discarded - only track size
}
```

**Résultat**: Utilisation de l'O constante(1) mémoire indépendamment de la taille du fichierM SK2

### Essais approfondis

**Nouveaux essais**Essais : 60 unité
**Suite d'essai totale**Essais :  405
**Taux de passage**: 100%

**Évaluer les fichiers**:

- `FormBodyHandlingTests.cs` - 12 Essais de partage des formulaires
- `JsonHandlingTests.cs` - 25 essais d'évacuation et d'extraction de JSON
- `V2_3_0_FeatureTests.cs` - 23 Essais d'intégration pour les flux de travail complets

**Catégories**:

- Partage du corps de forme (valeurs uniquesM SK1arrées,cartes spéciales ,unicédodeMSC4mojieMST5
- Données sur les formulaires multipartites (extraction de métadonnées , champs mixtesM SK2 fichiers, grands fichiers
- Évacuation de JSON (tous les caractères spéciauxM SK1caisses à bord)
- Voies profondes ( jusqu’à 21 segments, demandes complexesPSK3 structures résistantesM SK4
- Systèmes combinés (route profonde + formulaires + fichiersMSC3

### Rendement

**Rendement de la mise à jour des fichiers**:

- **Mémoire**: Constante OM SK1 - seulement 8KiB de tampon dans la mémoire
- **Accroître la vitesse**: Streaming permet d'extraire de grands fichiers sans bloquer
- **Sécurité**: Contenu jamais entreposé, empêche les attaques DoS

**Rendement de la construction JSON**:

- Évacuation manuelle 10-20% plus rapide que la réflexion
- Moins de collections GC
- Le comportement prévisible du temps d'exécution

### Résilier les changements

✅ **Aucune** - Compatible entièrement à l'arrière

- Toutes les fonctionnalités existantes fonctionnent sans changement
- Aucun changement de surface API
- Configuration compatible vers l'arrière
- Régressions zéro (tous 345 Passé des essais existantsM SK2

### Guide des migrations

Aucune migration n’est nécessaire! Tous les changements sont additifs:

```csharp
// Existing code works as-is
builder.Services.AddLLMockApi(builder.Configuration);
app.MapLLMockApi("/api/mock");

// New content types automatically supported
// - JSON (existing)
// - Form bodies (new)
// - File uploads (new)
// - Deep paths (enhanced)
```

### Documentation

**Nouvelle documentation**:

- `TEST_SUMMARY.md` - Couplage complet des essais 60 nouveaux essais
- `IMPLEMENTATION_SUMMARY.md` - Détails sur la mise en œuvre technique
- `V2_3_0_TESTS.md` - Documentation d'essai de l'intégration

**Documentation mise à jour**:

- `README.md` - Nouveaux exemples d'utilisation pour les formulairesFiches ,Préquences , voies profondes
- Mise à jour de la section "Qu'est-ce queM SK1Nouveau"
- Liste des caractéristiques mises à jour
- Mise à jour de la section de couverture des essais

### Limites connues

1. Le contenu du fichier est détourné (sans accès à LLM pour l'analyse)
2. Taille maximale de fichier limitée par les paramètres ASP.NET Core (~28MB)
3. Forme de nom du champ d'arrimage convention: les noms de champ répétés deviennent des tableaux

### Utiliser les cas

**Forme de soutien du corps**:

- Examen des formulaires HTML (login,inscriptionM SK2 commentaires )
- Applications Web traditionnelles
- URL-clients API encodés

**Soutien au téléchargement des fichiers**:

- Utilisations de mise à jour du document
- Essais de mise à jour d'images
- Mise à jour des photos du profil
- Opérations de fichier en vrac
- Traitement des pièces jointes

**Voies profondes**:

- RESTful API structures
- Applications multi-tenant
- Accès hiérarchique aux ressources
- Méthodes de routage complexes

### Contributeurs

Toutes les fonctionnalités v2.3.0 développées et testées par l’équipe d’API LLMock.

---


## v2.2.0 M SK1 Outils pluggables & Pré-APIs Configurés

**Concentration**: MCPM SK1 Système d'outils compatible, pré-- APIs REST configurés , et mémoire contextuelle intelligente

Cette version introduit un puissant système d'outils pluggables pour appeler des API externes et poursuivre les points de fin modèles, ainsi que des définitions préconfigurées de l'API REST qui éliminent la configuration répétitive . La mémoire contextuelle est maintenant autonome- gère avec expiration automatique et extraction complète du champM SK4

### Principales caractéristiques

#### 1. Outils pluggables & Système d'actions 🔥

**Le problème est résolu**: Il n’est pas possible d’appeler des API externes ou des points de fin modèles de chaîne pour créer des flux de travail et des arbres décisionnels réalistes.

**Solution**: MCP- Système d'outils compatible avec les exécutants HTTP et Mock

**Types d'outils**:

**Outils HTTP** - Demander des API REST externes

```json
{
  "Name": "getUserData",
  "Type": "http",
  "HttpConfig": {
    "Endpoint": "https://api.example.com/users/{userId}",
    "Method": "GET",
    "AuthType": "bearer",
    "AuthToken": "${API_TOKEN}",  // Environment variable support
    "ResponsePath": "$.data"       // JSONPath extraction
  }
}
```

**Outils de défectuosité** - Modèles de chaîne pour les arbres décisionnels

```json
{
  "Name": "getOrderHistory",
  "Type": "mock",
  "MockConfig": {
    "Endpoint": "/api/mock/users/{userId}/orders",
    "Method": "GET",
    "QueryParams": { "limit": "10" },
    "Shape": "{\"orders\":[{\"id\":\"string\",\"total\":0.0}]}"
  }
}
```

**Faits clés**:

- **Remplacement du modèle**: `{paramName}` placeholders in URLs, headers, bodies
- **Variables environnementales**: `${ENV_VAR_NAME}` pour le stockage de renseignements confidentiels
- **Authentification**: BearerM SK1 Basic, API Key support
- **Extraction de JSONPath**: Extraire des champs spécifiques des réponses
- **Chaînement d'outils**: Exécuter plusieurs outils en séquence
- **Limites de sécurité**: MaxToolChainDepth et MaxConcurrentTools protègent l'exécution en fuite
- **Cache des résultats**: Opérations de cache coûteuses par demande
- **MCP Compatible**: Architecture prête à l'intégration du protocole de contexte modèle

**Modes d'exécution**:

- `Disabled`: Outils non disponibles
- `Explicit`: Demande par téléphone `?useTool=name` ou `X-Use-Tool` en-tête (Phase
- `LlmDriven`: LLM détermine les outils à appeler.

**Exemple d'utilisation**:

```http
# Execute tool explicitly
GET /api/mock/user-profile?useTool=getUserData&userId=123

# Chain multiple tools
GET /api/mock/dashboard?useTool=getUserData,getOrderHistory&userId=123

# Tool results automatically merged into LLM context
Response: {
  "user": { /* enriched with real API data */ },
  "orders": [ /* from tool chain */ ]
}
```

**Documentation**: `docs/TOOLS_ACTIONS.md` (500+ lignesM SK1

#### 2. Pré-APIs REST Configurés 🔥

**Le problème est résolu**: Configuration répétitive pour les patrons API communs - forme, contexteMSC3 outilsM SK4 limite de vitesseMska5 etcM Ska6

**Solution**: Définir toutes les configurations de l'API une fois qu'on a appelé , par nom

**Exemple de configuration**:

```json
{
  "RestApis": [
    {
      "Name": "user-profile",
      "Method": "GET",
      "Path": "profile/{userId}",
      "Shape": "{\"user\":{},\"orders\":[],\"recommendations\":[]}",
      "ContextName": "user-session",
      "Tools": ["getUserData", "getOrderHistory"],
      "Tags": ["users", "composite"],
      "CacheCount": 5,
      "RateLimitDelay": "500-1000"
    }
  ]
}
```

**Fonctions supportées**:

- **Spécification de la forme**: Forme JSON ou référence à la spécification OpenAPI
- **Intégration OpenAPI**: `OpenApiSpec` + `OpenApiOperationId` pour la génération dirigée par schema-
- **Contexte partagé**: Gestion automatique du contexte via `ContextName`
- **Intégration des outils**: Pré-configure les outils à exécuter
- **Tags/Groupes**: Organiser les API par catégorie
- **Limitation du taux**: Configuration de retard d'API par - Per
- **N-Complétions**: Gérer plusieurs variantes
- **Enregistrement**: Enabler l'écoulement d'SSE
- **Simulation d'une erreur**: Configuration de l'erreur de configuration
- **Paramètres par défaut**: Params et titres de demande

**Avantages**:

- **Répétition zéro**: Configurer une fois, utiliser partout
- **Essais cohérents**: La même formeM SK1contexte à l’échelle de l’équipe
- **Prototypage rapide**: appeler par nom au lieu des demandes de construction
- **Documentation**: Les APIs sont auto-documentés dans la configuration

**Utilisation** ( par l’intermédiaire des points de gestion - venant en version vM SK2

```http
# List all configured APIs
GET /api/configured

# Execute configured API
GET /api/configured/user-profile?userId=123
```

**appsettings.FullM SK1json**: 8 exemples complets incluant eM SK2 flux de travail commerciaux, , APIs de surveillance et , scénarios d'essai

#### 3. Mémoire de contexte dynamique avec expiration automatique 🔥

**Le problème est résolu**: Mémoire de contexte précédemment accumulé à titre indéfini , nécessitant un nettoyage manuel et pouvant causer des fuites de mémoire dans les longues sessions d'essai ou les pipelines de CD

**Solution**: ASP.NET Core `IMemoryCache` avec l'expiration progressive

```csharp
// NEW: Automatic expiration with sliding window
public class MemoryCacheContextStore : IContextStore
{
    private readonly IMemoryCache _cache;
    private readonly TimeSpan _slidingExpiration; // Default: 15 minutes

    // Contexts automatically expire after inactivity
    // Every access refreshes the expiration timer
    // Zero risk of memory leaks!
}
```

**Principaux avantages**:

- **Nettoyage manuel zéro**: Les contextes disparaissent automatiquement après 15 minutes d'inactivité
- **L'expiration des Sliding**: Le Timer se rétablit à chaque appel API - les contextes actifs n'expirent jamais
- **Efficacité de la mémoire**: parfait pour les pipelines CIM SK1CD - aucune accumulation d'état entre les essais
- **Durée de configuration**: Établir les heures de 5 minutes à 24 selon vos besoins

**Configuration**:

```json
{
  "mostlylucid.mockllmapi": {
    "ContextExpirationMinutes": 15  // Default: 15 (range: 5-1440)
  }
}
```

**Paramètres recommandés**:

- **5 minutes**: Essais d'unités rapides , CIM SK2 Pipelines CD
- **15 minutes**: Défault - Essais de développement général CSM2 recommandésCMS3
- **30 minutes**: Processus de travail complexe à plusieurs étapes
- **60+ minutes**: Séances d'essais exploratoires longues

#### 2. Extraction intelligente de données partagées

**Le problème est résolu**: Seulement les champs en code dur (`id`, `userId`, `name`, `email`) ont été suivisM SK1 limitant la cohérence pour le domaine - champs spécifiques tels que les numéros d'articles de l'SKU M SK3 numéros de compte , codes de référence MSC5 etc.

**Solution**: Extraction récursive de champs qui capte **Toutes** champs automatiquement

**Avant (vM SK1**:

```json
// Only 4 hardcoded fields extracted
{"lastId": "123", "lastUserId": "456", "lastName": "Alice", "lastEmail": "alice@example.com"}
```

**Maintenant (vM SK1**:

```json
// ALL fields extracted up to 2 levels deep
{
  "orderId": "123",
  "sku": "WIDGET-01",
  "price": "49.99",
  "customer.customerId": "456",
  "customer.tier": "gold",
  "customer.address.city": "Seattle",  // Nested 2 levels
  "items.length": "1",
  "items[0].productId": "789",
  "items[0].quantity": "2",
  // Legacy keys still work:
  "lastId": "123"
}
```

**Nouvelles capacités**:

- **Objects nichés**: Extraits `address.city`, `payment.cardNumber` avec la notation de points
- **Traçage de l'arrée**: Longueurs des tableaux de stockage (`items.length: 5`)
- **Données sur le premier article**: Captures `items[0].productId` Automatiquement
- **Champs personnalisés**: Tout domaine - champ spécifique est maintenant suivi
- **Domaines non limités**: Travaux pour l’e-commerceM SK1Commerce,FinanceMST3SantéMSC4Génématiques,, etc.
- **Compatible à l'arrière**: Legacy `lastId`, `lastUserId` les clés fonctionnent encore

**Real-Impact mondial**:

```http
### Create order with SKU and tier
POST /api/mock/orders?context=checkout
Response: {"orderId": 123, "sku": "WIDGET-01", "customer": {"tier": "gold"}}

### Apply discount - automatically uses same SKU and tier!
POST /api/mock/discounts?context=checkout
Response: {
  "discountId": 789,
  "sku": "WIDGET-01",      ← Same SKU from previous call
  "customerTier": "gold",  ← Same tier from previous call
  "discount": 0.15
}
```

Le LLM voit maintenant **tous** extrait des champs dans le prompt et maintient la cohérence entre les données spécifiques du domaine- sans aucune configuration

### Détails techniques

**Système d'outils pluggables**:

**Configuration de l'outil** (`Models/ToolConfig.cs`):

- Modèle de configuration détaillé pour tous les types d'outils
- Soutien pour HTTP, Mock, et types d'outils extensibles
- Systèmes de paramètre avec validation du type
- Configuration de l'interruption et du cache

**Exécuteur de l'outil Http** (`Services/Tools/HttpToolExecutor.cs`):

- Substitution de modèles dans les organes URLs, headers, en utilisant `{paramName}`
- Résolution variable de l'environnement avec `${ENV_VAR_NAME}`
- Authentication: BearerM SK1 Basic, API Key
- Extraction de la réponse JSONPath
- Traitement des erreurs globales

**MockToolExecutor** (`Services/Tools/MockToolExecutor.cs`):

- Demande d'autres paramètres finaux modèles pour les flux de travail de l'arbre décisionnel
- Appuie toutes les fonctionnalités du point final de modèle (shape , contextM SK2 etc.)
- Activer des simulations API complexes multi-step

**Registre de l'outil** (`Services/Tools/ToolRegistry.cs`):

- Dévoiler et valider les outils configurés
- Enregistrement de l'exécuteur extensible par `IToolExecutor` interface
- Génie des définitions d'outils pour LLM (Phase

**Instrument d'orchestre** (`Services/Tools/ToolOrchestrator.cs`):

- Coordonner l'exécution des outils avec les limites de sécurité
- MaxToolChainDepth tracking per request (prevents infinite loops)
- Limite de MaxConcurrentTools
- Cache des résultats par demande
- Formats des résultats de la fusion du contexte LLM

**Pré-APIs REST Configurés**:

**RestApiConfig** (`Models/RestApiConfig.cs`):

- Modèle de définition API complet
- Appui à la référence des spécifications OpenAPI
- Intégration de l'outil, tags, paramètres par défaut
- Toutes les fonctionnalités de modèle: forme, contexteM SK2 limitation du tauxMSC3 diffusion en direct , caching

**RestApiRegistry** (`Services/RestApiRegistry.cs`):

- Charge et valide toutes les APIs configurées
- Thread-recherche de sécurité avec `ConcurrentDictionary`
- Auto-recharge les changements de configuration (`IOptionsMonitor`)
- Tag-filtration et regroupement fondés sur
- Validation: champs requis, méthodes HTTP valides , valeurs positives

**Mémoire de contexte**:

**MemoryCacheContextStore** (`Services/MemoryCacheContextStore.cs`):

- Utilisations `IMemoryCache` avec `SlidingExpiration` option
- Registres `PostEvictionCallback` pour l'enregistrement automatique de nettoyage
- Thread-sécuritaire avec `ConcurrentDictionary` pour le suivi des noms
- Détection et suppression des entrées en suspens lors de l'énumération

**OpenApiContextManager** (`Services/OpenApiContextManager.cs`):

- Nouveau `ExtractAllFields()` méthode d'extraction récursive
- Extraction récursive de champs avec une profondeur configurable (defaultM SK1 2 niveaux)
- Applique les valeurs primitives et les tableaux , ,
- **Rétablissement de la retenue**: Longes chaînes (>100 chars) maintenant tronquées dans SharedData pour éviter les bloats
- Retour compatible avec l'extraction de champs anciens

**Configuration** (`LLMockApiOptions.cs`):

- Nouveau `Tools` tableau de définitions d'outils pluggables
- Nouveau `ToolExecutionMode` enum (Disabled /ExplicitM SK2LlmDriven)
- Nouveau `MaxConcurrentTools` et `MaxToolChainDepth` les limites de sécurité;
- Nouveau `RestApis` tableau pour les définitions de l'API préconfigurée -
- Nouveau `ContextExpirationMinutes` propriété (défaultM SK1 15, étendue
- Tous inscrits à DI via `LLMockApiExtensions.RegisterCoreServices()`

### Évaluation

**8 Nouveaux essais** dans `OpenApiContextManagerTests.cs`:

- ✅ Extraction dynamique de tous les champs primitives
- ✅ Extraction d'objets nichés avec la notation de points
- ✅ Traçage de la longueur de l'arrée
- ✅ Extraction du champ de l'article premier tableau
- ✅ Niveaux de nidification multiples (2 profond par défaut
- ✅ Types de données mixtes (stringsM SK2 numbersMSC3 booleans)
- ✅ Compatibilité à l'arrière avec les clés traditionnelles
- ✅ Cases de bord (Objectifs vides, valeurs nullesM SK3 limite de nidification profondeMSC4

### Mise à jour de la documentation

**Nouvelle documentation**:

- `docs/TOOLS_ACTIONS.md` (500+ lignesM SK1 Guide complet sur le système d'outils pluggables
  
  - Aperçu et compatibilité MCP
  - Types d'outils (HTTP et Mock)
  - Référence de configuration avec toutes les options
  - Méthodes d'authentification (Bearer , BasicM SK2 API Key)
  - Exemples d'utilisation et modèles
  - Patterns d'arbre de décision avec outils de simulation
  - Systèmes avancés ( logique conditionnelle , points d'achèvement dynamiques
  - Phase 2/3 feuille de route (LLM-sélection d'outils pilotésM SK3 arbres décisionnels avancésMSC4
  - Référence API avec les schémas TypeScript
  - Troubleshooting et considérations relatives au rendement

- `docs/RATE_LIMITING_BATCHING.md`: Guide global de limitation des taux
  
  - Options de configuration et stratégies
  - N-complissements avec le battage
  - Per- suivi des statistiques de point final
  - Exemples d'essais de performance

**Les fichiers mis à jour**:

- `README.md`: Nouvelle section v2.2.0 avec outils et API préconfigurés
- `appsettings.Full.json`: Exemples complets pour:
  - Configuration des outils 5 ( Outils HTTP et Mock
  - 8 pré-définitions de REST API configurées
  - Exemples d'authentification de l'outil
  - Patterns d'arbre de décision
- `LLMApi.http`: 20+ nouveaux exemples de demande HTTP
  - Exécution de l'outil par le biais des paramètres et des titres de demande
  - Exemples de substitution des modèles
  - Méthodes de recherche d'outils
  - Exemples d'authentification
  - Extraction de JSONPath
  - Surveillance du rendement
- `docs/API-CONTEXTS.md`: Réécriture complète de l’entreposage du contexte et d’extraction des données partagées
  - Architecture IMemoryCache
  - Le comportement d'expiration en cascade
  - Exemples d'extraction dynamique
  - Cases d'utilisation Real-world avec des données nested
- `CLAUDE.md`: Mise à jour avec toutes les nouvelles options de configuration
  - Outils & Configuration des actions
  - Pre-APIs REST configurés
  - Paramètres d'expiration du contexte

### Résilier les changements

**Aucune** - Compatible complètement à l'arrière avec v2.1.0:

- Extraction de champs hérités (`lastId`, `lastUserId`, etc .) fonctionne toujours
- Le code de contexte existant continue à fonctionner sans changement
- Les nouvelles fonctionnalités sont automatiques - aucun changement de code n'est nécessaire

### Guide des migrations

**Aucune migration n’est nécessaire!** Améliorer et profiter des avantages automatiques:

1. **Expiration du contexte**: Les contextes automatisés - se nettoient maintenant eux-mêmes
2. **Extraction améliorée**: Automatique - tous les champs sont maintenant suivis

**Optionnel**: Configurer le temps d'expiration si par défaut 15 minutes ne convient pas à votre flux de travail'

```json
{
  "mostlylucid.mockllmapi": {
    "ContextExpirationMinutes": 30  // Increase for longer test sessions
  }
}
```

### Impact sur le rendement

**Utilisation de la mémoire**: Réduction globale en raison de l'expiration automatique

- Les contextes ne s'accumulent plus indéfiniment
- CI/Les pipelines de CD restent en mémoire
- Long-services d'exploitation autonomeM SK1clean

**Frais d'extraction**: Minimale (< 1ms par réponseM SK3

- L'extraction récursive est hautement optimisée
- Fonctionne seulement sur les réponses avec des contextes
- Limite de profondeur empêche la récursion en train d'échouer

**Utilisation des tokens**: légèrement augmenté

- Plus de champs dans les données partagées = prompts légèrement plus longs
- Augmentation typique: M SK1 tokens par contexte
- Offset par expiration automatique (moins de contextes globaux)

### Compatibilité

- **Compatible intégralement à l'arrière** avec v2.1.0
- Toutes les fonctionnalités existantes continuent de fonctionner
- Aucun changement de rupture
- Mise à niveau-in-place recommandée

---


## v2.1.0 M SK1 ≥- Qualité & Version de validation

**Concentration**: Amélioration de la fiabilité , essais complets M SK2 et meilleure expérience des développeurs

Cette version met l’accent sur l’amélioration de la fiabilité des chunks, fournissant un outil exhaustif de validation , et rationalisant la gestion de la configurationM SK2 Toutes les fonctionnalités de v2.0 demeurent pleinement compatiblesMSC4

### Principales améliorations

#### 1. Suite complète de validation HTTP

- **70+ Cas d'essai**: Protection complète de la validation dans `LLMApi.http`
  - Gestion de l'API Open (loadM SK1 list, getMSC3 unload , describeMST5
  - Gestion du contexte de l'API (créer, mettre à jour , pauseM SK3 renouveler
  - gRPC proto management (uploadMSC1 list, getM SK3 servicesMST4 callMSL5
  - Validation continue de l'écoulement SSE
  - Essais de cartographie avec des larges tableaux
  - Historique du contexte et descriptions personnalisées
  - Choix du backend (X-LLMM SK2Header de l'arrière-plan
  - Validation du schéma (includeSchema + XM SK2Response-SchemaMSC4
  - Validation des caractéristiques combinées
  - Simulation des erreurs (codes d'erreur HTTP compréhensifs)

#### 2. Amélioration de la fiabilité du processus de fabrication

- **Formatage de l'arrée explicite**: Des prompts améliorés avec des instructions explicites pour la génération d'arréaux JSON à l'aide d'un ultra-
  - Des règles de formattage critiques ont été ajoutées `PromptBuilder.cs`: " Votre premier caractère DOIT être ["
  - Formatage renforcé de l'arrée dans `ChunkingCoordinator.cs` Contexte de l'article
  - Prévient la comma- sortie d'un objet séparé (eM SK2g ., `{...},{...}` au lieu de `[{...},{...}]`)
- **Amélioration de l'instruction suivante**: Amélioration des directives pour les LLM lors de demandes multiples
- **Limites connues**: Modèle documenté `docs/OLLAMA_MODELS.md`)

#### 3. Simplification de la configuration

- **Nettoyage `appsettings.json`**: Commentaires sur le modèle verbose retirés , structure plus propre
- **`docs/OLLAMA_MODELS.md`**: Nouveau guide de référence complet (285 lignes
  - 10+ configurations de modèles avec des exigences matérielles
  - Lignes directrices sur la température pour différents cas d'utilisation
  - Recommandations en matière de taille des fenêtres contextuelles
  - Exemples de configuration multi-backend
  - Guide de troubleshooting pour la résolution des problèmes
  - Instructions d'installation du modèle

#### 4. Amélioration de la documentation

- **Documentation complète de l'évacuateur**: Tous les points de gestion 25+ ont maintenant des dossiers Swagger complets
  - Tag organisation (OpenAPI Management,Contextes APIM SK2gRPCMST3 etcMSC4
  - Résumés et descriptions détaillées
  - Demande/exemples de réponse
- **Référence à l'API de backend**: Nouveau `docs/BACKEND_API_REFERENCE.md` (600+ lignesM SK1
  - Documentation finale complète
  - Paramètres de recherche et référence des titres
  - Formats de réponse d'erreurs
  - Documentation du centre SignalR

### Fixes de bogues

- Fixé problème d'encodage URL dans le test HTTP pour les descriptions des points de fin OpenAPI (`:`, `/`, `{`, `}` caractères)

### Les fichiers sont modifiés

**Changements de code:**

- `mostlylucid.mockllmapi/Services/PromptBuilder.cs`: Instructions de formattage des tableaux améliorés
- `mostlylucid.mockllmapi/Services/ChunkingCoordinator.cs`: Formatage additionnel de tableaux dans le contexte du tronçon (line 447)
- `LLMApi/appsettings.json`: Configuration simplifiée

**Nouvelle documentation:**

- `docs/OLLAMA_MODELS.md`: Guide de configuration détaillé du modèle
- `docs/BACKEND_API_REFERENCE.md`: Référence API de gestion complète

**Dossiers mis à jour:**

- `LLMApi/LLMApi.http`: Étendue de la ligne 448 à la ligne 847

### Limites connues

**Concentration à haute température**:

- Les LLM peuvent générer des objets séparés par comma-au lieu de tableaux à température 1.2+
- **Méthodes de recours**:
  1. Température inférieure à 0.8-1.0 pour les demandes ponctuelles
  2. Utiliser llama3.2:3b ou mistralM SK1nemo (instructions meilleures aprèsMSC3
  3. Réduire le nombre d'articles pour éviter la fragmentation
  4. Disable auto-chunking with `?autoChunk=false`

Voir `docs/OLLAMA_MODELS.md` pour une solution détaillée des problèmes.

### Compatibilité

- **Compatible intégralement à l'arrière** avec v2.0.0
- Toutes les fonctionnalités existantes continuent de fonctionner
- Aucun changement de rupture

---


## v2.0.0 M SK1 ≥- MAJOR RELEASE

**Aucun changement important** - En dépit de l’écrasement majeur des versions, tous les codes existants continuent à fonctionner.

Il s’agit d’un important jalon de lancement qui transforme l’API LLMock en une production complète, - plate-forme pour le moquage réalisteM SK2 Version 2.0 ajoute des modes d’écoulement SSE réalistesMST4 multiMSC5 balayage du chargement de la backendMSM6 sélection globale de la Backend MSM7 et documentation exhaustiveMMSC8

### Principales caractéristiques

#### 1. Modes réels d'écoulement de l'SSE MAJORM SK2

Trois modes distincts de diffusion SSE pour tester différents modèles API réels

**Mode LlmTokens** (Définition par défaut - Compatible à l'arrière

- Token-by-token streaming pour les interfaces de chat AI
- Format: `{"chunk":"text","accumulated":"fulltext","done":false}`
- Case à utiliser: Utilisation d'interfaces de chatbot pour tester les applications LLM

**Mode des objectifs complets** (NEWM SK1

- Remplir les objets JSON en tant que événements distincts de l'SSE
- Format: `{"data":{object},"index":0,"total":10,"done":false}`
- Case d'utilisation: TwitterM SK1X API, stock tickersMSC3 realMST4time feeds , IoT sensors

**Mode d'ArrayItems** (NEWM SK1

- Éléments d'arrée avec des métadonnées riches
- Format: `{"item":{object},"index":0,"total":100,"arrayName":"users","hasMore":true,"done":false}`
- Case à utiliser: Résultats pagenésM SK1 exportations en vrac, résultats de recherche

**Configuration:**

```json
{
  "MockLlmApi": {
    "SseMode": "CompleteObjects"  // LlmTokens | CompleteObjects | ArrayItems
  }
}
```

**Per-Request Override:**

```http
GET /api/mock/stream/users?sseMode=CompleteObjects
GET /api/mock/stream/data?sseMode=ArrayItems
GET /api/mock/stream/chat?sseMode=LlmTokens
```

**Exemple de client (Objects complets):**

```javascript
const eventSource = new EventSource('/api/mock/stream/users?sseMode=CompleteObjects');

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

    if (response.done) {
        console.log('Complete!');
        eventSource.close();
    } else {
        console.log(`User ${response.index + 1}/${response.total}:`, response.data);
        // response.data contains the complete user object
    }
};
```

#### Équilibrage des charges de l'arrière-plan (MAJOR

Distribuer les demandes à travers plusieurs backends de LLM pour un haut débit:

**Configuration:**

```json
{
  "MockLlmApi": {
    "Backends": [
      {
        "Name": "ollama-llama3",
        "Provider": "ollama",
        "Weight": 3,
        "Enabled": true
      },
      {
        "Name": "ollama-mistral",
        "Provider": "ollama",
        "Weight": 2,
        "Enabled": true
      },
      {
        "Name": "lmstudio-default",
        "Provider": "lmstudio",
        "Weight": 1,
        "Enabled": true
      }
    ]
  }
}
```

**SignalR Hub with Load Balancing:**

```json
{
  "HubContexts": [
    {
      "Name": "high-throughput-data",
      "BackendNames": ["ollama-llama3", "ollama-mistral", "lmstudio-default"]
    }
  ]
}
```

**Caractéristiques:**

- Distribution pondérée derobin
- Per-request de sélection du backend
- Failover automatique par défaut si les backends ne sont pas disponibles
- Travaille avec SignalR, SSE, RESTM SK2 et GraphQL

#### 3. Selection globale de l'arrière-plan

**Per-Request Selection** (Methodologies multiples):

```http
# Via query parameter
GET /api/mock/users?backend=openai-gpt4

# Via header
GET /api/mock/users
X-LLM-Backend: openai-gpt4

# SignalR hub context
{
  "HubContexts": [
    {
      "Name": "analytics",
      "BackendName": "openai-gpt4-turbo"
    }
  ]
}
```

**Multiples fournisseurs simultanément:**

- Ollama (modèles locauxM SK1
- OpenAI (cloud API)
- LM Studio (server local)
- Mistral-Nemo (128k contexteM SK2

#### 4. MistralM SK1Nemo 128k Soutien du contexte

Configuration pour Mistral-Nemo avec massive 128k context windowM SK2

```json
{
  "Backends": [
    {
      "Name": "ollama-mistral-nemo",
      "Provider": "ollama",
      "ModelName": "mistral-nemo",
      "MaxTokens": 128000,
      "Enabled": true
    }
  ]
}
```

**Utiliser les cases:**

- Gérer des milliers de documents détaillés dans une seule demande
- Structures de données ensemencées complexes avec des relations profondes
- Opérations de gros lots (utiliser avec `MaxItems=10000+`)
- Ensembles de données d'essai exhaustifs
- Demandes de GraphQL avec des champs étenduement ensemblés

**Exemple de SignalR:**

```json
{
  "HubContexts": [
    {
      "Name": "massive-dataset-128k",
      "Description": "Massive dataset generation with 128k context",
      "BackendName": "ollama-mistral-nemo"
    }
  ]
}
```

#### 5. Swagger/OpenAPI UI

Interactive API documentation avec Swagger UI:

- **L'interface de Swagger**: Disponible à `/swagger`
- **Spécification OpenAPI**: AutoM SK1générée à partir de points finals
- **Essais interactifs**: Essayez les points finals directement dans le navigateur
- **Descriptions détaillées**: Documentation complète pour tous les points finals
- **Navigation**: Lien vers le titre de la page de démonstration

**Activer dans le programme.cs:**

```csharp
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

app.UseSwagger();
app.UseSwaggerUI();
```

### Révision de la documentation

#### Nouveaux fichiers de documentation

- **`docs/SSE_STREAMING_MODES.md`** (2,500+ lignesM SK1 - Guide complet de l'SSE
  
  - Explication détaillée des trois modes
  - Exemples de code client pour chaque mode
  - Utiliser la matrice de décision des cas
  - Tableaux de comparaison
  - Guide des migrations
  - Section Troubleshooting

- **`LLMApi/SSE_Streaming.http`** - 30+ Examples HTTP pour les modes SSE
  
  - Exemples pour les trois modes SSE
  - Exemples de fonctionnalités combinées (selection du backend,contexte
  - Usages pratiques (tickers de stockM SK1 exportations en vrac, registresMSC3
  - Exemples de code JavaScript du client

#### Documentation mise à jour

- **`docs/CONFIGURATION_REFERENCE.md`** - Section des modes d'SSE ajoutée
- **`docs/MULTIPLE_LLM_BACKENDS.md`** - Amélioré par balayage de la charge
- **`appsettings.Full.json`** - Exemples de mode SSE ajoutés et Mistral

### 🧪 Amélioration des essais

**Nouvelle couverture d'essai:**

- **Essais de mode SSE 22** (tous les passagesM SK1
  - Validation de la valeur d'Enum
  - Analyse de la configuration
  - Supprimer le paramètre de la demande
  - Validation du format d'événement pour tous les modes
  - Case-parsage insensible

**Suite d'essai totale:**

- **Essais 218** (213 PassationM SK1 5 Essais gRPC ont été abandonnés)
- Nulle erreur de compilation ou mises en garde
- Compatibilité ultérieure complète vérifiée

### 🔧 Améliorations de configuration

**Nouvelles options de configuration:**

```json
{
  "MockLlmApi": {
    // SSE Streaming Modes (NEW)
    "SseMode": "LlmTokens",  // LlmTokens | CompleteObjects | ArrayItems

    // Multiple LLM Backends with Load Balancing (v1.8.0)
    "Backends": [
      {
        "Name": "backend-name",
        "Provider": "ollama",  // ollama | openai | lmstudio
        "BaseUrl": "http://localhost:11434/v1/",
        "ModelName": "llama3",
        "ApiKey": null,
        "MaxTokens": 8192,
        "Enabled": true,
        "Weight": 3,  // For load balancing
        "Priority": 10
      }
    ],

    // Legacy Single Backend (Still Supported)
    "BaseUrl": "http://localhost:11434/v1/",
    "ModelName": "llama3",

    // Auto-Chunking (v1.8.0)
    "EnableAutoChunking": true,
    "MaxInputTokens": 4096,
    "MaxOutputTokens": 2048,
    "MaxItems": 1000,

    // Streaming Configuration
    "StreamingChunkDelayMinMs": 0,
    "StreamingChunkDelayMaxMs": 0,

    // Cache Configuration
    "CacheSlidingExpirationMinutes": 15,
    "CacheAbsoluteExpirationMinutes": 60,
    "MaxCachePerKey": 5
  }
}
```

### 🌍 Variables environnementales

Soutien global des variables environnementales avec une documentation complète:

```bash
# SSE Mode
export MockLlmApi__SseMode="CompleteObjects"

# Backend Selection
export MockLlmApi__Backends__0__Name="ollama-llama3"
export MockLlmApi__Backends__0__Provider="ollama"
export MockLlmApi__Backends__0__BaseUrl="http://localhost:11434/v1/"
export MockLlmApi__Backends__0__ModelName="llama3"
export MockLlmApi__Backends__0__Enabled="true"
export MockLlmApi__Backends__0__Weight="3"

# SignalR Hub Contexts with Backend Selection
export MockLlmApi__HubContexts__0__Name="analytics"
export MockLlmApi__HubContexts__0__BackendName="openai-gpt4-turbo"

# Or load balancing
export MockLlmApi__HubContexts__1__BackendNames__0="ollama-llama3"
export MockLlmApi__HubContexts__1__BackendNames__1="ollama-mistral"
```

### 📦 Nouveaux fichiers

**Mise en œuvre de base:**

- `mostlylucid.mockllmapi/Models/SseMode.cs` - Enum du mode SSE
- `mostlylucid.mockllmapi/Services/Providers/ILlmProvider.cs` - Interface des fournisseurs
- `mostlylucid.mockllmapi/Services/Providers/OllamaProvider.cs` - Fournisseur Ollama
- `mostlylucid.mockllmapi/Services/Providers/OpenAIProvider.cs` - Officier OpenAI
- `mostlylucid.mockllmapi/Services/Providers/LMStudioProvider.cs` - Fournisseur de Studio LM
- `mostlylucid.mockllmapi/Services/Providers/LlmProviderFactory.cs` - Fabrication de fournisseurs
- `mostlylucid.mockllmapi/Services/LlmBackendSelector.cs` - Logique de sélection du backend

**Essais:**

- `LLMApi.Tests/SseModeTests.cs` Essais de mode SSE

**Documentation:**

- `docs/SSE_STREAMING_MODES.md` - Guide complet de l'SSE 2,500+ lignesM SK2
- `LLMApi/SSE_Streaming.http` Exemples de SSE

### 📝 Dossiers mis à jour

**Services de base:**

- `mostlylucid.mockllmapi/LLMockApiOptions.cs` - Ajouté `SseMode` propriété, `LlmBackends` Tableau 1
- `mostlylucid.mockllmapi/RequestHandlers/StreamingRequestHandler.cs` - Routage du mode SSE ajouté
- `mostlylucid.mockllmapi/Services/LlmClient.cs` - Surcharges supplémentaires de sélection du backend ajoutées
- `mostlylucid.mockllmapi/Services/MockDataBackgroundService.cs` - Ajout de la sélection du backend SignalR
- `mostlylucid.mockllmapi/Models/HubContextConfig.cs` - Ajouté `BackendName` et `BackendNames`

**Documentation:**

- `README.md` - Mise à jour à v2.0, liste complète des fonctionnalités
- `docs/CONFIGURATION_REFERENCE.md` - Modus SSE et sélection de backend ajoutés
- `docs/MULTIPLE_LLM_BACKENDS.md` - Amélioré avec des exemples d'équilibre de la charge
- `appsettings.Full.json` - Exemples détaillés ajoutés

**Application de démonstration:**

- `LLMApi/Program.cs` - Configuration de Swagger ajoutée
- `LLMApi/Pages/_Layout.cshtml` - Lien UI de Swagger ajouté

### 🎨 Exemples de cas d'utilisation

**Stock Market Feed (Objects complets):**

```http
GET /api/mock/stream/stocks?sseMode=CompleteObjects&shape={"ticker":"AAPL","price":150.25,"change":2.5}
```

**Exportation de marchandises en vrac (ArrayItems):**

```http
GET /api/mock/stream/export-customers?sseMode=ArrayItems&shape={"customers":[{"id":"string","name":"string"}]}
```

**Interface de chat AI (LlmTokens):**

```http
GET /api/mock/stream/chat?sseMode=LlmTokens&shape={"message":"Hello!"}
```

**High-Senseurs IoT à haut débit M SK1Load Balanced):**

```json
{
  "HubContexts": [
    {
      "Name": "iot-sensors",
      "BackendNames": ["ollama-llama3", "ollama-mistral", "lmstudio-default"]
    }
  ]
}
```

**Ensemble de données massives avec 128k Contexte**

```http
GET /api/mock/stream/bulk-data?sseMode=ArrayItems&backend=ollama-mistral-nemo
```

### Migration de v1.x

**Aucun changement de code requis!**

Version 2.0 est compatible 100% vers l'arrière avec vM SK2x:

```csharp
// v1.x code - still works exactly the same
builder.Services.AddLLMockApi(builder.Configuration);
app.MapLLMockApi("/api/mock", includeStreaming: true);

// SSE streaming defaults to LlmTokens mode (original behavior)
// Legacy single backend config (BaseUrl/ModelName) still works
```

**Opt-Introduction aux nouvelles fonctionnalités:**

```csharp
// Same setup, just update appsettings.json
{
  "MockLlmApi": {
    "SseMode": "CompleteObjects",  // Switch to realistic streaming
    "Backends": [...]  // Add multiple backends
  }
}
```

### Résilier les changements

**NONE!**

En dépit de la version majeure de 2.0,, il n’y a aucune modification de rupture.

- Le mode SSE par défaut est `LlmTokens` (conduite originaleM SK1
- L'héritage `BaseUrl`/`ModelName` config encore supporté
- Tous les points de fin existants fonctionnent sans changement
- Tous les tests existants réussissent
- La compatibilité ultérieure totale est maintenue

### 📈 Amélioration du rendement

- **Balancing des charges multi-Backend**: Distribuer la charge sur plusieurs instances LLM
- **Tour pondéré-Robin**: Distribution intelligente basée sur les fonctionnalités de backend
- **Backend-Limitations spécifiques des tokens**: Optimiser les capacités de chaque modèle
- **Mode des objectifs complets**: Moins d’événements SSE = moins de frais généraux que le token

### Pourquoi la version 2.0?

Cette version représente une transformation fondamentale:

**v1.xM SK1 Mock API avec génération à puissance LLM-**

- Un seul backend LLM
- Un mode d'écoulement SSE
- Configuration de base

**v2.0: Production-Ready Mock Platform**

- Multiple LLM backends with load balancing
- Trois modes d'écoulement SSE réalistes
- Choix intégral du backend
- Production-configuration à l'échelle M SK1k contextes)
- Enterprise-documentation prête
- Documentation API interactive (Swagger)

Version 2.0 positionne LLMock API comme une plate-forme de remorquement complète capable de traiter la production-exigences d'essai à grande échelle dans divers cas d'utilisationM SK2

### Documentation complète

- **[Modes d'écoulement SSE](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/SSE_STREAMING_MODES.md)** - Guide complet sur les modes SSE
- **[Multiple LLM Backends](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/MULTIPLE_LLM_BACKENDS.md)** - Guide de configuration du backend
- **[Référence de configuration](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/CONFIGURATION_REFERENCE.md)** - Toutes les options de configuration
- **[Exemples HTTP](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMApi/SSE_Streaming.http)** - PréparéM SK1à-exemples de SSE
- **[Enregistrement et saisie](https://github.com/scottgal/LLMApi/blob/refs/heads/master/CHUNKING_AND_CACHING.md)** - AutoM SK1guide de sauvetage
- **[Contextes de l'API](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)** - Guide de gestion du contexte
- **[Soutien gRPC](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/GRPC_SUPPORT.md)** - Guide de montage gRPC
- **[README](https://github.com/scottgal/LLMApi/blob/refs/heads/master/README.md)** - Démarrage rapide et aperçu

### 🙏 Merci

Merci à tous les utilisateurs et contributeurs qui ont aidé à transformer l’API LLMock en une plate-forme de montage complète. Votre rétroaction et vos cas d’utilisation ont conduit ces améliorations!

---


## v1.8.0 M SK1

Voir les notes de mise à jour précédentes pour v1.8.0 fonctions M SK1Support multiple du backend LLM, Demande automatisée de saisie de fichiersMSC3 Configuration améliorée des caches ).

---


## Publications antérieures

Voir l’historique complet de la mise à jour ci-dessous pour v1.7.xM SK1 v 1.6.x≥, v\1.5.x , et les versions antérieuresMSC6