# Unterstützung der gRPC Mock API mit Protokollpuffern

# Einleitung

Dies ist die Dokumentation für die gRPC Mock API-Unterstützung in LLMApi-.

<!--category-- AI, LLM, ASP.NET Core, API, gRPC, Protobuf, AI-Article, Nuget, mockllmapi-->
<datetime class="hidden">2025-11-06T00:30</datetime>

> HINWEIS:- Dies ist die Live von GitHub-.-Es wird KI erzeugt.

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

Sie können die[ GitHub hier ](https://github.com/scottgal/LLMApi)für das Projekt – alle öffentlichen Bereiche usw. –

# gRPC Mock API Unterstützung mit Protokollpuffern

LLMock API bietet jetzt umfassende gRPC-Unterstützung ., , so dass Sie gRPC-Dienste dynamisch zu verspotten, ohne irgendwelche Service-Implementierungen zu schreiben . `.proto` files., und der Mock-Server behandelt den Rest , um realistische Antworten basierend auf Ihren Protobuf-Meldungsdefinitionen zu generieren.

## Überblick

Das gRPC-Feature unterstützt zwei komplementäre Ansätze

1. **JSON über HTTP** Perfekt für Browser-Tests und schnelle Prototyping
2. **Binäre Protokollpuffer** Echtes gRPC-Drahtprotokoll für die Produktion - Tests mit echten GRPC Kunden

Beide Ansätze verwenden das gleiche hochgeladene `.proto` Definitionen und LLM---generierte Antworten, die Ihnen Flexibilität geben, wie Sie testen.

```mermaid
graph TD
    A[Upload .proto File] --> B[Proto Parser]
    B --> C[Service Definitions Stored]
    C --> D{Client Request Type?}
    D -->|JSON| E[JSON Endpoint]
    D -->|Binary Protobuf| F[Binary Endpoint]
    E --> G[LLM Generates Response]
    F --> G
    G --> H{Output Format?}
    H -->|JSON| I[Return JSON]
    H -->|Binary| J[Serialize to Protobuf]
    J --> K[Return Binary Response]
```

## Schnellstart

### Eine Proto-Datei hochladen

Definieren Sie zuerst Ihren gRPC-Dienst in einem `.proto` Datei„ :"

```protobuf
syntax = "proto3";

package userservice;

service UserService {
  rpc GetUser (GetUserRequest) returns (User);
  rpc ListUsers (ListUsersRequest) returns (UserList);
  rpc CreateUser (CreateUserRequest) returns (User);
}

message GetUserRequest {
  int32 user_id = 1;
}

message ListUsersRequest {
  int32 page = 1;
  int32 page_size = 2;
  optional string filter = 3;
}

message CreateUserRequest {
  string name = 1;
  string email = 2;
  optional string phone = 3;
}

message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
  optional string phone = 4;
  string created_at = 5;
  bool is_active = 6;
}

message UserList {
  repeated User users = 1;
  int32 total_count = 2;
  int32 page = 3;
}
```

Laden Sie diese Proto-Datei auf den Mock-Server.

```bash
# Upload via plain text body
curl -X POST http://localhost:5116/api/grpc-protos \
  -H "Content-Type: text/plain" \
  --data-binary "@user_service.proto"

# Or upload as multipart form
curl -X POST http://localhost:5116/api/grpc-protos \
  -F "file=@user_service.proto"
```

Die Antwort zeigt Ihre Service-Struktur

```json
{
  "message": "Proto definition uploaded successfully",
  "name": "user_service.proto",
  "package": "userservice",
  "services": [
    {
      "name": "UserService",
      "methods": [
        {
          "name": "GetUser",
          "type": "Unary",
          "input": "GetUserRequest",
          "output": "User"
        },
        {
          "name": "ListUsers",
          "type": "Unary",
          "input": "ListUsersRequest",
          "output": "UserList"
        },
        {
          "name": "CreateUser",
          "type": "Unary",
          "input": "CreateUserRequest",
          "output": "User"
        }
      ]
    }
  ]
}
```

### Anrufverfahren . . - . JSON über HTTP

Für schnelles Testen und Browser-basierte Clients verwenden Sie die JSON-Endpunkte.

```bash
# Get a user (JSON request/response)
curl -X POST http://localhost:5116/api/grpc/UserService/GetUser \
  -H "Content-Type: application/json" \
  -d '{"user_id": 12345}'
```

Das LLM erzeugt eine realistische Antwort passend zu Ihrer Proto-Definition.

```json
{
  "id": 12345,
  "name": "Sarah Chen",
  "email": "sarah.chen@techcorp.com",
  "phone": "+1-555-0142",
  "created_at": "2024-03-15T10:30:00Z",
  "is_active": true
}
```

### Anrufverfahren ---Binäre Protokollpuffer

Für die Produktion - --ähnliche Prüfung mit echtem gRPC Drahtprotokoll - MSC1-

```bash
# Create a binary Protobuf request (example using protoc)
echo '{"user_id": 12345}' | \
  protoc --encode=userservice.GetUserRequest user_service.proto > request.bin

# Send binary request, get binary response
curl -X POST http://localhost:5116/api/grpc/proto/UserService/GetUser \
  -H "Content-Type: application/grpc+proto" \
  --data-binary "@request.bin" \
  --output response.bin

# Decode binary response
protoc --decode=userservice.User user_service.proto < response.bin
```

Ausgabe„ :"

```protobuf
id: 12345
name: "Sarah Chen"
email: "sarah.chen@techcorp.com"
phone: "+1-555-0142"
created_at: "2024-03-15T10:30:00Z"
is_active: true
```

## Wie es funktioniert

### Protokolldatei Parsing

Wenn Sie eine `.proto` Die Datei Mock Server parsiert sie, um zu extrahieren

- Begriffsbestimmungen für Dienstleistungen
- Signaturen der RPC-Methode
- Definitionen des Nachrichtentyps
- Feldtypen und -nummern

```mermaid
sequenceDiagram
    participant Client
    participant ProtoManager
    participant ProtoParser
    participant Storage

    Client->>ProtoManager: Upload user_service.proto
    ProtoManager->>ProtoParser: Parse(content)
    ProtoParser->>ProtoParser: Extract syntax/package
    ProtoParser->>ProtoParser: Parse services
    ProtoParser->>ProtoParser: Parse messages
    ProtoParser->>ProtoManager: Return ProtoDefinition
    ProtoManager->>Storage: Store in ConcurrentDictionary
    ProtoManager->>Client: Return success + metadata
```

Der Parser verwendet regex-basierte Extraktion, um Protoelemente zu identifizieren.

```csharp
// Service extraction
var serviceRegex = new Regex(
    @"service\s+([a-zA-Z0-9_]+)\s*\{([^}]+)\}",
    RegexOptions.Singleline);

// Method extraction
var methodRegex = new Regex(
    @"rpc\s+([a-zA-Z0-9_]+)\s*\(\s*(stream\s+)?([a-zA-Z0-9_.]+)\s*\)" +
    @"\s*returns\s*\(\s*(stream\s+)?([a-zA-Z0-9_.]+)\s*\)");

// Message extraction
var messageRegex = new Regex(
    @"message\s+([a-zA-Z0-9_]+)\s*\{([^}]+)\}",
    RegexOptions.Singleline);
```

### Antrag auf Bearbeitungsfluss

#### JSON-Endpunkte

```mermaid
sequenceDiagram
    participant Client
    participant Endpoint
    participant GrpcHandler
    participant ProtoManager
    participant LLM

    Client->>Endpoint: POST /api/grpc/UserService/GetUser<br/>(JSON body)
    Endpoint->>ProtoManager: FindMethod(UserService, GetUser)
    ProtoManager->>Endpoint: Return method definition
    Endpoint->>GrpcHandler: HandleUnaryCall(service, method, json)
    GrpcHandler->>ProtoManager: GetMessage(User)
    ProtoManager->>GrpcHandler: Return message schema
    GrpcHandler->>GrpcHandler: Build LLM prompt with schema
    GrpcHandler->>LLM: Generate response for User message
    LLM->>GrpcHandler: Return JSON response
    GrpcHandler->>Endpoint: Extract and return JSON
    Endpoint->>Client: JSON response
```

Der Handler baut eine detaillierte Eingabeaufforderung für das LLM-:

```csharp
var prompt = $@"You are a gRPC service mock. Generate realistic data for this response.

Service: {serviceName}
Method: {methodName}
Request: {requestJson}

Generate a response matching this structure:
{jsonShape}

Return ONLY valid JSON matching the structure above. Be creative with realistic values.";
```

#### Binary Protobuf Endpunkte

```mermaid
sequenceDiagram
    participant Client
    participant Endpoint
    participant GrpcHandler
    participant ProtobufHandler
    participant LLM

    Client->>Endpoint: POST /api/grpc/proto/UserService/GetUser<br/>(Binary Protobuf)
    Endpoint->>GrpcHandler: HandleUnaryCallBinary(service, method, bytes)
    GrpcHandler->>ProtobufHandler: CreateJsonTemplate(inputMessage)
    ProtobufHandler->>GrpcHandler: Return JSON template
    GrpcHandler->>LLM: Generate response (same as JSON flow)
    LLM->>GrpcHandler: Return JSON response
    GrpcHandler->>ProtobufHandler: SerializeFromJson(json, outputMessage)
    ProtobufHandler->>ProtobufHandler: Write Protobuf binary format
    ProtobufHandler->>GrpcHandler: Return binary bytes
    GrpcHandler->>Endpoint: Return binary Protobuf
    Endpoint->>Client: Binary response (application/grpc+proto)
```

### Protokoll Puffer Serialisierung

Das `DynamicProtobufHandler` konvertiert JSON in binäres Protobuf-Format mit Felddefinitionen

```csharp
public byte[] SerializeFromJson(
    string json,
    ProtoMessage messageDefinition,
    List<ProtoMessage> allMessages)
{
    var jsonDoc = JsonDocument.Parse(json);
    using var stream = new MemoryStream();
    using var writer = new CodedOutputStream(stream);

    // Write each field according to proto definition
    foreach (var field in messageDefinition.Fields.OrderBy(f => f.Number))
    {
        if (!jsonDoc.RootElement.TryGetProperty(field.Name, out var fieldValue))
            continue; // Skip missing fields

        WriteField(writer, field, fieldValue, allMessages);
    }

    writer.Flush();
    return stream.ToArray();
}
```

Drahttypen werden durch den Feldtyp bestimmt.

```csharp
private WireFormat.WireType GetWireType(string fieldType)
{
    return fieldType switch
    {
        "string" or "bytes" => WireFormat.WireType.LengthDelimited,
        "int32" or "int64" or "uint32" or "uint64" or
        "sint32" or "sint64" or "bool" => WireFormat.WireType.Varint,
        "fixed32" or "sfixed32" or "float" => WireFormat.WireType.Fixed32,
        "fixed64" or "sfixed64" or "double" => WireFormat.WireType.Fixed64,
        _ => WireFormat.WireType.LengthDelimited // Complex/nested types
    };
}
```

## Management-API

Das gRPC-Feature enthält eine vollständige Management-API für die Arbeit mit Protodefinitionen.

### Alle Protos auflisten

```bash
curl http://localhost:5116/api/grpc-protos
```

Ansprechrate

```json
{
  "definitions": [
    {
      "name": "user_service.proto",
      "package": "userservice",
      "syntax": "proto3",
      "uploadedAt": "2025-01-05T20:30:00Z",
      "serviceCount": 1,
      "messageCount": 5,
      "services": ["UserService"]
    }
  ],
  "count": 1
}
```

### Proto Details erhalten

```bash
curl http://localhost:5116/api/grpc-protos/user_service.proto
```

Gibt vollständige Details einschließlich aller Dienste zurück.

### Proto löschen

```bash
curl -X DELETE http://localhost:5116/api/grpc-protos/user_service.proto
```

### Alle Protos löschen

```bash
curl -X DELETE http://localhost:5116/api/grpc-protos
```

## API-Endpunktereferenz

### Endpunkte des Proto-Managements

Verfahren zur Bestimmung des Endpunkts
|--------|----------|-------------|
| `POST` | `/api/grpc-protos` Hochladen einer Datei mit einem Text oder mehreren Teilen von )
| `GET` | `/api/grpc-protos` Alle hochgeladenen Proto-Definitionen auflisten
| `GET` | `/api/grpc-protos/{name}` Details zu einem bestimmten Proto erhalten
| `DELETE` | `/api/grpc-protos/{name}` Löschen einer bestimmten Proto-Definition
| `DELETE` | `/api/grpc-protos` Alle Proto-Definitionen löschen

