Введение

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

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

Ви можете знайти Тут GitHub для проекту, всі громадські домени і т.д.

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

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 файл:

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 серверу:

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

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

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

# 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 генерує реальну відповідь, яка відповідає вашій прото-дефіціції:

{
  "id": 12345,
  "name": "Sarah Chen",
  "email": "[email protected]",
  "phone": "+1-555-0142",
  "created_at": "2024-03-15T10:30:00Z",
  "is_active": true
}

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

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

# 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

Виход:

id: 12345
name: "Sarah Chen"
email: "[email protected]"
phone: "+1-555-0142"
created_at: "2024-03-15T10:30:00Z"
is_active: true

Як це працює

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

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

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

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

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

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:

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 кінцеві точки

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, використовуючи визначення поля:

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

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

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 включає в себе повний інтерфейс управління для роботи з прото-дефиниціями:

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

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

Відповідь:

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

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

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

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

Поletes Proto

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

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

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

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

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

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

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

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

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:

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 генерує реальну реакцію на порядок з усіма заповненими полями.

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

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

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

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

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

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відповідь). Методи потоку аналізовані, але ще не втілені

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:

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

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

• Інфраструктура 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:

   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-

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

# 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

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

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

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

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

#!/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:

[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

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

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

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

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

Симптом:

{
  "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
• Упевниться, що прото-файл відповідає структурі повідомлення

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

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

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

// 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 та бінарного забезпечення дає вам гнучкість в роботі, яка підходить вам найкраще.