Pipeline: Add LLM and mocked user generation to the pipeline (#230)

2026-10-15 18:14:44 +00:00 · 2026-07-01 07:47:24 -04:00
parent 880f73e004
commit 2b8a900d12
90 changed files with 57254 additions and 800 deletions
--- a/tooling/pipeline/src/data_generation/llama/generate_brewery.cc
+++ b/tooling/pipeline/src/data_generation/llama/generate_brewery.cc
@@ -12,6 +12,7 @@
 #include <string_view>
 #include <vector>

+#include "data_generation/json_grammars.h"
 #include "data_generation/llama_generator.h"
 #include "data_generation/llama_generator_helpers.h"

@@ -32,19 +33,6 @@ static std::string FormatLocalLanguageCodes(
  return formatted;
 }

-// GBNF grammar for structured brewery JSON output.
-// @TODO move to a separate gbnf file if it grows in complexity or is shared
-// across modules.
-static constexpr std::string_view kBreweryJsonGrammar = R"json_brewery(
-root ::= thought-block "{" ws "\"name_en\"" ws ":" ws string ws "," ws "\"description_en\"" ws ":" ws string ws "," ws "\"name_local\"" ws ":" ws string ws "," ws "\"description_local\"" ws ":" ws string ws "}" ws
-thought-block ::= [^{]*
-ws ::= [ \t\n\r]*
-string ::= "\"" char+ "\""
-char ::= [^"\\\x7F\x00-\x1F] | [\\] escape
-escape ::= ["\\/bfnrt] | "u" hex hex hex hex
-hex ::= [0-9a-fA-F]
-)json_brewery";
-
 static constexpr int kBreweryInitialMaxTokens = 2800;

 BreweryResult LlamaGenerator::GenerateBrewery(
@@ -83,15 +71,14 @@ BreweryResult LlamaGenerator::GenerateBrewery(

  /**
   * RETRY LOOP with validation and error correction
-   * Attempts to generate valid brewery data up to 3 times, with feedback-based
-   * refinement
+   * Attempts to generate valid brewery data up to 3 times, with
+   * feedback-based refinement
   */
  constexpr int max_attempts = 3;
  std::string raw;
  std::string last_error;

  // Token budget: too small risks truncating valid JSON mid-string.
-  // Start conservatively but allow adaptive increases on truncation.
  int max_tokens = kBreweryInitialMaxTokens;

  // Limit output length to keep it concise and focused
@@ -104,7 +91,7 @@ BreweryResult LlamaGenerator::GenerateBrewery(
          {.level = LogLevel::Debug,
           .phase = PipelinePhase::BreweryAndBeerGeneration,
           .message = std::format("LlamaGenerator: raw output (attempt {}): {}",
-                      attempt + 1, raw)});
+                                  attempt + 1, raw)});
    }

    // Validate output: parse JSON and check required fields
@@ -120,8 +107,9 @@ BreweryResult LlamaGenerator::GenerateBrewery(
        logger_->Log(
            {.level = LogLevel::Info,
             .phase = PipelinePhase::BreweryAndBeerGeneration,
-             .message = std::format("LlamaGenerator: successfully generated brewery data on attempt {}",
-                        attempt + 1)});
+             .message = std::format("LlamaGenerator: successfully generated "
+                                    "brewery data on attempt {}",
+                                    attempt + 1)});
      }

      return brewery;