### gRPC Service Call Endpunkte

Verfahren zur Bestimmung des Endpunkts
|--------|----------|-------------|
| `POST` | `/api/grpc/{service}/{method}` Methode mit JSON-Anforderung aufrufen
| `POST` | `/api/grpc/proto/{service}/{method}` Methode zur Invoke-Methode mit binärer Protobuf-Anfrage

## Erweiterte Beispiele

### Komplexe verschachtelte Nachrichten

```protobuf
syntax = "proto3";

package orderservice;

service OrderService {
  rpc CreateOrder (OrderRequest) returns (Order);
}

message OrderRequest {
  string customer_id = 1;
  repeated OrderItem items = 2;
  Address shipping_address = 3;
  PaymentInfo payment = 4;
}

message OrderItem {
  string product_id = 1;
  int32 quantity = 2;
  double unit_price = 3;
}

message Address {
  string street = 1;
  string city = 2;
  string state = 3;
  string postal_code = 4;
  string country = 5;
}

message PaymentInfo {
  string method = 1;
  string last_four_digits = 2;
}

message Order {
  string order_id = 1;
  string customer_id = 2;
  repeated OrderItem items = 3;
  Address shipping_address = 4;
  string status = 5;
  double total_amount = 6;
  string created_at = 7;
}
```

