robot_lab 0.1.0 → 0.2.1

data/examples/15_memory_network_and_bus/output/windows_draft.md

@@ -1,7 +1,7 @@
 # win_writer Draft
 
-**Windows: The Ultimate Platform for Your Home AI Research Lab**
+Windows is the strongest all-around choice for a home AI research lab because it gives you the best combination of raw GPU support, hardware flexibility, and practical developer workflow. For LLM fine-tuning, image generation, and local inference, NVIDIA CUDA support on Windows is first-class: PyTorch, TensorFlow, xFormers, bitsandbytes, TensorRT, ONNX Runtime, and popular tools like Ollama, LM Studio, ComfyUI, AUTOMATIC1111, and Stable Diffusion WebUI all have strong Windows paths. If you want the highest-performance consumer GPUs for AI work, Windows pairs especially well with NVIDIA RTX hardware, from a single 4070 Ti Super up to multi-GPU prosumer setups. And if you need Linux-native scripts or package workflows, WSL2 gives you a near-seamless Ubuntu environment on the same machine, so you can run Hugging Face Transformers, PEFT, DeepSpeed, vLLM, llama.cpp, JupyterLab, and CUDA-enabled Linux tooling without giving up native Windows apps.
 
-When building a home AI research lab focused on LLM fine-tuning, image generation, and local inference, Windows stands as the unequivocally superior choice. The platform's **first-class NVIDIA CUDA support** provides seamless access to the full GPU acceleration stack that modern AI workloads demand. Unlike other operating systems that often require complex driver configurations or suffer from compatibility issues, Windows delivers out-of-the-box support for CUDA 12.x, cuDNN, and TensorRT—essential for frameworks like PyTorch, TensorFlow, and JAX that power cutting-edge models like Llama 2, Stable Diffusion XL, and Mistral. Microsoft's **DirectML** further enhances this ecosystem by enabling hardware-agnostic ML acceleration across AMD, Intel, and NVIDIA GPUs, giving you unparalleled flexibility in hardware selection. With **WSL2**, you get native Linux compatibility without sacrificing Windows' superior hardware support, allowing you to run containerized models via Docker or Podman while maintaining access to Windows-exclusive tools.
+Windows also wins on hardware compatibility and ecosystem breadth. A home lab often mixes gaming-class GPUs, high-core-count CPUs, fast NVMe storage, USB devices, capture cards, and sometimes unusual motherboard or networking gear; Windows consistently offers the widest driver support and easiest setup across that mix. Beyond CUDA, Windows also supports DirectML, which broadens acceleration options on AMD and Intel hardware for local inference and experimentation. On the tooling side, it integrates cleanly with Visual Studio Code, Visual Studio, Docker Desktop, PowerShell, Windows Terminal, Git for Windows, and enterprise-friendly tools for remote access, file sharing, backup, and virtualization. In practice, that means you can fine-tune a LoRA in WSL2, monitor GPUs with native Windows utilities, manage datasets on NTFS storage, launch ComfyUI or LM Studio from the desktop, and still have access to familiar scripting and automation.
 
-The Windows ecosystem excels in providing the **widest hardware compatibility** and vendor support in the industry. Whether you're deploying multiple RTX 4090s for distributed training, experimenting with Intel Arc GPUs for cost-effective inference, or scaling up to workstation-class Quadro cards, Windows ensures optimal driver support and performance tuning. The platform's enterprise-grade tooling integration shines for serious researchers: **Visual Studio Code** with GPU debugging extensions, **Weights & Biases** desktop integration, **Anaconda** with native Windows conda-forge packages, and seamless **Git LFS** support for managing large model checkpoints. Popular frameworks like **Hugging Face Transformers**, **ComfyUI** for Stable Diffusion workflows, and **text-generation-webui** for local LLM serving all provide superior Windows support with pre-compiled binaries and automated installers. The vibrant Windows AI community, centered around platforms like the AUTOMATIC1111 ecosystem and LM Studio, offers extensive documentation, troubleshooting resources, and model optimization guides specifically tailored to Windows environments—making your research journey both productive and well-supported.
+Just as important, Windows has massive community support for home AI builders. Most consumer AI guides now assume either native Windows or Windows plus WSL2, especially for Stable Diffusion workflows, local LLM front ends, and single-node fine-tuning recipes. Troubleshooting is easier when there are abundant guides for CUDA driver versions, PyTorch wheels, Flash Attention builds, and model-serving stacks on common RTX cards. For someone building a serious home AI lab, Windows offers the most practical balance: top-tier NVIDIA performance, Linux compatibility when you need it, broad hardware support, and a mature tool ecosystem that scales from casual experimentation to disciplined research workflows.

