=== mix.exs ===

defmodule DspexDemo.MixProject do use Mix.Project

def project do [ app: :dspex_demo, version: “0.1.0”, elixir: “~> 1.15”, start_permanent: Mix.env() == :prod, deps: deps() ] end

def application do [ extra_applications: [:logger], mod: {DspexDemo.Application, []} ] end

defp deps do [ # Use DSPEx as dependency (assuming it’s published or path dependency) {:dspex, path: “../dspex”}, # HTTP client for API requests {:req, “> 0.4.0”}, # JSON handling {:jason, “> 1.4”}, # CLI interface {:burrito, “> 1.0”}, # Terminal UI {:owl, “> 0.9”} ] end end

=== config/config.exs ===

import Config

config :dspex, providers: %{ gemini: %{ api_key: {:system, “GEMINI_API_KEY”}, base_url: “https://generativelanguage.googleapis.com/v1beta/models", default_model: “gemini-2.0-flash-exp”, timeout: 30_000 }, openai: %{ api_key: {:system, “OPENAI_API_KEY”}, base_url: “https://api.openai.com/v1", default_model: “gpt-4o-mini”, timeout: 30_000 } }, prediction: %{ default_provider: :gemini, default_temperature: 0.7, default_max_tokens: 150 }, teleprompters: %{ beacon: %{ default_instruction_model: :openai, default_evaluation_model: :gemini, max_concurrent_operations: 10 } }

=== lib/dspex_demo/application.ex ===

defmodule DspexDemo.Application do @moduledoc false

use Application

@impl true def start(_type, _args) do children = [ # Start HTTP client pool {Finch, name: DspexDemo.Finch} ]

opts = [strategy: :one_for_one, name: DspexDemo.Supervisor]
Supervisor.start_link(children, opts)

end end

=== lib/dspex_demo/signatures/qa_signature.ex ===

defmodule DspexDemo.Signatures.QASignature do @moduledoc "”” Answer questions with reasoning and confidence.

Provide clear, accurate answers to questions with step-by-step reasoning and a confidence score indicating how certain you are about the answer. """

use DSPEx.Signature, “question -> answer, reasoning, confidence” end

=== lib/dspex_demo/signatures/sentiment_signature.ex ===

defmodule DspexDemo.Signatures.SentimentSignature do @moduledoc """ Analyze the sentiment of text with detailed classification.

Classify text sentiment as positive, negative, or neutral with reasoning for the classification and confidence in the assessment. """

use DSPEx.Signature, “text -> sentiment, reasoning, confidence” end

=== lib/dspex_demo/signatures/cot_signature.ex ===

defmodule DspexDemo.Signatures.CoTSignature do @moduledoc """ Solve problems with explicit chain-of-thought reasoning.

Break down complex problems into logical steps, showing your work clearly before arriving at the final answer. """

use DSPEx.Signature, “problem -> reasoning, answer” end

=== lib/dspex_demo/examples/question_answering.ex ===

defmodule DspexDemo.Examples.QuestionAnswering do @moduledoc """ Demonstrates DSPEx + BEACON for question answering optimization. """

alias DSPEx.{Example, Predict, Program} alias DSPEx.Teleprompter.BEACON alias DspexDemo.Signatures.QASignature

def run_demo do IO.puts """

🎯 DSPEx + BEACON Question Answering Demo
==========================================

This demo shows how BEACON optimizes a question-answering program
by finding the best instruction and demonstration combinations.

"""

# Create student and teacher programs
student = Predict.new(QASignature, :gemini)
teacher = Predict.new(QASignature, :openai)

IO.puts "📚 Creating training dataset..."

# Create training examples
trainset = [
  Example.new(%{
    question: "What is the capital of France?",
    answer: "Paris",
    reasoning: "Paris is the capital and largest city of France, located in the north-central part of the country.",
    confidence: "high"
  }, [:question]),
  
  Example.new(%{
    question: "What is 25% of 80?",
    answer: "20",
    reasoning: "25% means 25/100 or 0.25. To calculate: 80 × 0.25 = 20.",
    confidence: "high"
  }, [:question]),
  
  Example.new(%{
    question: "Who invented the telephone?",
    answer: "Alexander Graham Bell",
    reasoning: "Alexander Graham Bell is credited with inventing the first practical telephone in 1876.",
    confidence: "high"
  }, [:question]),
  
  Example.new(%{
    question: "What is the largest planet in our solar system?",
    answer: "Jupiter",
    reasoning: "Jupiter is the largest planet in our solar system, with a mass greater than all other planets combined.",
    confidence: "high"
  }, [:question]),
  
  Example.new(%{
    question: "In which year did World War II end?",
    answer: "1945",
    reasoning: "World War II ended in 1945 with the surrender of Japan in September following the atomic bombings.",
    confidence: "high"
  }, [:question])
]

IO.puts "✅ Created #{length(trainset)} training examples"

# Define evaluation metric
metric_fn = fn example, prediction ->
  # Multi-factor scoring
  answer_score = if example.data.answer == prediction.answer, do: 0.6, else: 0.0
  reasoning_score = if String.length(prediction.reasoning || "") > 10, do: 0.3, else: 0.0
  confidence_score = if prediction.confidence in ["high", "medium", "low"], do: 0.1, else: 0.0
  
  answer_score + reasoning_score + confidence_score
end

IO.puts """

🧠 Testing baseline student performance...
"""

# Test baseline performance
test_question = %{question: "What is the chemical symbol for gold?"}

case Program.forward(student, test_question) do
  {:ok, baseline_result} ->
    IO.puts "Baseline Answer: #{baseline_result.answer}"
    IO.puts "Baseline Reasoning: #{baseline_result.reasoning}"
    IO.puts "Baseline Confidence: #{baseline_result.confidence}"
  {:error, reason} ->
    IO.puts "❌ Baseline test failed: #{inspect(reason)}"
    return {:error, :baseline_failed}
end

IO.puts """

🚀 Starting BEACON optimization...
This will:
1. Generate instruction candidates using the teacher model
2. Bootstrap demonstration examples
3. Use Bayesian optimization to find the best combination
4. Return an optimized student program

"""

# Create BEACON teleprompter
teleprompter = BEACON.new(
  num_candidates: 8,           # Generate 8 instruction candidates
  max_bootstrapped_demos: 3,   # Use up to 3 demonstrations
  num_trials: 20,              # Run 20 optimization trials
  quality_threshold: 0.7,      # Require 70% quality for demos
  max_concurrency: 5,          # Use 5 concurrent workers
  timeout: 90_000              # 90 second timeout
)

# Add progress callback
progress_callback = fn progress ->
  case progress.phase do
    :bootstrap_generation ->
      IO.write("📝 Generating demos: #{progress.completed}/#{progress.total}\r")
    :demonstration_evaluation ->
      IO.write("🔍 Evaluating demos: #{progress.completed}/#{progress.total}\r")
    :demonstration_selection ->
      IO.puts("\n✅ Selected #{progress.selected_count} quality demonstrations")
    _ ->
      :ok
  end
end

teleprompter_with_progress = %{teleprompter | progress_callback: progress_callback}

# Run BEACON optimization
case BEACON.compile(teleprompter_with_progress, student, teacher, trainset, metric_fn, []) do
  {:ok, optimized_student} ->
    IO.puts """
    
    ✨ BEACON optimization completed successfully!
    
    🧪 Testing optimized student performance...
    """
    
    # Test optimized performance
    case Program.forward(optimized_student, test_question) do
      {:ok, optimized_result} ->
        IO.puts """
        
        📊 RESULTS COMPARISON
        =====================
        
        BASELINE STUDENT:
        Answer: #{baseline_result.answer}
        Reasoning: #{baseline_result.reasoning}
        Confidence: #{baseline_result.confidence}
        
        OPTIMIZED STUDENT:
        Answer: #{optimized_result.answer}
        Reasoning: #{optimized_result.reasoning}
        Confidence: #{optimized_result.confidence}
        
        🎉 Optimization complete! The BEACON-optimized program should show
        improved reasoning quality and more structured responses.
        """
        
        {:ok, %{
          baseline: baseline_result,
          optimized: optimized_result,
          program: optimized_student
        }}
        
      {:error, reason} ->
        IO.puts "❌ Optimized test failed: #{inspect(reason)}"
        {:error, :optimized_test_failed}
    end
    
  {:error, reason} ->
    IO.puts "❌ BEACON optimization failed: #{inspect(reason)}"
    {:error, :optimization_failed}
end

end

def run_interactive_demo do IO.puts """

🎮 Interactive DSPEx + BEACON Demo
=================================

Ask questions and see both baseline and optimized responses!
Type 'quit' to exit.

"""

case run_demo() do
  {:ok, %{program: optimized_program}} ->
    baseline_program = Predict.new(QASignature, :gemini)
    interactive_loop(baseline_program, optimized_program)
    
  {:error, reason} ->
    IO.puts "❌ Demo setup failed: #{inspect(reason)}"
end

end

defp interactive_loop(baseline, optimized) do question = IO.gets("🤔 Ask a question: “) |> String.trim()

case question do
  "quit" ->
    IO.puts "👋 Thanks for trying DSPEx + BEACON!"
    
  "" ->
    interactive_loop(baseline, optimized)
    
  _ ->
    IO.puts "\n🧠 Thinking..."
    
    input = %{question: question}
    
    # Get baseline response
    baseline_response = case Program.forward(baseline, input) do
      {:ok, result} -> result
      {:error, _} -> %{answer: "Error", reasoning: "Failed", confidence: "low"}
    end
    
    # Get optimized response
    optimized_response = case Program.forward(optimized, input) do
      {:ok, result} -> result
      {:error, _} -> %{answer: "Error", reasoning: "Failed", confidence: "low"}
    end
    
    IO.puts """
    
    📊 BASELINE vs OPTIMIZED
    ========================
    
    BASELINE:
    Answer: #{baseline_response.answer}
    Reasoning: #{baseline_response.reasoning}
    Confidence: #{baseline_response.confidence}
    
    OPTIMIZED (BEACON):
    Answer: #{optimized_response.answer}
    Reasoning: #{optimized_response.reasoning}
    Confidence: #{optimized_response.confidence}
    
    """
    
    interactive_loop(baseline, optimized)
end

end end

=== lib/dspex_demo/examples/sentiment_analysis.ex ===

defmodule DspexDemo.Examples.SentimentAnalysis do @moduledoc "”" Demonstrates DSPEx + BEACON for sentiment analysis optimization. """

alias DSPEx.{Example, Predict, Program} alias DSPEx.Teleprompter.BEACON alias DspexDemo.Signatures.SentimentSignature

def run_demo do IO.puts """

😊 DSPEx + BEACON Sentiment Analysis Demo
========================================

This demo optimizes sentiment analysis with reasoning and confidence scoring.

"""

student = Predict.new(SentimentSignature, :gemini)
teacher = Predict.new(SentimentSignature, :openai)

# Create training examples
trainset = [
  Example.new(%{
    text: "I absolutely love this product! It exceeded all my expectations.",
    sentiment: "positive",
    reasoning: "Strong positive language with 'absolutely love' and 'exceeded expectations'",
    confidence: "high"
  }, [:text]),
  
  Example.new(%{
    text: "This is the worst purchase I've ever made. Complete waste of money.",
    sentiment: "negative", 
    reasoning: "Extremely negative language with 'worst' and 'waste of money'",
    confidence: "high"
  }, [:text]),
  
  Example.new(%{
    text: "The product is okay, nothing special but does the job.",
    sentiment: "neutral",
    reasoning: "Balanced language with 'okay' and 'nothing special' indicating neutrality",
    confidence: "medium"
  }, [:text]),
  
  Example.new(%{
    text: "Amazing quality and fast delivery! Highly recommended.",
    sentiment: "positive",
    reasoning: "Positive descriptors 'amazing' and enthusiastic recommendation",
    confidence: "high"
  }, [:text])
]

# Evaluation metric for sentiment analysis
metric_fn = fn example, prediction ->
  sentiment_score = if example.data.sentiment == prediction.sentiment, do: 0.7, else: 0.0
  reasoning_score = if String.length(prediction.reasoning || "") > 15, do: 0.2, else: 0.0
  confidence_score = if prediction.confidence in ["high", "medium", "low"], do: 0.1, else: 0.0
  
  sentiment_score + reasoning_score + confidence_score
end

# Test input
test_text = %{text: "The movie was pretty good but the ending was disappointing."}

# Get baseline
{:ok, baseline} = Program.forward(student, test_text)

# Create and run BEACON
teleprompter = BEACON.new(
  num_candidates: 6,
  max_bootstrapped_demos: 2,
  num_trials: 15,
  quality_threshold: 0.6
)

case BEACON.compile(teleprompter, student, teacher, trainset, metric_fn, []) do
  {:ok, optimized} ->
    {:ok, optimized_result} = Program.forward(optimized, test_text)
    
    IO.puts """
    
    📊 SENTIMENT ANALYSIS RESULTS
    =============================
    
    Text: "#{test_text.text}"
    
    BASELINE:
    Sentiment: #{baseline.sentiment}
    Reasoning: #{baseline.reasoning}
    Confidence: #{baseline.confidence}
    
    OPTIMIZED:
    Sentiment: #{optimized_result.sentiment}
    Reasoning: #{optimized_result.reasoning}
    Confidence: #{optimized_result.confidence}
    
    """
    
    {:ok, %{baseline: baseline, optimized: optimized_result}}
    
  {:error, reason} ->
    {:error, reason}
end

end end

=== lib/dspex_demo/examples/chain_of_thought.ex ===

defmodule DspexDemo.Examples.ChainOfThought do @moduledoc """ Demonstrates DSPEx + BEACON for chain-of-thought reasoning optimization. """

alias DSPEx.{Example, Predict, Program} alias DSPEx.Teleprompter.BEACON alias DspexDemo.Signatures.CoTSignature

def run_demo do IO.puts """

🧮 DSPEx + BEACON Chain-of-Thought Demo
======================================

This demo optimizes step-by-step mathematical reasoning.

"""

student = Predict.new(CoTSignature, :gemini)
teacher = Predict.new(CoTSignature, :openai)

# Create training examples for math problems
trainset = [
  Example.new(%{
    problem: "A store has 48 apples. They sell 15 in the morning and 12 in the afternoon. How many apples are left?",
    reasoning: "Starting with 48 apples. Morning sales: 48 - 15 = 33 apples remaining. Afternoon sales: 33 - 12 = 21 apples remaining.",
    answer: "21"
  }, [:problem]),
  
  Example.new(%{
    problem: "If a train travels 60 mph for 2.5 hours, how far does it travel?",
    reasoning: "Distance = speed × time. Speed = 60 mph, Time = 2.5 hours. Distance = 60 × 2.5 = 150 miles.",
    answer: "150 miles"
  }, [:problem]),
  
  Example.new(%{
    problem: "Sarah has 3 times as many books as Tom. If Tom has 8 books, how many does Sarah have?",
    reasoning: "Tom has 8 books. Sarah has 3 times as many. Sarah's books = 3 × 8 = 24 books.",
    answer: "24"
  }, [:problem])
]

# Evaluation metric for chain-of-thought
metric_fn = fn example, prediction ->
  # Check if answer is correct
  answer_score = if String.contains?(prediction.answer || "", example.data.answer), do: 0.6, else: 0.0
  
  # Check reasoning quality (contains key mathematical operations)
  reasoning = String.downcase(prediction.reasoning || "")
  has_steps = String.contains?(reasoning, ["=", "×", "+", "-", "÷"]) and String.length(reasoning) > 30
  reasoning_score = if has_steps, do: 0.4, else: 0.0
  
  answer_score + reasoning_score
end

# Test problem
test_problem = %{problem: "A rectangle has length 12 meters and width 8 meters. What is its area?"}

# Get baseline
{:ok, baseline} = Program.forward(student, test_problem)

# Create and run BEACON with longer timeout for reasoning
teleprompter = BEACON.new(
  num_candidates: 10,
  max_bootstrapped_demos: 3,
  num_trials: 25,
  quality_threshold: 0.8,
  timeout: 120_000  # 2 minute timeout for complex reasoning
)

case BEACON.compile(teleprompter, student, teacher, trainset, metric_fn, []) do
  {:ok, optimized} ->
    {:ok, optimized_result} = Program.forward(optimized, test_problem)
    
    IO.puts """
    
    📊 CHAIN-OF-THOUGHT RESULTS
    ===========================
    
    Problem: "#{test_problem.problem}"
    
    BASELINE:
    Reasoning: #{baseline.reasoning}
    Answer: #{baseline.answer}
    
    OPTIMIZED:
    Reasoning: #{optimized_result.reasoning}
    Answer: #{optimized_result.answer}
    
    """
    
    {:ok, %{baseline: baseline, optimized: optimized_result}}
    
  {:error, reason} ->
    {:error, reason}
end

end end

=== lib/dspex_demo.ex ===

defmodule DspexDemo do @moduledoc """ DSPEx + BEACON Demo Application

This application demonstrates the power of DSPEx with BEACON optimization across different use cases: question answering, sentiment analysis, and chain-of-thought reasoning. """

alias DspexDemo.Examples.{QuestionAnswering, SentimentAnalysis, ChainOfThought}

def main(args \ []) do case parse_args(args) do {:help} -> print_help()

  {:interactive} ->
    QuestionAnswering.run_interactive_demo()
    
  {:demo, type} ->
    run_demo(type)
    
  {:all} ->
    run_all_demos()
    
  {:error, reason} ->
    IO.puts "❌ Error: #{reason}"
    print_help()
end

end

defp parse_args([]), do: {:all} defp parse_args(["–help"]), do: {:help} defp parse_args(["-h"]), do: {:help} defp parse_args(["–interactive"]), do: {:interactive} defp parse_args(["-i"]), do: {:interactive} defp parse_args([“qa”]), do: {:demo, :question_answering} defp parse_args([“sentiment”]), do: {:demo, :sentiment_analysis} defp parse_args([“cot”]), do: {:demo, :chain_of_thought} defp parse_args([unknown]), do: {:error, “Unknown option: #{unknown}”}

defp print_help do IO.puts """

🎯 DSPEx + BEACON Demo Application
=================================

This demo showcases DSPEx with BEACON teleprompter optimization.

Usage:
  mix run                    # Run all demos
  mix run qa                 # Question answering demo
  mix run sentiment          # Sentiment analysis demo  
  mix run cot                # Chain-of-thought demo
  mix run --interactive      # Interactive Q&A session
  mix run --help             # Show this help

Environment Variables (optional):
  GEMINI_API_KEY            # Google Gemini API key
  OPENAI_API_KEY            # OpenAI API key

Note: Without API keys, the demo will use mock responses
for educational purposes.

"""

end

defp run_demo(:question_answering) do QuestionAnswering.run_demo() end

defp run_demo(:sentiment_analysis) do SentimentAnalysis.run_demo() end

defp run_demo(:chain_of_thought) do ChainOfThought.run_demo() end

defp run_all_demos do IO.puts """

🚀 Running All DSPEx + BEACON Demos
===================================

This will demonstrate BEACON optimization across three different
program types: Question Answering, Sentiment Analysis, and
Chain-of-Thought Reasoning.

"""

demos = [
  {"Question Answering", &QuestionAnswering.run_demo/0},
  {"Sentiment Analysis", &SentimentAnalysis.run_demo/0},
  {"Chain-of-Thought Reasoning", &ChainOfThought.run_demo/0}
]

results = Enum.map(demos, fn {name, demo_fn} ->
  IO.puts "\n" <> String.duplicate("=", 60)
  IO.puts "🎯 #{name} Demo"
  IO.puts String.duplicate("=", 60)
  
  case demo_fn.() do
    {:ok, result} ->
      IO.puts "✅ #{name} demo completed successfully!"
      {name, :success, result}
      
    {:error, reason} ->
      IO.puts "❌ #{name} demo failed: #{inspect(reason)}"
      {name, :error, reason}
  end
end)

# Summary
IO.puts """

📊 DEMO SUMMARY
===============
"""

Enum.each(results, fn {name, status, _result} ->
  emoji = if status == :success, do: "✅", else: "❌"
  IO.puts "#{emoji} #{name}: #{status}"
end)

success_count = Enum.count(results, fn {_, status, _} -> status == :success end)

IO.puts """

🎉 Completed #{success_count}/#{length(results)} demos successfully!

The DSPEx + BEACON framework demonstrates how Bayesian optimization
can automatically improve language model programs by finding optimal
instruction and demonstration combinations.

"""

end end

=== Installation and Usage Instructions ===

Create the demo app:

$ mkdir dspex_demo

$ cd dspex_demo

$ mix new . –app dspex_demo

Copy the above files into the appropriate locations

Run the demo:

$ mix deps.get

$ export GEMINI_API_KEY=your_key_here # optional

$ export OPENAI_API_KEY=your_key_here # optional

$ mix run # Run all demos

$ mix run –interactive # Interactive mode

$ mix run qa # Just Q&A demo

The demo will work with or without API keys (falls back to educational mock responses)