Anruf mit verschachtelten JSON-:

```bash
curl -X POST http://localhost:5116/api/grpc/OrderService/CreateOrder \
  -H "Content-Type: application/json" \
  -d '{
    "customer_id": "CUST-12345",
    "items": [
      {
        "product_id": "PROD-001",
        "quantity": 2,
        "unit_price": 29.99
      },
      {
        "product_id": "PROD-042",
        "quantity": 1,
        "unit_price": 149.99
      }
    ],
    "shipping_address": {
      "street": "123 Main Street",
      "city": "San Francisco",
      "state": "CA",
      "postal_code": "94102",
      "country": "USA"
    },
    "payment": {
      "method": "credit_card",
      "last_four_digits": "4242"
    }
  }'
```

Das LLM erzeugt eine realistische Ordnungsreaktion mit allen verschachtelten Feldern, die bevölkert sind.

### Wiederholte Felder und Arrays

Der Proto Parser verarbeitet wiederholte Felder automatisch.

```protobuf
message ProductList {
  repeated Product products = 1;
  int32 total_count = 2;
}

message Product {
  string id = 1;
  string name = 2;
  double price = 3;
  repeated string tags = 4;
}
```

Antwort mit mehreren verschachtelten Arrays

```json
{
  "products": [
    {
      "id": "PROD-001",
      "name": "Wireless Mouse",
      "price": 29.99,
      "tags": ["electronics", "peripherals", "wireless"]
    },
    {
      "id": "PROD-002",
      "name": "Mechanical Keyboard",
      "price": 149.99,
      "tags": ["electronics", "peripherals", "gaming"]
    }
  ],
  "total_count": 47
}
```