data/examples/16_writers_room/.envrc

@@ -0,0 +1 @@
+export ROBOT_LAB_TEMPLATE_PATH="${PWD}/prompts"

data/examples/16_writers_room/writers_room.rb

@@ -35,14 +35,12 @@
 ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
 
 require "json"
-require_relative "../../lib/robot_lab"
+require_relative "../common"
 require_relative "display"
 require_relative "tools"
 require_relative "room"
 require_relative "writer"
 
-RubyLLM.configure { |c| c.logger = Logger.new(File::NULL) }
-
 # ── Mode Descriptors ────────────────────────────────────────
 
 BOOK_MODE = {
@@ -128,7 +126,7 @@ FileUtils.mkdir_p(OUTPUT_DIR)
 display = Display.new(log_path: log_path)
 
 shared_config = RobotLab::RunConfig.new(
-  model: "claude-sonnet-4-5-20250929",
+  model: LLM[:default].model,
   temperature: 0.7
 )
 

data/examples/17_skills.rb

@@ -40,10 +40,7 @@
 #   ├── pii_redactor.md         — Leaf skill: redact PII
 #   └── audit_trail.md          — Leaf skill: audit metadata in every response
 
-# Configure template path before loading (MywayConfig reads env vars on init)
-ENV['ROBOT_LAB_TEMPLATE_PATH'] ||= File.join(__dir__, "prompts")
-
-require_relative "../lib/robot_lab"
+require_relative "common"
 
 # Send logger output to a file instead of stdout
 require 'logger'
@@ -120,10 +117,7 @@ ALERTS = [
 # Build the Incident Responder with Composable Skills
 # =============================================================================
 
-puts "=" * 70
-puts "RobotLab Skills Demo — SRE Incident Response System"
-puts "=" * 70
-puts
+banner "RobotLab Skills Demo — SRE Incident Response System"
 
 # Show the skill composition
 puts "Skill composition:"
@@ -142,6 +136,7 @@ puts
 # - sre_compliance:    Recursive skill — auto-expands to include pii_redactor
 #                      and audit_trail before its own compliance instructions
 responder = RobotLab.build(
+  model: LLM[:default].model,
   name: "incident_responder",
   template: :incident_responder,
   skills: [:runbook_protocol, :structured_output, :sre_compliance],
@@ -165,13 +160,13 @@ messages = chat.instance_variable_get(:@messages)
 system_msg = messages.find { |m| m.role.to_s == "system" }
 if system_msg
   prompt = system_msg.content
-  puts "-" * 70
+  hr
   puts "Assembled system prompt (#{prompt.length} chars, #{prompt.lines.count} lines):"
-  puts "-" * 70
+  hr
   prompt.lines.each_with_index do |line, i|
     puts "  %3d  %s" % [i + 1, line]
   end
-  puts "-" * 70
+  hr
 end
 
 # =============================================================================
@@ -179,6 +174,7 @@ end
 # =============================================================================
 
 plain_responder = RobotLab.build(
+  model: LLM[:default].model,
   name: "plain_responder",
   template: :incident_responder,
   context: {
@@ -202,11 +198,7 @@ end
 # =============================================================================
 
 ALERTS.each_with_index do |alert, index|
-  puts
-  puts "=" * 70
-  puts "Incident #{index + 1}: #{alert[:label]}"
-  puts "=" * 70
-  puts
+  section "Incident #{index + 1}: #{alert[:label]}"
 
   result = responder.run(alert[:data])
   content = result.output.first&.content.to_s
@@ -217,7 +209,6 @@ ALERTS.each_with_index do |alert, index|
   puts
 end
 
-puts "=" * 70
 puts
 puts <<~FOOTER
   This example demonstrates:

data/examples/18_rails/Gemfile

@@ -8,3 +8,4 @@ gem "puma", "~> 6.0"
 gem "turbo-rails", "~> 2.0"
 
 gem "robot_lab", path: "../.."
+gem "robot_lab-rails", path: "../../../robot_lab-rails"

data/examples/19_token_tracking.rb

@@ -20,9 +20,7 @@
 # Usage:
 #   ANTHROPIC_API_KEY=your_key ruby examples/19_token_tracking.rb
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
-
-require_relative "../lib/robot_lab"
+require_relative "common"
 
 # Anthropic claude-haiku-4-5 pricing (as of early 2026)
 HAIKU_INPUT_CPM  = 0.80   # $ per 1M input tokens
@@ -41,15 +39,12 @@ def first_line(text)
   text&.strip&.lines&.first&.strip || ""
 end
 
-puts "=" * 60
-puts "Example 19: Per-Robot Token & Cost Tracking"
-puts "=" * 60
-puts
+banner "Per-Robot Token & Cost Tracking"
 
 robot = RobotLab.build(
+  model: LLM[:default].model,
   name: "analyst",
-  system_prompt: "You are a concise technical analyst. Keep every reply under 40 words.",
-  model: "claude-haiku-4-5-20251001"
+  system_prompt: "You are a concise technical analyst. Keep every reply under 40 words."
 )
 
 prompts = [
@@ -71,7 +66,7 @@ prompts.each_with_index do |prompt, i|
   puts
 end
 
-puts "-" * 60
+hr
 puts "After #{prompts.size} runs:"
 puts "  Total tokens: #{token_summary(robot.total_input_tokens, robot.total_output_tokens)}"
 puts "  Total cost:   #{run_cost(robot.total_input_tokens, robot.total_output_tokens)}"
@@ -106,14 +101,14 @@ puts
 # To start truly fresh (new context, new counter), build a new robot.
 # ---------------------------------------------------------------
 
-puts "-" * 60
+hr
 puts "Fresh robot — genuinely zero context:"
 puts
 
 fresh = RobotLab.build(
+  model: LLM[:default].model,
   name: "analyst2",
-  system_prompt: "You are a concise technical analyst. Keep every reply under 40 words.",
-  model: "claude-haiku-4-5-20251001"
+  system_prompt: "You are a concise technical analyst. Keep every reply under 40 words."
 )
 
 result = fresh.run("What is memoization?")
@@ -123,6 +118,5 @@ puts "  This run:   #{token_summary(result.input_tokens, result.output_tokens)}"
 puts "  Cumulative: #{token_summary(fresh.total_input_tokens, fresh.total_output_tokens)}"
 puts
 
-puts "=" * 60
+hr
 puts "Token tracking demo complete."
-puts "=" * 60

data/examples/20_circuit_breaker.rb

@@ -25,9 +25,7 @@
 # Usage:
 #   ANTHROPIC_API_KEY=your_key ruby examples/20_circuit_breaker.rb
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
-
-require_relative "../lib/robot_lab"
+require_relative "common"
 
 # -------------------------------------------------------------------------
 # A tool that always says "more steps remain" — designed to induce looping
@@ -62,10 +60,7 @@ class MultiStepProcessor < RubyLLM::Tool
   end
 end
 
-puts "=" * 60
-puts "Example 20: Tool Loop Circuit Breaker"
-puts "=" * 60
-puts
+banner "Tool Loop Circuit Breaker"
 
 TASK = "Run the batch process from step 1 using the MultiStepProcessor tool. " \
        "Execute every step sequentially until the process reports 'complete'."
@@ -78,15 +73,14 @@ TASK = "Run the batch process from step 1 using the MultiStepProcessor tool. " \
 # history. Call clear_messages to flush the broken context before reuse.
 # -------------------------------------------------------------------------
 
-puts "--- Part 1: Circuit breaker fires (max_tool_rounds: 5) ---"
-puts
+section "Part 1: Circuit Breaker Fires (max_tool_rounds: 5)"
 
 robot = RobotLab.build(
+  model: LLM[:default].model,
   name: "process_runner",
   system_prompt: "You are a process runner. Execute tasks exactly as instructed.",
   local_tools: [MultiStepProcessor],
-  max_tool_rounds: 5,
-  model: "claude-haiku-4-5-20251001"
+  max_tool_rounds: 5
 )
 
 begin
@@ -106,8 +100,7 @@ puts
 # Only the conversation history is cleared — the robot is then reusable.
 # -------------------------------------------------------------------------
 
-puts "--- Part 2: Recover with clear_messages ---"
-puts
+section "Part 2: Recover with clear_messages"
 
 robot.clear_messages
 puts "Chat flushed. Robot config (tools, max_tool_rounds) is unchanged."
@@ -125,8 +118,7 @@ puts
 # not a tax on well-behaved tool interactions.
 # -------------------------------------------------------------------------
 
-puts "--- Part 3: No circuit breaker — task terminates naturally ---"
-puts
+section "Part 3: No Circuit Breaker — Task Terminates Naturally"
 
 class SingleStep < RubyLLM::Tool
   description "Doubles a number and returns the result immediately."
@@ -138,16 +130,15 @@ class SingleStep < RubyLLM::Tool
 end
 
 unguarded = RobotLab.build(
+  model: LLM[:default].model,
   name: "calculator",
   system_prompt: "Use the provided tool to answer questions.",
-  local_tools: [SingleStep],
-  model: "claude-haiku-4-5-20251001"
+  local_tools: [SingleStep]
 )
 
 result = unguarded.run("Double the number 21 using the tool.")
 puts "Result: #{result.reply&.strip}"
 puts
 
-puts "=" * 60
+hr
 puts "Circuit breaker demo complete."
-puts "=" * 60

data/examples/21_learning_loop.rb

@@ -19,9 +19,7 @@
 # Usage:
 #   ANTHROPIC_API_KEY=your_key ruby examples/21_learning_loop.rb
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
-
-require_relative "../lib/robot_lab"
+require_relative "common"
 
 SNIPPETS = [
   {
@@ -66,20 +64,17 @@ SNIPPETS = [
   }
 ].freeze
 
-puts "=" * 65
-puts "Example 21: Learning Accumulation Loop"
-puts "=" * 65
-puts
+banner "Learning Accumulation Loop"
 
 robot = RobotLab.build(
+  model: LLM[:default].model,
   name: "code_reviewer",
-  system_prompt: <<~PROMPT,
+  system_prompt: <<~PROMPT
     You are a concise Ruby code reviewer. For each snippet:
     1. Identify the main issue (one sentence).
     2. Show the improved version (code block).
     Keep responses under 80 words total.
   PROMPT
-  model: "claude-haiku-4-5-20251001"
 )
 
 SNIPPETS.each_with_index do |item, i|
@@ -88,7 +83,7 @@ SNIPPETS.each_with_index do |item, i|
   # ---------------------------------------------------------------
   # Show what learnings are active going into this run
   # ---------------------------------------------------------------
-  puts "--- Run #{run_number} ---"
+  section "Run #{run_number}"
   if robot.learnings.empty?
     puts "Learnings:  (none yet)"
   else
@@ -117,16 +112,14 @@ end
 # ---------------------------------------------------------------
 # Show the full accumulated learning list
 # ---------------------------------------------------------------
-puts "=" * 65
-puts "Accumulated learnings (#{robot.learnings.size} total):"
+section "Accumulated Learnings (#{robot.learnings.size} total)"
 robot.learnings.each_with_index { |l, i| puts "  #{i + 1}. #{l}" }
 puts
 
 # ---------------------------------------------------------------
 # Demonstrate superset dedup: a broader learning replaces narrower ones
 # ---------------------------------------------------------------
-puts "--- Deduplication demo ---"
-puts
+section "Deduplication Demo"
 robot2 = RobotLab.build(name: "reviewer2", system_prompt: "You review code.")
 
 robot2.learn("avoid using puts")
@@ -140,14 +133,13 @@ puts
 # Demonstrate persistence: learnings survive a robot rebuild using
 # the same Memory object
 # ---------------------------------------------------------------
-puts "--- Persistence across rebuild ---"
-puts
+section "Persistence Across Rebuild"
 
 shared_memory = robot.instance_variable_get(:@memory)
 rebuilt = RobotLab.build(
+  model: LLM[:default].model,
   name: "code_reviewer",
-  system_prompt: "You review code.",
-  model: "claude-haiku-4-5-20251001"
+  system_prompt: "You review code."
 )
 rebuilt.instance_variable_set(:@memory, shared_memory)
 
@@ -159,6 +151,5 @@ puts "Learnings on rebuilt robot (#{rebuilt.learnings.size}):"
 rebuilt.learnings.each_with_index { |l, i| puts "  #{i + 1}. #{l}" }
 puts
 
-puts "=" * 65
+hr
 puts "Learning loop demo complete."
-puts "=" * 65

data/examples/22_context_compression.rb

@@ -22,9 +22,7 @@
 # Usage:
 #   ANTHROPIC_API_KEY=your_key ruby examples/22_context_compression.rb
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
-
-require_relative "../lib/robot_lab"
+require_relative "common"
 
 # ---------------------------------------------------------------------------
 # Check optional dependency
@@ -47,15 +45,13 @@ def approx_tokens(messages)
   end
 end
 
-puts "=" * 60
-puts "Example 22: Context Window Compression"
-puts "=" * 60
-puts
+banner "Context Window Compression"
 
 # ---------------------------------------------------------------------------
 # Build a robot and simulate a long conversation on two topics
 # ---------------------------------------------------------------------------
 bot = RobotLab.build(
+  model: LLM[:default].model,
   name:          "assistant",
   system_prompt: "You are a concise Ruby expert. Reply in 2-3 sentences."
 )
@@ -157,12 +153,10 @@ puts
 # ---------------------------------------------------------------------------
 # Show the LLM summarizer pattern (not executed — requires API key)
 # ---------------------------------------------------------------------------
-puts "=" * 60
-puts "LLM summarizer pattern (requires API key):"
-puts "=" * 60
-puts <<~RUBY
-
+section "LLM Summarizer Pattern (requires API key)"
+show_code <<~RUBY
   summarizer_bot = RobotLab.build(
+    model: "gpt-5.4",
     name:          "summarizer",
     system_prompt: "Summarize the following text in one sentence."
   )
@@ -173,7 +167,6 @@ puts <<~RUBY
     drop_threshold:  0.2,
     summarizer:      ->(text) { summarizer_bot.run("Summarize: \#{text}").reply }
   )
-
 RUBY
 
 puts "Done."

data/examples/23_convergence.rb

@@ -19,9 +19,7 @@
 # Usage:
 #   ANTHROPIC_API_KEY=your_key ruby examples/23_convergence.rb
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
-
-require_relative "../lib/robot_lab"
+require_relative "common"
 
 # ---------------------------------------------------------------------------
 # Check optional dependency
@@ -34,10 +32,7 @@ rescue LoadError
   exit 1
 end
 
-puts "=" * 60
-puts "Example 23: Debate Convergence Detection"
-puts "=" * 60
-puts
+banner "Debate Convergence Detection"
 
 # ---------------------------------------------------------------------------
 # Similarity scoring
@@ -61,8 +56,7 @@ pairs = {
   ]
 }
 
-puts "Similarity scores:"
-puts "-" * 60
+section "Similarity Scores"
 pairs.each do |label, (a, b)|
   score = RobotLab::Convergence.similarity(a, b)
   converged = RobotLab::Convergence.detected?(a, b, threshold: 0.6)
@@ -74,11 +68,8 @@ end
 # ---------------------------------------------------------------------------
 # Router fast-path pattern
 # ---------------------------------------------------------------------------
-puts "=" * 60
-puts "Router fast-path pattern"
-puts "=" * 60
-puts <<~RUBY
-
+section "Router Fast-Path Pattern"
+show_code <<~RUBY
   # Two verifier robots run in parallel and store their replies in shared memory.
   # The router checks convergence before dispatching to the expensive reconciler.
 
@@ -100,14 +91,12 @@ puts <<~RUBY
   )
 
   result = network.run(message: "Is this claim accurate?")
-
 RUBY
 
 # ---------------------------------------------------------------------------
 # Demonstrate with simulated verifier outputs
 # ---------------------------------------------------------------------------
-puts "Simulating verifier fast-path:"
-puts "-" * 60
+section "Simulating Verifier Fast-Path"
 
 verifier_outputs = [
   {

data/examples/24_structured_delegation.rb

@@ -20,29 +20,27 @@
 # Usage:
 #   ANTHROPIC_API_KEY=your_key ruby examples/24_structured_delegation.rb
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
+require_relative "common"
 
-require_relative "../lib/robot_lab"
-
-puts "=" * 60
-puts "Example 24: Structured Delegation"
-puts "=" * 60
-puts
+banner "Structured Delegation"
 
 # ---------------------------------------------------------------------------
 # Build a manager and two specialist robots
 # ---------------------------------------------------------------------------
 manager = RobotLab.build(
+  model: LLM[:default].model,
   name:          "manager",
   system_prompt: "You are a project manager. Delegate tasks concisely."
 )
 
 summarizer = RobotLab.build(
+  model: LLM[:default].model,
   name:          "summarizer",
   system_prompt: "You are a concise summarizer. Produce a 1-2 sentence summary."
 )
 
 analyst = RobotLab.build(
+  model: LLM[:default].model,
   name:          "analyst",
   system_prompt: "You are a data analyst. Identify the key metric in one sentence."
 )
@@ -59,13 +57,12 @@ TEXT
 
 puts "Document:"
 puts document
-puts "-" * 60
+hr
 
 # ---------------------------------------------------------------------------
 # Synchronous delegation — sequential, blocks until each result arrives
 # ---------------------------------------------------------------------------
-puts "── Synchronous (sequential) ──────────────────────────────"
-puts
+section "Synchronous (sequential)"
 
 puts "Delegating to summarizer (blocking)..."
 summary_result = manager.delegate(to: summarizer, task: "Summarize this report:\n\n#{document}")
@@ -88,15 +85,16 @@ puts
 # ---------------------------------------------------------------------------
 # Asynchronous delegation — parallel fan-out, results collected later
 # ---------------------------------------------------------------------------
-puts "── Asynchronous (parallel fan-out) ───────────────────────"
-puts
+section "Asynchronous (parallel fan-out)"
 
 # Fresh robots — each delegate call should start from a clean slate
 async_summarizer = RobotLab.build(
+  model: LLM[:default].model,
   name:          "summarizer",
   system_prompt: "You are a concise summarizer. Produce a 1-2 sentence summary."
 )
 async_analyst = RobotLab.build(
+  model: LLM[:default].model,
   name:          "analyst",
   system_prompt: "You are a data analyst. Identify the key metric in one sentence."
 )
@@ -127,9 +125,7 @@ puts
 # ---------------------------------------------------------------------------
 # Contrast with the alternatives
 # ---------------------------------------------------------------------------
-puts "=" * 60
-puts "When to use delegate vs. the alternatives"
-puts "=" * 60
+section "When to Use delegate vs. the Alternatives"
 puts <<~TEXT
 
   bus messaging       — fire-and-forget; no return value; async

data/examples/25_history_search.rb

@@ -13,19 +13,14 @@
 # Usage:
 #   ruby examples/25_history_search.rb
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
-
 require "json"
-require_relative "../lib/robot_lab"
+require_relative "common"
 
 CONVERSATION_TURNS = File.readlines(
   File.join(__dir__, "25_history_search", "conversation.jsonl"), chomp: true
 ).map { |line| JSON.parse(line, symbolize_names: true) }.freeze
 
-puts "=" * 60
-puts "Example 25: Chat History Search"
-puts "=" * 60
-puts
+banner "Chat History Search"
 
 # ---------------------------------------------------------------------------
 # Minimal message stub — populates history without LLM calls
@@ -35,7 +30,7 @@ FakeMsg = Struct.new(:role, :content, :tool_calls)
 # ---------------------------------------------------------------------------
 # Build a robot and inject the conversation fixture
 # ---------------------------------------------------------------------------
-robot = RobotLab.build(name: "tech_lead", system_prompt: "You are a senior engineering advisor.")
+robot = RobotLab.build(model: LLM[:default].model, name: "tech_lead", system_prompt: "You are a senior engineering advisor.")
 
 messages = CONVERSATION_TURNS.map { |t| FakeMsg.new(t[:role], t[:content], nil) }
 robot.instance_variable_get(:@chat).instance_variable_set(:@messages, messages)
@@ -88,7 +83,7 @@ end
 # ---------------------------------------------------------------------------
 # RAG pattern — retrieve the most relevant turns, then inject as context
 # ---------------------------------------------------------------------------
-puts "── RAG pattern: retrieve context, then call LLM ────────────────"
+section "RAG Pattern: Retrieve Context, Then Call LLM"
 puts "(showing retrieved context — no actual LLM call)"
 puts
 
@@ -111,9 +106,7 @@ puts
 # ---------------------------------------------------------------------------
 # When to use search_history
 # ---------------------------------------------------------------------------
-puts "=" * 60
-puts "When to use search_history"
-puts "=" * 60
+section "When to Use search_history"
 puts <<~'TEXT'
 
   Without search_history:

data/examples/26_document_store.rb

@@ -13,14 +13,10 @@
 #   ruby examples/26_document_store.rb
 #   (Downloads the ~23 MB ONNX model on first run; cached afterwards.)
 
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
+require_relative "common"
+require "robot_lab/document_store"
 
-require_relative "../lib/robot_lab"
-
-puts "=" * 60
-puts "Example 26: Embedding-Based Document Store"
-puts "=" * 60
-puts
+banner "Embedding-Based Document Store"
 puts "Note: First run downloads the fastembed model (~23 MB, cached)."
 puts
 
@@ -97,7 +93,7 @@ end
 # ---------------------------------------------------------------------------
 # Delete and verify
 # ---------------------------------------------------------------------------
-puts "── Delete :redis_caching_guide, re-run cache query"
+section "Delete :redis_caching_guide, Re-run Cache Query"
 store.delete(:redis_caching_guide)
 results = store.search("Redis evicting keys unexpectedly", limit: 2)
 puts "   Remaining keys: #{store.keys.inspect}"
@@ -107,7 +103,7 @@ puts
 # ---------------------------------------------------------------------------
 # Memory integration
 # ---------------------------------------------------------------------------
-puts "── Memory integration"
+section "Memory Integration"
 memory = RobotLab::Memory.new(enable_cache: false)
 
 DOCUMENTS.each { |key, text| memory.store_document(key, text) }
@@ -124,10 +120,7 @@ puts
 # ---------------------------------------------------------------------------
 # RAG pattern
 # ---------------------------------------------------------------------------
-puts "=" * 60
-puts "RAG Pattern: retrieve relevant docs, then generate with LLM"
-puts "=" * 60
-puts
+section "RAG Pattern: Retrieve Relevant Docs, Then Generate with LLM"
 
 rag_query = "Our Sidekiq jobs exhaust retries and land in the dead queue after a Stripe outage."