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

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

# Inleiding

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

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

Ni kan hitta[ GitHub här ](https://github.com/scottgal/LLMApi)för projektet, all offentlig domain etc...

[TOC]

# Koncept

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

# Benötningar

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

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

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

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

# mestlucid.mockllmapi

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

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

[![NuGet](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)
[![GitHub-utsläpp](https://img.shields.io/github/v/release/scottgal/LLMApi)](https://github.com/scottgal/LLMApi/releases)
[![Licensen : Olicenctioner](https://img.shields.io/badge/license-Unlicense-blue.svg)](http://unlicense.org/)

**Kompanionspaket:** [mestlucid.mockllmapi.Testing](https://github.com/scottgal/LLMApi/blob/refs/heads/master/mostlylucid.mockllmapi.Testing/README.md) - Testverktyg med flytande HttpClient integration

---


## Hur man läser denna README

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

- **"Jag vill pröva detta i 5 minuter** → Spring till [Vinnig Start](#quick-start)
- **"Jag vill veta vad det här kan göra** → Se [Featurer överblick](#features) och [Arkitektur](#architecture)
- **"Jag vill förstå hur det fungerar** → Lees [Feature Dokumentation](#feature-documentation) och [avancerade egenskaper](#advanced-features)

---


## Vad är nytt?

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

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

### Version 2.5.0 detaljer

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

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

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

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

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

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

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

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

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

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

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

[Se TEST_SUMMARYM SK1md och IMPLEMENTATION_SUMmARY .md för detaljer](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 detaljer

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

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

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

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

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

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

[Se TEST_SUMMARYM SK1md och IMPLEMENTATION_SUMmARY .md för detaljer](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 detaljer

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

**1. Pluggable Tools & Actions System** - Koppla in externa REST APIs eller kedjans mock slutpunkter för att skapa realistiska arbetsflöden och beslutsträd. [Hela dokument →](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/TOOLS_ACTIONS.md)

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

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

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

**5. Förstärkt dokumentation** - Nya omfattande vägledningar för [verktyg & Aksier](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/TOOLS_ACTIONS.md), [Limitering av hastighet](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/RATE_LIMITING_BATCHING.md), och [API Kontexter](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md).

[Se RELEASE_NOTES.md för detaljer](https://github.com/scottgal/LLMApi/blob/refs/heads/master/RELEASE_NOTES.md)

</details>
---


## Tabellen med innehåll

### Kernkoncepter

- [Featurer överblick](#features) - Vad detta system kan göra
- [Vinnig Start](#quick-start) - Starta i 5 minuter
- [Arkitektur](#architecture) - Hur allt passar ihop
- [icke-mål & gränser](#non-goals--boundaries) - Vad detta inte är

### Protokoll & egenskaper

- [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)
- [OpenAPI / Swagger](#openapi--swagger-mock-generation)
- [gRPC Services](#6-grpc-service-mocking-new-in-v170)

### avancerad & arkitektur

- [Konfigurationsoptioner](#configuration-options)
- [Feature Dokumentation](#feature-documentation) - I depth guides
- [avancerade egenskaper](#advanced-features)
- [Demo-applikationer](#demo-applications)
- [Testing](#testing)

---


## Arkitektur överblick

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

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

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

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

**Nyckelkomponenter:**

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

Se [detaljerade arkitekturdiagramer](#architecture) لاندې för begäranström och formkontroll.

---


## Mönster

Paketet erbjuder **sex oberoende egenskaper** - använda vilken kombination som helst du behöver [Modulära exempel](https://github.com/scottgal/LLMApi/blob/refs/heads/master/MODULAR_EXAMPLES.md) för protokoll-specifika konfigurationer):

### 1. REST API Mocking

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

### 2. GraphQL API Mocking

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

### 3. Server

- **Fortskridande Streaming**: SSE-stöd med progressiv JSON-generation
- **Aktualiseringar av realtid**: Datentoken från strömmen
- **Det fungerar ensam**: No REST API setup required
- **[kompletta SSE Guide](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/SSE_STREAMING_MODES.md)** | **[Kontinuösa strömningar](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/CONTINUOUS_STREAMING.md)**

### 4. SignalR Real-Time Streaming

- **WebSocket Streaming**: Kontinuösa verkliga data över SignalR
- **Flera sammanhang**: kör flera oberoende dataflöden samtidigt
- **Livkedjanshantering**: Start/stoppa kontexter dynamiskt med administrationsAPI
- **Det fungerar ensam**: No REST API setup required
- **[SignalR Demo Guide](https://github.com/scottgal/LLMApi/blob/refs/heads/master/SIGNALR_DEMO_GUIDE.md)**

### 5. OpenAPI / Swagger Mock Generation

- **Automatisk Endpoint Generation**: Punktera på vilken OpenAPI som helst /Swaggerspecifikation | ( | URL eller file
- **Alla operationer togs bort**: Varje väg och metod från spec blir en direkt slutpunkt
- **Schema-driven data**: LLM genererar realistiska data som matchar dina schema
- **Flera Speser**: Lade och monterade flera API-spetsar samtidigt
- **Det fungerar ensam**: No REST API setup required
- **[OpenAPI Features Guide](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/OPENAPI-FEATURES.md)**

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

- **Proto-filer ladda upp**: ladda upp .proto-filer för att generera gRPC-servmodeller
- **Dual Protocol Support**: JSON över HTTP för testning , binär Protobuf för produktion
- **Dinamisk serialisering**: Runtime Protobuf-kodering utan kod generering
- **LLM-Spowered Data**: Realistiska svar som matchar dina protosignaldefinitioner
- **Det fungerar ensam**: No REST API setup required
- **[gRPC Support Guide](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/GRPC_SUPPORT.md)**

### De vanliga egenskaperna

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

---


## icke-mål & gränser

**Vad är detta?**

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

**Vad detta inte är**

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

**När man ska använda den:**

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

**När inte använda den:**

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

---


## Feature Dokumentation

För detaljerade vägledningar med arkitekturdiagramer

- **[Docker-användningsguidet](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/DOCKER_GUIDE.md)** - Komplett Konfiguration och användning av Docker
  
  - Vinnigstart med Docker Compose + Ollama
  - Slut exempel med llm
  - Konfigurationsmetoder (env varsM SK1 volym kartläggning, . env-filerMSC4
  - GPU support , multi- baksida
  - Tillverkningsuppfattningar och problemlösning

- **[Referencen till Backend API](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/BACKEND_API_REFERENCE.md)** - Complete management endpoint documentation
  
  - OpenAPI-drivande slutpunkter
  - API: s kontextstyrning
  - gRPC-proto-management
  - SignalR-huber
  - Full request/respons exempel

- **[Multiple LLM Backends Guide](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/MULTIPLE_LLM_BACKENDS.md)** - Multiple provider support
  
  - Anslut till Ollama, OpenAI, och LM Studio samtidigt
  - Per-skräv backend-selection via opskrifte /sklära paramer
  - Komplett bakåt-kompatibilitet med gamla konfigurationer
  - Tillhandahållare- specifika exempel och bästa metoder

- **[API Kontextführer](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)** - NEWM SK1
  
  - Samlad minne över requester för konsekventa multi-step-Workflows
  - E- kommersiella influenser , stock tickers , spelsituations exempel
  - Tokenshantering och intelligent uttackning
  - Mermaids arkitekturdiagram

- **[Limitering av hastighet & Batching Guide](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/RATE_LIMITING_BATCHING.md)** - NOWE i vM SK1
  
  - N-kompletionsstöd för att generera flera reaktionsvarianter
  - Per- slutpunktsstatistiker följd med rörliga medel
  - Tre slagstrategier (Sekvämt,ParallellM SK2 Streaming )
  - detaljerade timingsголовer för prestationstester
  - Perfekt för att testa backoff-strategier och avbrottsscenarier

- **[Pluggable Tools & Actions Guide](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/TOOLS_ACTIONS.md)** - NOWE i vM SK1
  
  - MCP-kompatibel arkitektur för utvidgbar verktygsintegration
  - HTTP-verktyg för att kalla externa APIs med autentisering
  - Mock verktyg för att skapa beslutsträd och arbetsflöden
  - Template-substitutioner med stöd för miljövariabler
  - Att spåra verktyg med säkerhetsgränser och att kaska resultat
  - Fasen 1 (Explicit), Fasen

- **[gRPC Support Guide](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/GRPC_SUPPORT.md)** - NOWE i vM SK1
  
  - Uploada .proto-filer för automatisk gRPC-serv mocking
  - Dual support: JSON över HTTP och binär Protobuf
  - LLM-driven realistisk responsgenerering
  - kompletta implementeringsdetails och teststrategier

- **[OpenAPI Features Guide](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/OPENAPI-FEATURES.md)**
  
  - Dynamiskt dragning av specifikationer från URLs, filen, eller inline JSON
  - Automatisk slutpunkt generering med vägparameter
  - Om du vill svara på ett exempel med Petstore API
  - SignalR-integration för realen

- **[Modulära arkitektoniska exempel](https://github.com/scottgal/LLMApi/blob/refs/heads/master/MODULAR_EXAMPLES.md)**
  
  - REST-omnär, GraphQL-omNur, SignalRM SK4only konfigurationer
  - Optimeringsstrategier
  - Blanda och matcha protokoll

- **[SignalR Demo Guide](https://github.com/scottgal/LLMApi/blob/refs/heads/master/SIGNALR_DEMO_GUIDE.md)**
  
  - Real-tidsdataströmuppsättning
  - Kontextlivskedjans hantering
  - Clientuppkopplingsexempler

- **[Release Notes](https://github.com/scottgal/LLMApi/blob/refs/heads/master/RELEASE_NOTES.md)**
  
  - kompletta versionshistoria
  - Breka förändringar ( ingen sedan vM SK1
  - Migrationsführer

- **[Testuppfattning](https://github.com/scottgal/LLMApi/blob/refs/heads/master/TEST_SUMMARY.md)** - NOWE i vM SK1
  
  - Den kompletta dokumentationen
  - 228 tester med detaljerad brytning
  - Performance mätningar och validering
  - Alla kategorier förklarade

- **[Implementeringsförteckning](https://github.com/scottgal/LLMApi/blob/refs/heads/master/IMPLEMENTATION_SUMMARY.md)** - NOWE i vM SK1
  
  - Formularskropp och upplaad implementeringsdetailer
  - Handlig JSONkonstruktion för .NET 10
  - Memory-säkra file handlingsarchitektur
  - kompletta kodförändringar och logik

---


## Vinnig Start

### Installation

**huvudpaket:**

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

**Testverktyg (Optionellt):**

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

> Erfordrar flytande API för enkel HttpClient konfiguration i tester. [Se tester i sektionen](#testing) för detaljer.

### Vinnig Start med Docker (Empfohlend)

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

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

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

Se den **[kompletta Dockerführer](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/DOCKER_GUIDE.md)** för:

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

### Förberedelser ( Lokal utveckling)

Om du inte använder Docker:

1. Installera [.NET  8.0 SDK](https://dotnet.microsoft.com/download/dotnet/8.0) eller senare
2. Installera [Ollama](https://ollama.ai/) och dra en modell:
   ```bash
   ollama pull ministral-3:3b
   ```

### Att välja en LLM-modell

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

#### Rekomenderade modeller

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

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

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

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

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

**Varför är det bra?**

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

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

**För produktionen-liknande tester med komplexa schemat:**

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

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

**Varför är det bra?**

- Högst kvalitet och realistisk datagenerering
- **128K kontextfenster** ( kräver [Ollama-konfiguration](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/MULTIPLE_LLM_BACKENDS.md#ollama-context-window-configuration))
- Det bästa för komplexa nesterade strukturer och stora datasamlingar
- Mer kreativ variation i genererade data
- **Beteckning**: kräver fler resurser

#### Modell-Specific Konfiguration

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

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

**För gemma3:4b eller llama3:**

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

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

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

**Nota:** Mistral-nemo kräver [Ollamas kontextkonfiguration](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/MULTIPLE_LLM_BACKENDS.md#ollama-context-window-configuration) för 128K kontexter.

**Var man hittar MaxContextWindow:**

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

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

**För mindre modeller (phi3, tinyllamaM SK2**

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

**Varför temperaturen spelar roll:**

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

#### Installation

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

**viktiga begränsningar:**

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

### Grundanvändning

**Programm .cs:**

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

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

app.Run();
```

**appsettings.json:**

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

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

## Auto-forma (Forma minnet)

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

### Vad det gör

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

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

### Ett snabbt exempel

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

### Konfiguration

**Aktiverat standardmässigt** i `appsettings.json`:

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

### Per-Ansökskontroll

**Deaktivera specifika begäran:**

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

**Förnya en dålig form:**

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

### Path Normalisering

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

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

### Nyckliga egenskaper

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

### När man ska använda

**Perfekt för:**

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

**Inte nödvändigt när:**

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

### Troubleshooting

**Former som inte används?**

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

**Man måste ändra formen?**

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

**Lösa alla former programmerat:**

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

För den kompletta dokumentationen, se [CLAUDE.md AutoShape sektion](https://github.com/scottgal/LLMApi/blob/refs/heads/master/CLAUDE.md#autoshape-feature-shape-memory).

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

## Konfigurationsoptioner

> **📘 Komplett konfigurationsreferens** Se [Konfigurationsreferensführer](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/CONFIGURATION_REFERENCE.md) för alla alternativ
> **📄 Hela exempel** Se [appsettings.Full.json](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMApi/appsettings.Full.json) - demonstrerar **varenda dag** Konfigurationsoption

### Genom applikationer.json

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

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

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

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

**API Kontexter**: För detaljerad information om att använda kontexter för att upprätthålla konsistens mellan begäran **[API Kontextführer](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)**.

### Robusthetspolitiker

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

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

**Exponential Backoff**

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

**Serkretsbrytare**

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

**Konfiguration:**

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

**Logging:**

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

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

**När man ska justera**

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

### Genom kod

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

### Customa slutpunktsmönster

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

## Till exempel:

### Grundkrav

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

Ge tillbaka realistiska användardata som genererats av LLM.

### Formular med kroppsuppgifter (NEW i v2.3.0)

**HTML-lomagesinlägg:**

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

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

**Formular med flera värder:**

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

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

### Upload requests (NEW i v2.3.0)

**Att ladda upp en enda file:**

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

**Flera filer med formdata:**

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

**Hur file Uploads fungerar:**

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

**Ett exempel på svaret:**

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

### Deep Path Nesting (NEW i v2.3.0)

**komplexa Nested Paths:**

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

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

### Med API-kontext (NEW i v1.5.0)

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

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

Varje applikation i samma kontext ser de tidigare applikationerna, som garanterar konsekventa IDs , namn M SK2 och datarelationer . Perfekt för flera- stegverk **[API Kontextführer](https://github.com/scottgal/LLMApi/blob/refs/heads/master/docs/API-CONTEXTS.md)** för kompletta exempel.

### Med formkontroll

```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 genererar data som matchar din exakta form specifikation.

### Streaming (SSE - Server

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

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

**Användning:**

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

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

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

**Ett exempel från JavaScript:**

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

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

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

**Med formkontroll:**

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

Den stromande slutpunkten supporterar alla samma egenskaper som vanliga slutpunkter:

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

## GraphQL API-mocking

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

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

### En snabb start med GraphQL

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

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

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

### Grundanvändning

**Enkel fråga:**

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

**Svaret:**

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

### Med variabeler

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

### Insatta frågor

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

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

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

### Ett exempel på JavaScript-client

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

### Fehler i hantering

GraphQL fel kommer tillbaka i standardformat:

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

### Hur det fungerar

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

### Nyckliga fördelar

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

### Att testa GraphQL

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

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

Se den [GraphQL exempel i LLMApi.http](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMApi/LLMApi.http#L229-L294) för kompletta arbetsexempler.

### GraphQL Konfiguration

#### Symbolgränser och modellselektion

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

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

**Tokengränsregler:**

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

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

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

**För komplexa nestede frågor:**

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

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

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

## SignalR Real-Time Data Streaming

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

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

### Vinnig Start med SignalR

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

**1. Minimal SignalR-only setupM SK2**

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

**Optionellt: Lägg till REST API också**

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

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

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

**2. Konfigurera i appsettings**

```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. Anslut från klient**

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

### Hub Kontext Konfiguration

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

```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: Använd enkla engelska förklaringar**

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

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

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

### Dynamiska Kontextkreationer API

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

#### Att skapa ett sammanhang

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

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

Svaret:

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

#### Lyssna alla sammanhang

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

Svaret:

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

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

#### få en specifik kontext

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

Svaret:

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

#### Lösa Kontext

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

Svaret:

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

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

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

Svaret:

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

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

#### Stopp Kontext (Pause Data Generation

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

Svaret:

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

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

### Complierade Clientexampla

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

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

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

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

### Dynamisk Kontextkreation från gränssnittet

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

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

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

### SignalR Hub-metoder

Den `MockLlmHub` stödjer de följande metoderna:

**SubscribeToContext(string context**

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

**Abonnement från Kontext(string context)**

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

**Erfarenheter som client fått:**

**DataUpdate** - innehåller genererade modelldata

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

**Abonnerad** - Bekräftelse av ګډون

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

**Otillskriven** - Bekräftelse på avkommelse

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

### Konfigurationsoptioner

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

### JSON Schema-stöd

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

**Enkel form:**

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

**JSON-schema:**

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

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

### Arkitektur

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

**Komponenter:**

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

### Använd fall

**1. Taskbord-prototyping**

```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. IoT-simulation**

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

**3. Finansdata**

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

**4. Gaming-ledandebord**

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

### Kontextlivskedjans hantering

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

Varje kontext har följande egenskaper:

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

Kontexter kan vara i två tillstånd

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

**Nyckliga egenskaper:**

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

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

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

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

**exempel arbetsflöde:**

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

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

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

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

## OpenAPI / Swagger Mock Generation

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

### Vinnig Start med OpenAPI

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

**Programm .cs:**

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

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

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

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

app.Run();
```

**appsettings.json:**

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

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

### Hur det fungerar

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

### Konfigurationsoptioner

Varje OpenAPI specifikation supporterar dessa konfigurationsoptioner:

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

### avancerade konfigurationsexempler

**Filter av tag:**

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

**Filter genom vägar:**

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

**Aktivera strömningar:**

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

### Att testa OpenAPI-mocks

Given this OpenAPI spec configuration:

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

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

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

### Modulära användning

OpenAPI-modeller fungerar oberoende av REST

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

### Ondersteunde Specformat

- **OpenAPI 3.0** (JSON eller YAML
- **OpenAPI 3.1** (JSON eller YAML
- **Swagger 2.0** (JSON eller YAML

### Nyckliga egenskaper

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

### Använd fall

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

### Begränsningar

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

### Att testa OpenAPI-Management

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

**Spec-Management**:

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

**Endpunkttesting**:

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

**avancerade arbetsflöden**:

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

**Ett exempel från ledning.http**:

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

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

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

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

Se den kompletta [ledning.http](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LLMApi/management.http) file for 20+ ready

### Demo-applikationer

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

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

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

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

**Features:**

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

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

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

---


#### Web-baserade demo

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

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

**Features:**

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

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

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

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

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

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

**Features:**

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

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

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

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

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

**Nyhet** Interaktivt OpenAPI specifikationsmanagement med reala versioner

**Features:**

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

**Quick-Startexamples:**

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

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

**kör demonstrationen:**

```bash
cd LLMApi
dotnet run
```

Navigera till:

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

Alla demoer inkluderar:

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

## avancerade egenskaper

### Response Schema Echo (Form ) Export

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

Konfiguration:

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

exempel:

- Aktivera globalt (appsettings.jsonM SK2

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

- Aktivera per begäran (överrider config):

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

Svaret inkluderar opskrifte:

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

- Streaming: slutakten innehåller schemafältet när det är aktiverat

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

Märkter:

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

Använd fall:

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

### Custom prompt-templates

Oorskryf de standardintrycken med din egen

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

Möjliga platshalter:

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

### Fehlersimulation

Testa din klient's handling av fel med komplexa felsimulationsskapaciteter

**Fyra sätt att konfigurera fel** ( i precedensordning

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

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

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

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

2. **HTTP-Header**:

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

3. **Form JSON** (användande `$error` egendom):

```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. **Benomfattande organ** (användande `error` egendom):

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

**Frågliga responsformat:**

Regular/Streaming slutpunkter :

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

GraphQL slutpunkt:

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

**SignalR-Fehlersimulation:**

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

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

Eller dynamiskt via administrationsAPI:

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

**Ondersteunde HTTP statuskoder:**

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

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

Passforms meddelanden och detaljer överrider de standarden.

**Använd fall:**

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

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

### Flera instanser

Mounta flera mock APIs med olika konfigurationer:

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

## Specifikation för form

Tre sätt att kontrollera reaktionsstrukturen:

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

### Att kassera flera svar via form

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

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

exempel

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

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

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

Konfiguration

- MaxCachePerKey (int

Beteckningar

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

## Testing

### Testing Utilities Package (NEW!)

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

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

**Ett kort exempel:**

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

**Nyckliga egenskaper:**

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

**Konfigurationsexempler:**

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

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

**Se den [Testande paket README](https://github.com/scottgal/LLMApi/blob/refs/heads/master/mostlylucid.mockllmapi.Testing/README.md) för komplett dokumentation och exempel.**

### HTTP-Dateitestning

Använd det inkluderade `LLMApi.http` file with:

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

### Unittests

Projektet inkluderar komplexa unittestar:

```bash
# Run all tests
dotnet test

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

**Omfattningen av tester (228 tester, 100% passgrad**

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

**Ny i v2.3.0:**

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

Se [EST_SUMMARY.md](https://github.com/scottgal/LLMApi/blob/refs/heads/master/TEST_SUMMARY.md) för komplett testdokumentation och omfattningsmått

## Arkitektur

Se [Arkitektur överblick](#architecture-overview) ovanför systemdiagrammet och komponentbeschreibungen på hög nivå

### Den detaljerade begäranströmmen

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

### Flöd för formkontroll

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

**Projekt:**

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

## Varför använda mestlucid.mockllmapi?

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

## Att bygga NuGet-paketet

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

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

## Att bidra

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

## Licens

Detta är fri och obekväm programvara som släppts i den offentliga Domainen. Se [LICENSE](https://github.com/scottgal/LLMApi/blob/refs/heads/master/LICENSE) för detaljer eller besök [utan tillstånd.org](https://unlicense.org).