## Einrichtung

Fügen Sie gRPC-Unterstützung zu Ihrer ASP..-NET Core-Anwendung hinzu.

```csharp
using mostlylucid.mockllmapi;

var builder = WebApplication.CreateBuilder(args);

// Add LLMock API services (includes gRPC)
builder.Services.AddLLMockApi(builder.Configuration);

var app = builder.Build();

// Map proto management endpoints
app.MapLLMockGrpcManagement("/api/grpc-protos");

// Map gRPC service call endpoints (both JSON and binary)
app.MapLLMockGrpc("/api/grpc");

app.Run();
```

Das `AddLLMockApi()` Methode registriert sich automatisch

- `ProtoDefinitionManager` Verwaltet hochgeladene Proto-Definitionen
- `ProtoParser` Parsen von .-Protodateien
- `DynamicProtobufHandler` Verwendet binäre Protobuf Serialisierung
- `GrpcRequestHandler` Verfahren der gRPC-Methode Anrufe

## Derzeitige Beschränkungen

### Nur Unary Calls

Die derzeitige Umsetzung unterstützt **nur unary RPC-Aufrufe** Die Streaming-Methoden sind parsed, aber noch nicht implementiert.

```protobuf
service DataService {
  // Supported
  rpc GetData (Request) returns (Response);

  // Not yet supported
  rpc StreamData (Request) returns (stream Response);
  rpc UploadData (stream Request) returns (Response);
  rpc BidirectionalStream (stream Request) returns (stream Response);
}
```

