# LLMApi: gRPC Mock API Support with Protocol Buffers

# Введение

Це документація для підтримки API gRPC Mock в LLMApi.

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

> NOTA: Це живі дані з GitHub. Це генероване штучним інтелектом

[![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 ](https://github.com/scottgal/LLMApi)для проекту, всі громадські домени і т.д.

# gRPC Mock API Obsługа з протоколними буферами

LLMock API тепер надає повну підтримку gRPC,, що дозволяє вам динамічно моделювати сервіси gR PC без написання будь-яких застосувань `.proto` файли, і модельний сервер обробляє решту -, генеруючи реальні відповіді на основі визначення ваших Protobuf повідомлень

## Перегляньмо

Funkція gRPC підтримує два доповнювані підходи:

1. **JSON над HTTP** - Чудово для веб-браузера -на основі тестування та швидкого створення прототипу
2. **Буфери бінарного протоколу** - Справжний gRPC дротий протокол для виробництва - подібне тестування з реальними gR PC клієнтами

Обидві підходи використовують те ж саме завантажене `.proto` definitions and LLM-generated responses , giving you flexibility in how you test

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

## Швидкий старт

### 1. Завантаження протофайла

Перше, визначає вашу службу gRPC в `.proto` файл:

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

завантажити цей протоклікат до mock серверу:

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

Відповідь показує структуру вашої служби:

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

### 2. Metodи вызову - JSON над HTTP

Для швидкого тестування та перегляду браузера-засаджені клієнтиM SK1 використовують кінцеві точки JSON:

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

LLM генерує реальну відповідь, яка відповідає вашій прото-дефіціції:

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

### 3. Методи вызову - Буфери бінарного протоколу

Для виробництва- подібні тестування з справжнім протоколом дроту gRPCM SK1

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

Виход:

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

## Як це працює

### Прото-аналізування файлів

Коли ви завантажуєте `.proto` файл, модельний сервер розшифровує його для отриманняM SK1

- Definiції послуг
- Signatures методу RPC
- Для визначення типу повідомлення
- Типи та числа поля

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

Розшифровувач використовує екстракцію на основі regex-, щоб визначити прото-елементиM SK1

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

### Запрос обладнання потоком

#### Концільні точки JSON

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

Рухівник створює детальний про prompt для 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.";
```

#### Бінарні Protobuf кінцеві точки

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

### Серіалізація буферів протоколу

І `DynamicProtobufHandler` конвертує JSON в бінарний формат Protobuf, використовуючи визначення поля:

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

Типи проводів визначаються типом поля:

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

## Administrаційний інтерфейс

Funkція gRPC включає в себе повний інтерфейс управління для роботи з прото-дефиниціями:

### Список всіх проток

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

Відповідь:

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

### Получить подробиці прото

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

Вказує повні деталі, включно з усіма службами, методамиМSK1 повідомленнямM SK2 і визначеннями поля.

### Поletes Proto

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

### Виczyść всі протоси

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

## Довідка про кінцеві точки API

### Прото-менеджментні кінцеві точки

| Metodа МSK1 кінцевий пункт МSK2 опис |
|--------|----------|-------------|
| `POST` | `/api/grpc-protos` | Завантаження файла протоколу . МSK2 Plain text or multipart form МSK3 \ |
| `GET` | `/api/grpc-protos` | Список всіх завантажених прото-дефиницій МSK1
| `GET` | `/api/grpc-protos/{name}` | Получить подробиці конкретного прото |
| `DELETE` | `/api/grpc-protos/{name}` | Поletes a specific proto definition
| `DELETE` | `/api/grpc-protos` | Виczyść всі прото-дефиниції

### Кондитори дзвінків до Служби gRPC

| Metodа МSK1 кінцевий пункт МSK2 опис |
|--------|----------|-------------|
| `POST` | `/api/grpc/{service}/{method}` | Використовувати метод з проханням JSON
| `POST` | `/api/grpc/proto/{service}/{method}` | Ввімкніть метод з двойним проханням Protobuf МSK1відповідь МSK2

## Заawansовані приклади

### Складні вбудовані повідомлення

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

Зателефонувати за допомогою вбудованого 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"
    }
  }'
```

LLM генерує реальну реакцію на порядок з усіма заповненими полями.

### Повторювані поля та сукупності

Прото-аналізатор автоматично обробляє повторені поля:

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

Відповідь з численними вмонтованими массивами:

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

## Konfiguracja

Додайте підтримку gRPC до вашої ASP.NET Core aplikacji

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

І `AddLLMockApi()` метод автоматично региструє:

- `ProtoDefinitionManager` - Manages uploaded proto definitions
- `ProtoParser` - Розшифровує .proto файли
- `DynamicProtobufHandler` - Рухає серійизацією бінарного Protobuf
- `GrpcRequestHandler` - Обробляє виклики методу gRPC

## Текушні обмеження

### Тільки одинарні дзвінки

В даний час **лише одинарні дзвінки RPC** (проста просьбаM SK1відповідь). Методи потоку аналізовані, але ще не втілені

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

Намагання викликати метод потоку повертає błąd:

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

### Простіше Parsing Protobuf

Втілення бінарного Protobuf спрощене:

- **Прохання до аналізу**: В даний момент використовує шаблон JSON замість аналізу реального бінарного запиту Protobuf . Це працює для генерації реальних відповідей, але не підтверджує приchodzących бінарних даних

- **Серіалізація реагування**: Правильно серійизує JSON до бінарного формату Protobuf, відповідно до типів дротів та номерів поля .

Полне розшифровування запити потребує додаткової складності для обробки змінних-закодування довжиниM SK1 вбудовані повідомлення, і протоМSK3 domyślne .

### Поддержка Proto формату файлів

Розшифровувач підтримує звичайні прото3 властивості, але має обмеженняM SK1

**:**

- Початкові типи поля (stringM SK1 int32,int 64, uintMSC4 uINTMska5 boolM Ska6 floatMска7 doubleMSKA8 bytesMске9
- Повторювані поля
- Виборні поля
- Нестеровані повідомлення
- Услуги з одинарними методами

**Не підтримують:**

- Еноми (розшифровані, але не підтвердженіM SK1
- Карти (не застосованоM SK1
- Один із них (нерозшифрованийM SK1
- Поширення (нерозшифрованеM SK1
- Опції та аннотації (нехтований)
- Введення декларацій (не вирішеноM SK1

### Reflekція сервера gRPC (В процесі розвитку)

Стандартні клієнти gRPC очікують, що сервери будуть підтримувати [Протокол Reflection Сервера gRPC](https://github.com/grpc/grpc/blob/master/doc/server-reflection.md).

**Текучий стан:**

- Інфраструктура Reflection implemented using `protobuf-net.Reflection` МSK0v3.2.52)
- Прото-файли згенеровані на `FileDescriptorSet` при завантаженні
- `GrpcReflectionService` зберігає та управляє згортаними дескрипторами
- Інтеграція з `ProtoDefinitionManager` завершити

**Що працює?**

- Динамічна протокомбінація: завантажена `.proto` файли розшифровуються і комп 'ютеризовані в час запуску
- Утримка дескриптора: FileDescriptorObjekти набору генеруються і зберігаються в кэші
- Administrаційний API: `GET /api/grpc-protos` lista всіх завантажених прото-файлів з повними деталями
- Ядро JSON: Полне відкриття і тестування послуг за допомогою HTTP/JSON
- Дімострація: інтерактивний інтерфейс показує всі доступні послуги та методи

**Що відбувається?**

- Стандартне відображення кінцевих точок gRPC (`grpc.reflection.v1alpha.ServerReflection` сервіс)
- Полна інтеграція grpcurl без потреби `-proto` прапор

**Технічна Implementation:**

Коли ви завантажуєте `.proto` файл, системаM SK1

1. **Розглядає прото** за допомогою regex- `ProtoParser` для кінцевих точок JSON/HTTP
2. **Комп 'ютери для відображання** використовуючи протобуф `FileDescriptorSet`:
   ```csharp
   var fileSet = new FileDescriptorSet { ImportPath = { "." } };
   fileSet.Add(protoName, true, new StringReader(protoContent));
   fileSet.Process(); // Compiles the .proto file
   ```
3. **Перетворює дескриптори** між форматами protobuf-net і Google.Protobuf для зручності
4. **Поміщає обидві представлення** для підтримки протоколу dual-

**Найкращі варіанти**

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

**Чому не зробити це повністю?**

Протокол відображання gRPC потребує:

- Мапування `ServerReflection` Служба RPC для обробки відповідей на запитання
- Правильне застосування усіх методів відображання (ListServices, FileByFilenameM SK2 і т.д.
- Інтеграція з базою сервера ASP.NET Core gRPC

Базування вже на місці - комп 'ютеризовані протофайли, доступні дескриптори . Остання робота полягає в мапуванні кінцевого пункту рефракції і у тому, щоб гарантувати компромісність з інструментами, такими як grpcurl для відкриття сервісу МSK2

## Стратегії тестування

### Тестування браузера за допомогою JSON

Для швидкої ітерації під час розробки:

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

### Тестування інтеграції з бінарним

Для більш реалістичного тестування, що підходить до виробництва:

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

### Автоматичне тестування

Наприклад, тест xUnit:

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

## Подолання проблем

### Нездатність завантаження

**Симптом**: Помилка при завантаженні файла .proto

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

**Рішення**: Упевниться, що ' надсилає зміст прото-файлу правильно МSK2

- Як простий текст: `Content-Type: text/plain`
- Як багатокомпонентна форма: `Content-Type: multipart/form-data`

### Metodа не знайдена

**Симптом**:

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

**Рішення**:

1. Перевірити, що прото завантажено: `GET /api/grpc-protos`
2. Проверка точного співпадіння імен сервісу та методики (caseM SK1sensitive)
3. Упевниться, що тип методу не однозначний (не стрімуванняM SK1

### Неправильний JSON у відповідь

**Симптом**: LLM повертає неправильне JSON

Іноді це трапляється з складними вбудованими структурами. Модельний сервер намагається виділити JSON із LLM відповіді, але іноді LLM включає додаткові тексти або форматуванняM SK2

**Рішення**:

- Знову спробувати запити (LLM реагування варіуютьM SK1
- Простіша структура повідомлення
- Проверьте, чи LLM правильно налаштований в настроях

### Бінарні помилки Protobuf

**Симптом**: Бінарний кінцевий пункт повертає помилки або неправильні дані

**Рішення**:

- Перевірте, що ви - ' - правильно кодуєте запит `protoc`
- Проверьте, що Header Content-Type - це `application/grpc+proto`
- Упевниться, що прото-файл відповідає структурі повідомлення

## Рівень ефективності

### Прото-аналіз

Прото-файли розшифровуються після завантаження і зберігаються в пам 'яті.

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

### Заряди LLM

Кожен метод gRPC запускає LLM-запрос. Для високого рівняM SK1випробування об 'єму:

- Розглянемо Caching відповідей для однакових запитів
- Використовуйте функцію контексту для підтримки послідовності
- Регулювати LLM тайм-аут, якщо це необхідно

### Бінарна серійізація

Бінарна сеrialізація Protobuf додає мінімальної накладної витрати порівняно з JSON. Торгівля

- **JSON**: Швидша серійзація , легше виправлення
- **Бінарний**: Більш реалістичний , менші вантажі M SK2 справжній проводний протокол

## Дальне покращення

### Плановані характеристики

1. **Сервер стріминг** - Obsługа `returns (stream Response)` методи
2. **Client Streaming** - Obsługа `(stream Request) returns` методи
3. **Двоєсторонне стрімування** - Полне двоповерхове просування
4. **Reflekція gRPC** - Standard reflection protocol for tool compatibility
5. **Вимагати перевірки** - Розшифровує і підтверджує входні бінарні Protobuf запити
6. **Удосконалена прото підтримка** - Енуми , карти МSK2 один із них
7. **Caching реагування** - Опційне кэшування для детермінативних відповідей

### Допомагаючи

Знайшов błąd або хочеш зробити внесок? Переглянь репозитори GitHub для інструкцій щодо внеску.

## Підсумок

Функція mock API gRPC дає потужний спосіб тестувати сервіси gR PC, не впроваджуючи їх.

- завантажити .proto файли і негайно отримати робочі макетні послуги
- Вибирайте між JSON (convenienceM SK1 або бінарним Protobuf (realism)
- Згенеровані відповіді LLM- співпадають з вашими схемами повідомлень
- Полне управління API для прото-дефиницій
- Непоперечно інтегрується з існуючими функціями API LLMock

Неважливо, чи ви займаєтесь швидким переглядом браузера, тестуванням на основі -, чи створюєте комплексні тестові пакети для інтеграції. МSK2. Двойна поддержка JSON та бінарного забезпечення дає вам гнучкість в роботі, яка підходить вам найкраще.