@@ -134,33 +122,38 @@ BreweryResult LlamaGenerator::GenerateBrewery(
      logger_->Log(
          {.level = LogLevel::Warn,
           .phase = PipelinePhase::BreweryAndBeerGeneration,
-           .message =
-               std::format("LlamaGenerator: malformed brewery JSON (attempt {}): {}",
+           .message = std::format(
+               "LlamaGenerator: malformed brewery JSON (attempt {}): {}",
               attempt + 1, *validation_error)});
    }

    // Update prompt with error details to guide LLM toward correct output.
    user_prompt = std::format(
        "Your previous response was invalid. Error: {}\nReturn the thought "
-        "process before the JSON if needed, then return ONLY valid JSON with "
-        "exactly these keys, in this exact order: {{\"name_en\": \"<English "
+        "process before the JSON if needed, then return ONLY valid JSON "
+        "with "
+        "exactly these keys, in this exact order: {{\"name_en\": "
+        "\"<English "
        "brewery name>\", \"description_en\": \"<English single-paragraph "
-        "description>\", \"name_local\": \"<local-language brewery name>\", "
+        "description>\", \"name_local\": \"<local-language brewery "
+        "name>\", "
        "\"description_local\": \"<local-language single-paragraph "
-        "description>\"}}.\nDo not include markdown, comments, extra keys, or "
-        "literal placeholder values.\n\nKeep the JSON strings concise enough "
+        "description>\"}}.\nDo not include markdown, comments, extra keys, "
+        "or "
+        "literal placeholder values.\n\nKeep the JSON strings concise "
+        "enough "
        "to fit within the token budget.\n\n{}",
        *validation_error, retry_location);
  }

  // All retry attempts exhausted: log failure and throw exception
  if (logger_) {
-    logger_->Log(
-        {.level = LogLevel::Error,
-         .phase = PipelinePhase::BreweryAndBeerGeneration,
-       .message = std::format(
-         "LlamaGenerator: malformed brewery response after {} attempts: {}",
-         max_attempts, last_error.empty() ? raw : last_error)});
+    logger_->Log({.level = LogLevel::Error,
+                  .phase = PipelinePhase::BreweryAndBeerGeneration,
+                  .message = std::format(
+                      "LlamaGenerator: malformed brewery "
+                      "response after {} attempts: {}",
+                      max_attempts, last_error.empty() ? raw : last_error)});
  }
  throw std::runtime_error("LlamaGenerator: malformed brewery response");
 }
--- a/tooling/pipeline/src/data_generation/llama/generate_user.cc
+++ b/tooling/pipeline/src/data_generation/llama/generate_user.cc
@@ -1,24 +1,115 @@
 /**
 * @file data_generation/llama/generate_user.cc
- * @brief Generates locale-aware user profiles with strict two-line formatting,
- * retry handling, and output sanitization for downstream parsing.
+ * @brief Builds persona/name-grounded user prompts, performs retry-based
+ * inference, and validates structured JSON output for user records.
 */

-
 #include <format>
+#include <optional>
+#include <stdexcept>
 #include <string>
+#include <string_view>

+#include "data_generation/json_grammars.h"
 #include "data_generation/llama_generator.h"
 #include "data_generation/llama_generator_helpers.h"

-// TODO: Implement locale-aware user profile generation.
-// Current implementation returns a hardcoded test value and ignores the
-// locale parameter. Future implementation should:
-// 1. Load a USER_GENERATION.md prompt template with locale context
-// 2. Perform LLM inference with locale-specific username/bio generation
-// 3. Parse and validate JSON output with retry handling (similar to brewery)
-// 4. Return locale-aware username and biography
-UserResult LlamaGenerator::GenerateUser(const std::string& locale) {
-  return {.username = "test_user",
-          .bio = std::format("This is a test user profile from {}.", locale)};
+static constexpr int kUserInitialMaxTokens = 1200;
+
+UserResult LlamaGenerator::GenerateUser(const EnrichedCity& city,
+                                        const UserPersona& persona,
+                                        const Name& name) {
+  std::string style_affinities;
+  for (const std::string& style : persona.style_affinities) {
+    if (!style_affinities.empty()) {
+      style_affinities += ", ";
+    }
+    style_affinities += style;
+  }
+
+  const std::string system_prompt = prompt_directory_->Load("USER_GENERATION");
+
+  std::string user_prompt = std::format(
+      "## NAME:\n\n{} {}\n\n"
+      "## GENDER:\n\n{}\n\n"
+      "## CITY:\n\n{}\n\n"
+      "## COUNTRY:\n\n{}\n\n"
+      "## PERSONA:\n\n{}\n\n"
+      "## PERSONA DESCRIPTION:\n\n{}\n\n"
+      "## STYLE AFFINITIES:\n\n{}",
+      name.first_name, name.last_name, name.gender, city.location.city,
+      city.location.country, persona.name, persona.description,
+      style_affinities);
+
+  const std::string retry_context = std::format(
+      "Name: {} {}\nCity: {}, {}\nPersona: {}", name.first_name, name.last_name,
+      city.location.city, city.location.country, persona.name);
+
+  constexpr int max_attempts = 3;
+  std::string raw;
+  std::string last_error;
+  int max_tokens = kUserInitialMaxTokens;
+
+  for (int attempt = 0; attempt < max_attempts; ++attempt) {
+    raw = this->Infer(system_prompt, user_prompt, max_tokens, kUserJsonGrammar);
+    if (logger_) {
+      logger_->Log(
+          {.level = LogLevel::Debug,
+           .phase = PipelinePhase::UserGeneration,
+           .message = std::format("LlamaGenerator: raw output (attempt {}): {}",
+                                  attempt + 1, raw)});
+    }
+
+    UserResult user;
+    const std::optional<std::string> validation_error =
+        ValidateUserJson(raw, user);
+
+    if (!validation_error.has_value()) {
+      if (logger_) {
+        logger_->Log(
+            {.level = LogLevel::Info,
+             .phase = PipelinePhase::UserGeneration,
+             .message = std::format("LlamaGenerator: successfully "
+                                    "generated user data on attempt {}",
+                                    attempt + 1)});
+      }
+
+      user.first_name = name.first_name;
+      user.last_name = name.last_name;
+      user.gender = name.gender;
+      return user;
+    }
+
+    last_error = *validation_error;
+    if (logger_) {
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::UserGeneration,
+                    .message = std::format(
+                        "LlamaGenerator: malformed user JSON (attempt {}): {}",
+                        attempt + 1, *validation_error)});
+    }
+
+    user_prompt = std::format(
+        "Your previous response was invalid. Error: {}\nReturn the thought "
+        "process before the JSON if needed, then return ONLY valid JSON "
+        "with "
+        "exactly these keys, in this exact order: {{\"username\": "
+        "\"<handle "
+        "derived from the given name>\", \"bio\": \"<first-person bio "
+        "grounded in the persona>\", \"activity_weight\": <number between "
+        "0 "
+        "and 1>}}.\nDo not include markdown, comments, extra keys, or "
+        "literal placeholder values.\n\n{}",
+        *validation_error, retry_context);
+  }
+
+  if (logger_) {
+    logger_->Log({.level = LogLevel::Error,
+                  .phase = PipelinePhase::UserGeneration,
+                  .message = std::format(
+                      "LlamaGenerator: malformed user response "
+                      "after {} attempts: {}",
+                      max_attempts, last_error.empty() ? raw : last_error)});
+  }
+  throw std::runtime_error("LlamaGenerator: malformed user response");
 }