Versucht, eine Streaming-Methode zu aufrufen, gibt einen Fehler zurück.

```json
{
  "error": "Method StreamData is not a unary call. Type: ServerStreaming"
}
```

### Vereinfachtes Protobuf Parsing

Die binäre Protobuf-Implementierung wird vereinfacht

- **Parsing-Antrag**Aktuell verwendet eine JSON-Vorlage, anstatt die tatsächliche binäre Protobuf-Anforderung zu parsieren.Das funktioniert für realistische Antworten zu generieren, aber nicht die eingehenden Binärdaten zu validieren.

- **Serialisierung des Ansprechverhaltens**Genau serialisiert JSON zum binären Prototyp-Format nach Drahttypen und Feldnummern.

Vollständiges Request-Parsing würde zusätzliche Komplexität erfordern, um variablen Umgang mit -?Längenkodierung?

### Unterstützung für Proto-Dateiformat

Der Parser unterstützt gemeinsame Proto-Funktionen, hat aber Einschränkungen.

**Unterstützte :**

- Grundlegende Feldtypen (-String-,-Int.32,- Int.64,-Uint.32,-Uint. 64,-Bool-,-Float-MSC7-Double-,-Bytes)
- Wiederholte Felder
- Optionale Felder
- Verschachtelte Nachrichten
- Dienstleistungen mit einfachen Methoden

**Nicht unterstützt**

- Enums, geparst, aber nicht validiert
- Karten, die noch nicht implementiert sind
- Eines davon nicht parsiert
- Erweiterungen nicht parsiert
- Optionen und Anmerkungen
- Import-Anweisungen Nicht aufgelöst

### gRPC Server-Reflexion im Fortschritt

Standard gRPC-Clients erwarten, dass Server die [gRPC Server Reflektionsprotokoll](https://github.com/grpc/grpc/blob/master/doc/server-reflection.md).

**Aktueller Status**

- Reflektionsinfrastruktur unter Verwendung von `protobuf-net.Reflection` (-v-3.2.52)-
- Proto-Dateien werden zu kompiliert `FileDescriptorSet` beim Hochladen
- `GrpcReflectionService` speichert und verwaltet kompilierte Deskriptoren
- Integration mit `ProtoDefinitionManager` vollständig

**Was funktioniert?**

- Dynamische Proto-Compilation-Tools Hochgeladen `.proto` Dateien werden zur Laufzeit geparst und kompiliert
- Descriptor storage-DateiDescriptorSet Objekte werden generiert und zwischengespeichert
- Management-API-: `GET /api/grpc-protos` listet alle hochgeladenen Proto-Dateien mit vollständigen Details auf
- JSON-Endpunkt: Vollservice-Erkennung und -Test über HTTP-/.JSON
- Demoseite:-Interactive UI zeigt alle verfügbaren Dienste und Methoden

**Was ist im Fortschritt?**

- Standard gRPC-Reflektionsendpunkt Mapping`grpc.reflection.v1alpha.ServerReflection` Dienstleistungen
- Volle grpcurl Integration ohne Notwendigkeit `-proto` Flagge

**Technische Umsetzung**

Wenn Sie eine `.proto` Datei,- das System:-

1. **Parses das Proto** Verwendung von regex---basierten `ProtoParser` für JSON-/-HTTP-Endpunkte
2. **Zusammenstellungen zur Reflexion** Verwendung von Protobuf---net®.-Reflektionen `FileDescriptorSet`:
   ```csharp
   var fileSet = new FileDescriptorSet { ImportPath = { "." } };
   fileSet.Add(protoName, true, new StringReader(protoContent));
   fileSet.Process(); // Compiles the .proto file
   ```
3. **Umwandelt Deskriptoren** zwischen Protobuf-Formaten für die Kompatibilität
4. **Speichert beide Darstellungen** für Dual---Protokoll Unterstützung

**Aktuelle Workarounds**

```bash
# Provide proto file manually to grpcurl (always works)
grpcurl -proto yourfile.proto localhost:5116 list

# Use the JSON endpoint for testing (no grpcurl needed)
curl http://localhost:5116/api/grpc/UserService/GetUser \
  -H "Content-Type: application/json" \
  -d '{"user_id": 123}'

# Check available services via management API
curl http://localhost:5116/api/grpc-protos

# Use the interactive demo page at http://localhost:5116/Grpc
```

**Warum nicht vollständig?**

Das gRPC-Reflektionsprotokoll erfordert:

- Kartierung der `ServerReflection` RPC-Service zur Bearbeitung von Reflexionsabfragen
- Korrekte Umsetzung aller Reflexionsmethoden ListeServicesByFilename, usw..)
- Integration mit der Server-Infrastruktur von ASP-.-NET Core gRPC

Die Stiftung ist an Ort und Stelle.Die Protokolldateien sind kompiliert und es stehen Deskriptoren zur Verfügung.Die restlichen Arbeiten umfassen die Kartierung des Reflektionsserviceendpunktes und die Gewährleistung der Kompatibilität mit Tools wie grpcurl für Service-Discovery.

## Prüfstrategien

### Browser-Test mit JSON

Für schnelle Iteration während der Entwicklung

```javascript
// Fetch API in browser
async function getUser(userId) {
  const response = await fetch(`http://localhost:5116/api/grpc/UserService/GetUser`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ user_id: userId })
  });

  return await response.json();
}

const user = await getUser(12345);
console.log(user);
```

### Integrationstests mit Binär

Für realistischere Tests, die mit der Produktion übereinstimmen

```bash
#!/bin/bash

# Generate binary request
echo '{"user_id": 12345}' | \
  protoc --encode=userservice.GetUserRequest user_service.proto > request.bin

# Call binary endpoint
curl -X POST http://localhost:5116/api/grpc/proto/UserService/GetUser \
  -H "Content-Type: application/grpc+proto" \
  --data-binary "@request.bin" \
  --output response.bin

# Decode and verify
protoc --decode=userservice.User user_service.proto < response.bin