--- a/tooling/pipeline/src/data_generation/llama/helpers.cc
+++ b/tooling/pipeline/src/data_generation/llama/helpers.cc
@@ -9,13 +9,16 @@
 #include <boost/json.hpp>
 #include <cctype>
 #include <optional>
+#include <span>
 #include <stdexcept>
 #include <string>
 #include <string_view>
 #include <vector>

+#include <llama.h>
+
 #include "data_generation/llama_generator_helpers.h"
-#include "llama.h"
+
 namespace {
 /**
 * String trimming: removes leading and trailing whitespace
@@ -76,7 +79,7 @@ bool ReadRequiredTrimmedStringField(const boost::json::object& obj,
  return !out.empty();
 }

-bool HasSchemaPlaceholder(const std::array<std::string*, 4>& values) {
+bool HasSchemaPlaceholder(std::span<std::string* const> values) {
  for (const std::string* value : values) {
    std::string lowered = *value;
    std::ranges::transform(lowered, lowered.begin(),
@@ -207,3 +210,58 @@ std::optional<std::string> ValidateBreweryJson(const std::string& raw,

  return std::nullopt;
 }
+
+std::optional<std::string> ValidateUserJson(const std::string& raw,
+                                            UserResult& user_out) {
+  boost::system::error_code error_code;
+  const std::string_view raw_view(raw);
+  const size_t opening_brace = raw_view.find('{');
+  if (opening_brace == std::string_view::npos) {
+    return "JSON parse error: missing opening brace '{'";
+  }
+
+  const std::string_view json_payload = raw_view.substr(opening_brace);
+  boost::json::value json_value = boost::json::parse(json_payload, error_code);
+  if (error_code) {
+    return "JSON parse error: " + error_code.message();
+  }
+
+  if (!json_value.is_object()) {
+    return "JSON root must be an object";
+  }
+
+  const auto& obj = json_value.get_object();
+  if (obj.size() != 3) {
+    return "JSON object must contain exactly three keys";
+  }
+
+  std::string validation_error;
+  if (!ReadRequiredTrimmedStringField(obj, "username", user_out.username,
+                                      &validation_error)) {
+    return validation_error;
+  }
+
+  if (!ReadRequiredTrimmedStringField(obj, "bio", user_out.bio,
+                                      &validation_error)) {
+    return validation_error;
+  }
+
+  const boost::json::value* activity_weight_field =
+      obj.if_contains("activity_weight");
+  if (activity_weight_field == nullptr || !activity_weight_field->is_number()) {
+    return "Missing or invalid numeric field: activity_weight";
+  }
+
+  const double activity_weight = activity_weight_field->to_number<double>();
+  if (activity_weight < 0.0 || activity_weight > 1.0) {
+    return "activity_weight must be between 0 and 1";
+  }
+  user_out.activity_weight = static_cast<float>(activity_weight);
+
+  const std::array schema_placeholders = {&user_out.username, &user_out.bio};
+  if (HasSchemaPlaceholder(schema_placeholders)) {
+    return "JSON appears to be a schema placeholder, not content";
+  }
+
+  return std::nullopt;
+}
--- a/tooling/pipeline/src/data_generation/llama/infer.cc
+++ b/tooling/pipeline/src/data_generation/llama/infer.cc
@@ -14,9 +14,10 @@
 #include <string_view>
 #include <vector>

+#include <llama.h>
+
 #include "data_generation/llama_generator.h"
 #include "data_generation/llama_generator_helpers.h"
-#include "llama.h"

 static constexpr size_t kPromptTokenSlack = 8;
 // Minimum tokens to keep when using top-p sampling. Ensures at least one
--- a/tooling/pipeline/src/data_generation/llama/llama_generator.cc
+++ b/tooling/pipeline/src/data_generation/llama/llama_generator.cc
@@ -11,8 +11,9 @@
 #include <stdexcept>
 #include <string>

+#include <llama.h>
+
 #include "data_model/models.h"
-#include "llama.h"

 static constexpr uint32_t kMaxContextSize = 32768U;

--- a/tooling/pipeline/src/data_generation/llama/load.cc
+++ b/tooling/pipeline/src/data_generation/llama/load.cc
@@ -10,9 +10,10 @@
 #include <string>
 #include <utility>

+#include <ggml-backend.h>
+#include <llama.h>
+
 #include "data_generation/llama_generator.h"
-#include "ggml-backend.h"
-#include "llama.h"

 // Maximum batch size for decode operations. Capping the batch prevents
 // excessive memory allocation while maintaining inference performance.
--- a/tooling/pipeline/src/data_generation/mock/deterministic_hash.cc
+++ b/tooling/pipeline/src/data_generation/mock/deterministic_hash.cc
@@ -14,3 +14,13 @@ size_t MockGenerator::DeterministicHash(const Location& location) {
  boost::hash_combine(seed, location.country);
  return seed;
 }
+
+size_t MockGenerator::DeterministicHash(const Location& location,
+                                        const UserPersona& persona,
+                                        const Name& name) {
+  size_t seed = DeterministicHash(location);
+  boost::hash_combine(seed, persona.name);
+  boost::hash_combine(seed, name.first_name);
+  boost::hash_combine(seed, name.last_name);
+  return seed;
+}
--- a/tooling/pipeline/src/data_generation/mock/generate_user.cc
+++ b/tooling/pipeline/src/data_generation/mock/generate_user.cc
@@ -1,22 +1,31 @@
 /**
 * @file data_generation/mock/generate_user.cc
- * @brief Generates deterministic mock user profiles by hashing locale values
- * into predefined username and bio collections.
+ * @brief Generates deterministic mock user profiles by hashing city, persona,
+ * and sampled name into predefined username and bio collections.
 */

-#include <functional>
-#include <string>
 #include <string_view>

 #include "data_generation/mock_generator.h"

-UserResult MockGenerator::GenerateUser(const std::string& locale) {
-  const size_t hash = std::hash<std::string>{}(locale);
+UserResult MockGenerator::GenerateUser(const EnrichedCity& city,
+                                       const UserPersona& persona,
+                                       const Name& name) {
+  const size_t hash = DeterministicHash(city.location, persona, name);

-  UserResult result;
  const std::string_view username = kUsernames[hash % kUsernames.size()];
  const std::string_view bio = kBios[hash / kBioHashStride % kBios.size()];
-  result.username = username;
-  result.bio = bio;
-  return result;
+  const float activity_weight =
+      static_cast<float>(hash / kActivityWeightHashStride %
+                         kActivityWeightHashRange) /
+      static_cast<float>(kActivityWeightHashRange);
+
+  return {
+      .first_name = name.first_name,
+      .last_name = name.last_name,
+      .gender = name.gender,
+      .username = std::string(username),
+      .bio = std::string(bio),
+      .activity_weight = activity_weight,
+  };
 }