# Clean up
rm request.bin response.bin
```

### Automatisierte Prüfung

Beispiel xUnit test

```csharp
[Fact]
public async Task GrpcService_GetUser_ReturnsValidUser()
{
    // Arrange
    var protoContent = File.ReadAllText("user_service.proto");
    await _client.PostAsync("/api/grpc-protos",
        new StringContent(protoContent, Encoding.UTF8, "text/plain"));

    var request = new { user_id = 12345 };

    // Act
    var response = await _client.PostAsJsonAsync(
        "/api/grpc/UserService/GetUser", request);

    // Assert
    Assert.Equal(HttpStatusCode.OK, response.StatusCode);

    var user = await response.Content.ReadFromJsonAsync<JsonElement>();
    Assert.True(user.TryGetProperty("id", out _));
    Assert.True(user.TryGetProperty("name", out _));
    Assert.True(user.TryGetProperty("email", out _));
}
```

## Fehlerbehebung

### Proto-Upload fehlgeschlagen

**Symptome**Fehler beim Hochladen der Datei .

```json
{
  "error": "No proto content provided"
}
```

**Lösung**Vergewissern Sie sich, dass Sie den Proto-Dateiinhalt korrekt senden

- Als reiner Text `Content-Type: text/plain`
- Als mehrteilige Form `Content-Type: multipart/form-data`

### Methode nicht gefunden

**Symptome**:

```json
{
  "error": "Method UserService/GetUser not found. Upload proto file first."
}
```

**Lösung**:

1. Überprüfen Sie Proto wurde hochgeladen `GET /api/grpc-protos`
2. Prüfen Sie Service- und Methodennamen entsprechen genau (.case.-.sensitiv).
3. Vergewissern Sie sich, dass der Methodentyp unär ist.

### Ungültige JSON beim Ansprechen

**Symptome**LLM gibt missgebildete JSON zurück

Dies kann gelegentlich bei komplexen verschachtelten Strukturen auftreten.Der Mock-Server versucht JSON aus der LLM-Response zu extrahieren, aber manchmal enthält das LLM zusätzliche Texte oder Formatierungen.

**Lösung**:

- Wiederholen Sie die Anfrage Antworten variieren
- Vereinfachung der Nachrichtenstruktur
- Überprüfen Sie, ob das LLM korrekt in Appsettings konfiguriert ist

### Binary Prototyp Fehler

**Symptome**Binärer Endpunkt liefert Fehler oder fehlerhafte Daten zurück

**Lösung**:

- Überprüfen Sie die korrekte Codierung der Anfrage mit `protoc`
- Überprüfen Sie den Content-Header von - `application/grpc+proto`
- Stellen Sie sicher, dass die Proto-Datei mit der Nachrichtenstruktur übereinstimmt

## Leistungsbeurteilungen

### Protokoll-Parsing

Proto-Dateien werden einmal beim Hochladen geparst und im Speicher gespeichert.

```csharp
// Singleton storage
private readonly ConcurrentDictionary<string, ProtoDefinition> _definitions = new();
```

### LLM Anruf Overhead

Jeder Aufruf der gRPC-Methode löst eine LLM-Anfrage aus.

- Betrachten Sie Caching-Antworten für identische Anfragen
- Verwenden Sie das Kontext-Feature, um Konsistenz zu erhalten
- LLM-Timeout-Einstellungen bei Bedarf anpassen

### Binäre Serialisierung

Binary Protobuf Serialisierung fügt minimalen Overhead im Vergleich zu JSON-....

- **JSON**Schnellere Serialisierung – einfacheres Debuggen
- **Binärstoff**Weitere realistische Ergebnisse bei kleineren Nutzlasten

## Künftige Verbesserungen

### Geplante Merkmale

1. **Server-Streaming** Unterstützung für `returns (stream Response)` Methoden
2. **Client-Streaming** Unterstützung für `(stream Request) returns` Methoden
3. **Bidirektionales Streaming** Volles Duplex-Streaming
4. **gRPC Reflexion** Standard-Reflektionsprotokoll für Werkzeugkompatibilität
5. **Antrag auf Validierung** PARSE und validieren eingehende binäre Prototyp-Anfragen
6. **Verbesserte Proto-Unterstützung** Importe aus der EU
7. **Ansprech-Caching** Optionales Caching für deterministische Reaktionen

### Beitrag

Finden Sie einen Fehler oder möchten beitragen Überprüfen Sie das GitHub-Repository für Beitragsrichtlinien

## Zusammenfassung

Die gRPC-Mock API-Funktion bietet eine leistungsstarke Möglichkeit, gRPC-Dienste zu testen, ohne sie umzusetzen.

- Upload-Dateien und sofort Arbeits mock Dienstleistungen
- Wählen Sie zwischen JSON, (, Convenience, ) oder binären Prototypen.
- LLM.-.generierte Antworten entsprechen Ihren Nachrichtenschemas
- Vollständige Management-API für Proto-Definitionen
- Integriert nahtlos mit vorhandenen LLMock API-Funktionen

Egal ob Sie schnelles Browser-Testen oder das Bauen umfassender Integrationstestsuiten machen – der duale JSON und binäre Support gibt Ihnen die Flexibilität zu arbeiten, passt jedoch am besten zu Ihrem Workflow.