Elixir AI Integration Tutorial: Complete Guide 2025

elixir --version
# Should show: Elixir 1.14.0 or higher (compiled with Erlang/OTP 25)

mix --version
# Should show: Mix 1.14.0

mix phx.new --version
# Should show: Phoenix installer v1.7.0 or higher

brew install elixir
mix local.hex --force
mix archive.install hex phx_new --force

wget https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb
sudo dpkg -i erlang-solutions_2.0_all.deb
sudo apt-get update
sudo apt-get install elixir

mix local.hex --force
mix archive.install hex phx_new --force

mix phx.new elixir_ai_app --live
cd elixir_ai_app

# mix.exs
defmodule ElixirAiApp.MixProject do
  use Mix.Project

  def project do
    [
      app: :elixir_ai_app,
      version: "0.1.0",
      elixir: "~> 1.14",
      start_permanent: Mix.env() == :prod,
      deps: deps()
    ]
  end

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

  defp deps do
    [
      {:phoenix, "~> 1.7.0"},
      {:phoenix_live_view, "~> 0.20.0"},
      {:phoenix_html, "~> 3.3"},
      {:phoenix_live_reload, "~> 1.4", only: :dev},
      {:phoenix_live_dashboard, "~> 0.8"},
      {:esbuild, "~> 0.7", runtime: Mix.env() == :dev},
      {:tailwind, "~> 0.2.0", runtime: Mix.env() == :dev},
      {:telemetry_metrics, "~> 0.6"},
      {:telemetry_poller, "~> 1.0"},
      {:gettext, "~> 0.20"},
      {:jason, "~> 1.4"},
      {:plug_cowboy, "~> 2.6"},

      # AI Integration Dependencies
      {:req, "~> 0.4.0"},        # HTTP client for OpenAI API
      {:finch, "~> 0.16"},       # Persistent HTTP connections

      # Testing AI Features
      {:mox, "~> 1.0", only: :test},
      {:bypass, "~> 2.1", only: :test},
      {:stream_data, "~> 0.6", only: :test},
      {:excoveralls, "~> 0.18", only: :test}
    ]
  end
end

mix deps.get
mix deps.compile

# .env
export OPENAI_API_KEY="sk-your-openai-key-here"
export ANTHROPIC_API_KEY="sk-ant-your-anthropic-key-here"

# .gitignore
.env
.env.local
.env.*.local
/_build
/deps
*.ez
/priv/static/
erl_crash.dump

# config/runtime.exs
import Config

if config_env() == :prod do
  config :elixir_ai_app, :openai,
    api_key: System.fetch_env!("OPENAI_API_KEY"),
    organization_id: System.get_env("OPENAI_ORG_ID")

  config :elixir_ai_app, :anthropic,
    api_key: System.fetch_env!("ANTHROPIC_API_KEY")
end

if config_env() == :dev do
  config :elixir_ai_app, :openai,
    api_key: System.get_env("OPENAI_API_KEY", "your-dev-key"),
    organization_id: System.get_env("OPENAI_ORG_ID")

  config :elixir_ai_app, :anthropic,
    api_key: System.get_env("ANTHROPIC_API_KEY", "your-dev-key")
end

# lib/elixir_ai_app/ai/openai_client.ex
defmodule ElixirAiApp.AI.OpenAIClient do
  @moduledoc """
  OpenAI API client with proper error handling and retry logic.
  Uses Mox for testing via compile-time configuration.
  """

  @behaviour ElixirAiApp.AI.AIClientBehaviour

  @base_url "https://api.openai.com/v1"
  @default_model "gpt-4-turbo-preview"
  @default_temperature 0.7
  @default_max_tokens 1000

  # Compile-time config for testing
  @http_client Application.compile_env(:elixir_ai_app, :http_client, __MODULE__)

  @doc """
  Send a chat completion request to OpenAI.

  ## Examples

      iex> OpenAIClient.chat_completion("Hello, how are you?")
      {:ok, "I'm doing well, thank you! How can I assist you today?"}

      iex> OpenAIClient.chat_completion("Explain Elixir", model: "gpt-3.5-turbo")
      {:ok, "Elixir is a functional, concurrent programming language..."}
  """
  def chat_completion(messages, opts \\ []) do
    @http_client.do_chat_completion(messages, opts)
  end

  @doc """
  Actual implementation of chat completion (for production).
  In tests, this is mocked via Mox configuration.
  """
  def do_chat_completion(message, opts \\ []) do
    model = Keyword.get(opts, :model, @default_model)
    temperature = Keyword.get(opts, :temperature, @default_temperature)
    max_tokens = Keyword.get(opts, :max_tokens, @default_max_tokens)

    request_body = %{
      model: model,
      messages: [
        %{role: "system", content: "You are a helpful Elixir programming assistant."},
        %{role: "user", content: message}
      ],
      temperature: temperature,
      max_tokens: max_tokens
    }

    headers = [
      {"Authorization", "Bearer #{api_key()}"},
      {"Content-Type", "application/json"}
    ]

    make_request("/chat/completions", request_body, headers)
  end

  defp make_request(endpoint, request_body, headers) do
    req =
      Req.new(
        base_url: @base_url,
        headers: headers,
        retry: :transient,
        max_retries: 3,
        retry_delay: fn attempt -> :timer.seconds(2 ** attempt) end
      )

    case Req.post(req, url: endpoint, json: request_body) do
      {:ok, %Req.Response{status: 200, body: body}} ->
        parse_response(body)

      {:ok, %Req.Response{status: status, body: body}} when status >= 400 ->
        {:error, "API error #{status}: #{inspect(body)}"}

      {:error, exception} ->
        {:error, "Request failed: #{Exception.message(exception)}"}
    end
  end

  defp parse_response(body) do
    with {:ok, choices} <- Map.fetch(body, "choices"),
         [first_choice | _] <- choices,
         {:ok, message} <- Map.fetch(first_choice, "message"),
         {:ok, content} <- Map.fetch(message, "content") do
      {:ok, content}
    else
      :error -> {:error, "Missing required fields in API response"}
      [] -> {:error, "Empty choices array in API response"}
      _ -> {:error, "Invalid response structure from OpenAI API"}
    end
  end

  @doc """
  Stream chat completion responses token-by-token.
  """
  def chat_completion_stream(message, pid, opts \\ []) do
    # Streaming implementation using SSE
    # Will be implemented in LiveView section
    :ok
  end

  defp api_key do
    Application.get_env(:elixir_ai_app, :openai)[:api_key] ||
      raise "OPENAI_API_KEY not configured"
  end
end

# test/elixir_ai_app/ai/openai_client_test.exs
defmodule ElixirAiApp.AI.OpenAIClientTest do
  use ExUnit.Case, async: true
  alias ElixirAiApp.AI.OpenAIClient

  @moduletag :integration

  describe "chat_completion/2" do
    @tag :skip  # Remove @tag :skip and set OPENAI_API_KEY to run
    test "returns AI response for simple message" do
      assert {:ok, response} = OpenAIClient.chat_completion("Say 'Hello from Elixir!' in exactly 5 words.")

      assert is_binary(response)
      assert String.length(response) > 0
      # AI responses vary, so we check for key indicators
      assert String.contains?(String.downcase(response), "elixir")
    end

    @tag :skip
    test "handles custom model parameter" do
      assert {:ok, response} =
        OpenAIClient.chat_completion("What is 2+2?", model: "gpt-3.5-turbo")

      assert String.contains?(response, "4")
    end
  end
end

# Set your API key first
export OPENAI_API_KEY="sk-your-key-here"

# Run integration tests
mix test --only integration

# lib/elixir_ai_app/ai/assistant.ex
defmodule ElixirAiApp.AI.Assistant do
  @moduledoc """
  GenServer-based AI assistant with conversation memory and error recovery.
  """
  use GenServer
  require Logger

  alias ElixirAiApp.AI.OpenAIClient

  # Client API

  def start_link(opts \\ []) do
    name = Keyword.get(opts, :name, __MODULE__)
    GenServer.start_link(__MODULE__, opts, name: name)
  end

  @doc """
  Ask the AI assistant a question.

  ## Examples

      iex> {:ok, pid} = Assistant.start_link()
      iex> Assistant.ask(pid, "What is a GenServer?")
      {:ok, "A GenServer is a process that implements..."}
  """
  def ask(pid, message) when is_binary(message) do
    GenServer.call(pid, {:ask, message}, 30_000)  # 30 second timeout
  end

  @doc """
  Get the conversation history.
  """
  def get_history(pid) do
    GenServer.call(pid, :get_history)
  end

  @doc """
  Clear conversation memory.
  """
  def clear_history(pid) do
    GenServer.cast(pid, :clear_history)
  end

  # Server Callbacks

  @impl true
  def init(opts) do
    max_history = Keyword.get(opts, :max_history, 10)
    model = Keyword.get(opts, :model, "gpt-4-turbo-preview")

    state = %{
      history: [],
      max_history: max_history,
      model: model,
      request_count: 0,
      total_tokens: 0
    }

    Logger.info("AI Assistant started with model: #{model}")
    {:ok, state}
  end

  @impl true
  def handle_call({:ask, message}, _from, state) do
    # Add user message to history
    updated_history = add_to_history(state.history, :user, message, state.max_history)

    # Call OpenAI API
    case OpenAIClient.chat_completion(message, model: state.model) do
      {:ok, response} ->
        # Add AI response to history
        final_history = add_to_history(updated_history, :assistant, response, state.max_history)

        updated_state = %{state |
          history: final_history,
          request_count: state.request_count + 1
        }

        {:reply, {:ok, response}, updated_state}

      {:error, reason} ->
        Logger.error("AI request failed: #{inspect(reason)}")
        {:reply, {:error, reason}, state}
    end
  end

  @impl true
  def handle_call(:get_history, _from, state) do
    {:reply, state.history, state}
  end

  @impl true
  def handle_cast(:clear_history, state) do
    {:noreply, %{state | history: []}}
  end

  # Private Functions

  defp add_to_history(history, role, content, max_history) do
    new_message = %{
      role: role,
      content: content,
      timestamp: DateTime.utc_now()
    }

    updated_history = [new_message | history]

    # Keep only recent messages to manage memory/tokens
    Enum.take(updated_history, max_history)
  end
end

# Start the assistant
{:ok, pid} = ElixirAiApp.AI.Assistant.start_link()

# Ask questions - assistant remembers context!
{:ok, response1} = ElixirAiApp.AI.Assistant.ask(pid, "What is pattern matching in Elixir?")
IO.puts(response1)

# Follow-up question using context
{:ok, response2} = ElixirAiApp.AI.Assistant.ask(pid, "Can you give me an example?")
IO.puts(response2)

# Check conversation history
history = ElixirAiApp.AI.Assistant.get_history(pid)
IO.inspect(history, label: "Conversation History")

# lib/elixir_ai_app/ai/response_validator.ex
defmodule ElixirAiApp.AI.ResponseValidator do
  @moduledoc """
  Validate and parse AI responses using pattern matching.
  """

  @doc """
  Validate AI response and extract structured data.

  ## Examples

      iex> validate({:ok, "The answer is: 42"})
      {:ok, %{type: :answer, content: "42"}}

      iex> validate({:error, "Rate limit exceeded"})
      {:error, :rate_limit}
  """
  def validate({:ok, response}) when is_binary(response) do
    cond do
      String.contains?(response, ["error", "Error", "ERROR"]) ->
        {:error, :ai_generated_error}

      String.length(response) == 0 ->
        {:error, :empty_response}

      String.length(response) > 10_000 ->
        {:error, :response_too_long}

      true ->
        {:ok, parse_response(response)}
    end
  end

  def validate({:error, %{"error" => %{"type" => "insufficient_quota"}}}) do
    {:error, :insufficient_quota}
  end

  def validate({:error, %{"error" => %{"type" => "rate_limit_exceeded"}}}) do
    {:error, :rate_limit}
  end

  def validate({:error, reason}) do
    {:error, {:unknown_error, reason}}
  end

  defp parse_response(response) do
    %{
      type: :text,
      content: String.trim(response),
      length: String.length(response),
      processed_at: DateTime.utc_now()
    }
  end
end

# lib/elixir_ai_app/ai/assistant_supervisor.ex
defmodule ElixirAiApp.AI.AssistantSupervisor do
  @moduledoc """
  Dynamic supervisor for managing multiple AI assistant processes.
  Each user gets their own isolated AI assistant process.
  """
  use DynamicSupervisor

  alias ElixirAiApp.AI.Assistant

  def start_link(init_arg) do
    DynamicSupervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
  end

  @doc """
  Start an AI assistant for a specific user.

  ## Examples

      iex> start_assistant_for_user("user_123")
      {:ok, #PID<0.245.0>}
  """
  def start_assistant_for_user(user_id, opts \\ []) do
    child_spec = %{
      id: Assistant,
      start: {Assistant, :start_link, [Keyword.put(opts, :name, via_tuple(user_id))]},
      restart: :transient
    }

    DynamicSupervisor.start_child(__MODULE__, child_spec)
  end

  @doc """
  Stop an AI assistant for a user.
  """
  def stop_assistant_for_user(user_id) do
    case Registry.lookup(AssistantRegistry, user_id) do
      [{pid, _}] -> DynamicSupervisor.terminate_child(__MODULE__, pid)
      [] -> {:error, :not_found}
    end
  end

  @doc """
  Get assistant PID for a user (if exists).
  """
  def get_assistant(user_id) do
    case Registry.lookup(AssistantRegistry, user_id) do
      [{pid, _}] -> {:ok, pid}
      [] -> {:error, :not_found}
    end
  end

  @impl true
  def init(_init_arg) do
    DynamicSupervisor.init(strategy: :one_for_one)
  end

  defp via_tuple(user_id) do
    {:via, Registry, {AssistantRegistry, user_id}}
  end
end

# lib/elixir_ai_app/application.ex
defmodule ElixirAiApp.Application do
  use Application

  @impl true
  def start(_type, _args) do
    children = [
      # Phoenix endpoints
      ElixirAiAppWeb.Telemetry,
      {Phoenix.PubSub, name: ElixirAiApp.PubSub},
      ElixirAiAppWeb.Endpoint,

      # AI infrastructure
      {Registry, keys: :unique, name: AssistantRegistry},
      {Finch, name: ElixirAiApp.Finch},
      ElixirAiApp.AI.AssistantSupervisor
    ]

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

# Start assistant for user
{:ok, _pid} = ElixirAiApp.AI.AssistantSupervisor.start_assistant_for_user("user_123")

# Get assistant and ask questions
{:ok, pid} = ElixirAiApp.AI.AssistantSupervisor.get_assistant("user_123")
{:ok, response} = ElixirAiApp.AI.Assistant.ask(pid, "Hello!")

# Process crashes are automatically restarted by supervisor
# User state is preserved across restarts

# lib/elixir_ai_app/ai/batch_processor.ex
defmodule ElixirAiApp.AI.BatchProcessor do
  @moduledoc """
  Process multiple AI requests concurrently using Task.async_stream.
  """

  alias ElixirAiApp.AI.OpenAIClient

  @doc """
  Process a batch of messages in parallel with controlled concurrency.

  ## Examples

      iex> messages = ["Question 1", "Question 2", "Question 3"]
      iex> BatchProcessor.process_batch(messages, max_concurrency: 3)
      [
        {:ok, "Answer 1"},
        {:ok, "Answer 2"},
        {:ok, "Answer 3"}
      ]
  """
  def process_batch(messages, opts \\ []) do
    max_concurrency = Keyword.get(opts, :max_concurrency, 5)
    timeout = Keyword.get(opts, :timeout, 30_000)

    messages
    |> Task.async_stream(
      fn message -> OpenAIClient.chat_completion(message) end,
      max_concurrency: max_concurrency,
      timeout: timeout,
      on_timeout: :kill_task
    )
    |> Enum.map(fn
      {:ok, result} -> result
      {:exit, reason} -> {:error, {:timeout, reason}}
    end)
  end

  @doc """
  Process questions with different AI models concurrently.
  """
  def multi_model_consensus(question) do
    models = ["gpt-4-turbo-preview", "gpt-3.5-turbo", "gpt-4"]

    tasks =
      Enum.map(models, fn model ->
        Task.async(fn ->
          OpenAIClient.chat_completion(question, model: model)
        end)
      end)

    # Wait for all models to respond (with timeout)
    results =
      tasks
      |> Task.await_many(30_000)
      |> Enum.zip(models)
      |> Enum.map(fn {result, model} ->
        %{model: model, response: result}
      end)

    {:ok, results}
  end
end

questions = for i <- 1..100, do: "What is #{i} + #{i}?"

# Process with controlled concurrency (max 10 concurrent requests)
results = ElixirAiApp.AI.BatchProcessor.process_batch(questions, max_concurrency: 10)

# All 100 questions processed in ~3-4 seconds (vs. 300+ seconds sequential)
IO.inspect(length(results), label: "Total Results")

# lib/elixir_ai_app_web/live/chat_live.ex
defmodule ElixirAiAppWeb.ChatLive do
  use ElixirAiAppWeb, :live_view

  alias ElixirAiApp.AI.Assistant
  alias ElixirAiApp.AI.AssistantSupervisor

  @impl true
  def mount(_params, %{"user_id" => user_id} = _session, socket) do
    # Start or get existing assistant for user
    case AssistantSupervisor.get_assistant(user_id) do
      {:ok, pid} ->
        {:ok, assign_assistant(socket, pid, user_id)}

      {:error, :not_found} ->
        {:ok, _pid} = AssistantSupervisor.start_assistant_for_user(user_id)
        {:ok, pid} = AssistantSupervisor.get_assistant(user_id)
        {:ok, assign_assistant(socket, pid, user_id)}
    end
  end

  @impl true
  def handle_event("send_message", %{"message" => message}, socket) do
    if String.trim(message) != "" do
      # Add user message to UI immediately
      socket = add_message(socket, :user, message)

      # Set loading state
      socket = assign(socket, :loading, true)

      # Request AI response asynchronously
      pid = socket.assigns.assistant_pid
      send(self(), {:request_ai_response, pid, message})

      {:noreply, socket}
    else
      {:noreply, socket}
    end
  end

  @impl true
  def handle_event("clear_chat", _params, socket) do
    pid = socket.assigns.assistant_pid
    Assistant.clear_history(pid)

    {:noreply, assign(socket, :messages, [])}
  end

  @impl true
  def handle_info({:request_ai_response, pid, message}, socket) do
    case Assistant.ask(pid, message) do
      {:ok, response} ->
        socket =
          socket
          |> add_message(:assistant, response)
          |> assign(:loading, false)

        {:noreply, socket}

      {:error, reason} ->
        socket =
          socket
          |> add_message(:error, "Sorry, I encountered an error: #{inspect(reason)}")
          |> assign(:loading, false)

        {:noreply, socket}
    end
  end

  @impl true
  def render(assigns) do
    ~H"""
    <div class="container mx-auto max-w-4xl p-4">
      <div class="bg-white shadow-lg rounded-lg">
        <div class="bg-purple-600 text-white p-4 rounded-t-lg">
          <h1 class="text-2xl font-bold">Elixir AI Assistant</h1>
          <p class="text-sm">Powered by Phoenix LiveView + OpenAI</p>
        </div>

        <div class="h-96 overflow-y-auto p-4 bg-gray-50" id="chat-messages" phx-update="append">
          <%= for {id, role, content, timestamp} <- @messages do %>
            <div id={"message-#{id}"} class={"mb-4 #{if role == :user, do: "text-right", else: "text-left"}"}>
              <div class={"inline-block max-w-xs lg:max-w-md px-4 py-2 rounded-lg #{message_style(role)}"}>
                <div class="font-semibold text-xs mb-1">
                  <%= role_name(role) %>
                </div>
                <div class="text-sm whitespace-pre-wrap"><%= content %></div>
                <div class="text-xs text-gray-500 mt-1">
                  <%= Calendar.strftime(timestamp, "%H:%M:%S") %>
                </div>
              </div>
            </div>
          <% end %>

          <%= if @loading do %>
            <div class="text-center">
              <div class="inline-block animate-pulse text-gray-500">
                AI is thinking...
              </div>
            </div>
          <% end %>
        </div>

        <div class="p-4 border-t">
          <form phx-submit="send_message" class="flex gap-2">
            <input
              type="text"
              name="message"
              placeholder="Ask me anything about Elixir..."
              class="flex-1 px-4 py-2 border rounded-lg focus:outline-none focus:ring-2 focus:ring-purple-600"
              autocomplete="off"
            />
            <button
              type="submit"
              class="px-6 py-2 bg-purple-600 text-white rounded-lg hover:bg-purple-700 disabled:bg-gray-400"
              disabled={@loading}
            >
              Send
            </button>
            <button
              type="button"
              phx-click="clear_chat"
              class="px-4 py-2 bg-gray-200 text-gray-700 rounded-lg hover:bg-gray-300"
            >
              Clear
            </button>
          </form>
        </div>
      </div>
    </div>
    """
  end

  # Private functions

  defp assign_assistant(socket, pid, user_id) do
    socket
    |> assign(:assistant_pid, pid)
    |> assign(:user_id, user_id)
    |> assign(:messages, [])
    |> assign(:loading, false)
    |> assign(:message_counter, 0)
  end

  defp add_message(socket, role, content) do
    counter = socket.assigns.message_counter + 1
    message = {counter, role, content, DateTime.utc_now()}

    socket
    |> update(:messages, fn messages -> messages ++ [message] end)
    |> assign(:message_counter, counter)
  end

  defp message_style(:user), do: "bg-purple-600 text-white"
  defp message_style(:assistant), do: "bg-gray-200 text-gray-900"
  defp message_style(:error), do: "bg-red-100 text-red-900 border border-red-300"

  defp role_name(:user), do: "You"
  defp role_name(:assistant), do: "AI Assistant"
  defp role_name(:error), do: "System Error"
end

# lib/elixir_ai_app_web/router.ex
scope "/", ElixirAiAppWeb do
  pipe_through :browser

  live "/chat", ChatLive, :index
end

{:mox, "~> 1.0", only: :test},
{:bypass, "~> 2.1", only: :test}

# config/test.exs
import Config

config :elixir_ai_app, :openai,
  api_key: "test-api-key-not-real",
  base_url: "http://localhost:8080"  # Point to Bypass mock server

# Configure Mox for testing
config :elixir_ai_app, :http_client, ElixirAiApp.AI.MockAIClient

config :logger, level: :warning

# lib/elixir_ai_app/ai/ai_client_behaviour.ex
defmodule ElixirAiApp.AI.AIClientBehaviour do
  @callback chat_completion(String.t(), keyword()) :: {:ok, String.t()} | {:error, term()}
end

# test/support/mocks.ex
Mox.defmock(ElixirAiApp.AI.MockAIClient, for: ElixirAiApp.AI.AIClientBehaviour)

# test/elixir_ai_app/ai/assistant_test.exs
defmodule ElixirAiApp.AI.AssistantTest do
  use ExUnit.Case, async: true

  import Mox

  alias ElixirAiApp.AI.Assistant
  alias ElixirAiApp.AI.MockAIClient

  setup :verify_on_exit!

  describe "start_link/1" do
    test "starts assistant with default options" do
      assert {:ok, pid} = Assistant.start_link()
      assert Process.alive?(pid)
    end

    test "starts assistant with custom model" do
      assert {:ok, _pid} = Assistant.start_link(model: "gpt-3.5-turbo")
    end
  end

  describe "ask/2" do
    setup do
      {:ok, pid} = Assistant.start_link()
      %{pid: pid}
    end

    test "returns AI response for valid message", %{pid: pid} do
      # Mock AI response
      MockAIClient
      |> expect(:chat_completion, fn message, _opts ->
        assert message == "Hello, AI!"
        {:ok, "Hello! How can I help you today?"}
      end)

      assert {:ok, response} = Assistant.ask(pid, "Hello, AI!")
      assert response == "Hello! How can I help you today?"
    end

    test "maintains conversation history across multiple asks", %{pid: pid} do
      MockAIClient
      |> expect(:chat_completion, 2, fn _message, _opts ->
        {:ok, "Mocked response"}
      end)

      assert {:ok, _} = Assistant.ask(pid, "First question")
      assert {:ok, _} = Assistant.ask(pid, "Second question")

      history = Assistant.get_history(pid)
      assert length(history) == 4  # 2 user messages + 2 assistant responses
    end

    test "handles API errors gracefully", %{pid: pid} do
      MockAIClient
      |> expect(:chat_completion, fn _message, _opts ->
        {:error, "Rate limit exceeded"}
      end)

      assert {:error, "Rate limit exceeded"} = Assistant.ask(pid, "Test")
    end

    test "respects max_history limit", %{pid: pid} do
      # Start with small history limit
      {:ok, pid} = Assistant.start_link(max_history: 4)

      MockAIClient
      |> expect(:chat_completion, 3, fn _message, _opts ->
        {:ok, "Response"}
      end)

      Assistant.ask(pid, "Message 1")
      Assistant.ask(pid, "Message 2")
      Assistant.ask(pid, "Message 3")

      history = Assistant.get_history(pid)
      # Should only keep last 4 messages (2 conversations)
      assert length(history) == 4
    end
  end

  describe "clear_history/1" do
    test "clears conversation history", %{pid: pid} do
      MockAIClient
      |> expect(:chat_completion, fn _message, _opts ->
        {:ok, "Response"}
      end)

      Assistant.ask(pid, "Test message")
      assert length(Assistant.get_history(pid)) == 2

      Assistant.clear_history(pid)
      assert Assistant.get_history(pid) == []
    end
  end
end

# test/elixir_ai_app/ai/openai_client_integration_test.exs
defmodule ElixirAiApp.AI.OpenAIClientIntegrationTest do
  use ExUnit.Case, async: false

  alias ElixirAiApp.AI.OpenAIClient

  @moduletag :integration
  @moduletag timeout: 60_000

  describe "chat_completion/2 (REAL API)" do
    @tag :skip  # Remove to run with real API key
    test "returns response from real OpenAI API" do
      message = "What is 2+2? Answer with just the number."

      assert {:ok, response} = OpenAIClient.chat_completion(message)
      assert is_binary(response)
      assert String.contains?(response, "4")
    end

    @tag :skip
    test "handles different models" do
      assert {:ok, _response} =
        OpenAIClient.chat_completion("Hello", model: "gpt-3.5-turbo")
    end
  end
end

# test/elixir_ai_app/ai/response_validator_property_test.exs
defmodule ElixirAiApp.AI.ResponseValidatorPropertyTest do
  use ExUnit.Case, async: true
  use ExUnitProperties

  alias ElixirAiApp.AI.ResponseValidator

  property "validates all non-empty strings as valid responses" do
    check all response <- string(:printable, min_length: 1, max_length: 1000) do
      assert {:ok, _parsed} = ResponseValidator.validate({:ok, response})
    end
  end

  property "rejects empty responses" do
    assert {:error, :empty_response} = ResponseValidator.validate({:ok, ""})
  end

  property "handles error tuples correctly" do
    check all error_message <- string(:printable, min_length: 1) do
      assert {:error, _} = ResponseValidator.validate({:error, error_message})
    end
  end
end

# Run all tests (fast unit tests with mocks)
mix test

# Run only integration tests (requires API key)
export OPENAI_API_KEY="sk-your-key"
mix test --only integration

# Run with coverage
mix test --cover

# Run property-based tests
mix test test/elixir_ai_app/ai/response_validator_property_test.exs

# lib/elixir_ai_app/ai/ai_supervisor.ex
defmodule ElixirAiApp.AI.AISupervisor do
  @moduledoc """
  Top-level supervisor for all AI-related processes.
  Implements supervision tree with restart strategies.
  """
  use Supervisor

  def start_link(init_arg) do
    Supervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
  end

  @impl true
  def init(_init_arg) do
    children = [
      # HTTP client pool for AI APIs
      {Finch,
       name: ElixirAiApp.AI.Finch,
       pools: %{
         "https://api.openai.com" => [size: 100, count: 10]
       }},

      # Registry for named AI assistants
      {Registry, keys: :unique, name: AssistantRegistry},

      # Dynamic supervisor for user assistants
      ElixirAiApp.AI.AssistantSupervisor,

      # Rate limiter for API calls
      {ElixirAiApp.AI.RateLimiter, max_requests: 100, window_ms: 60_000}
    ]

    # :one_for_one - if child crashes, only restart that child
    # :rest_for_one - if child crashes, restart it and all children started after it
    # :one_for_all - if any child crashes, restart ALL children
    Supervisor.init(children, strategy: :one_for_one)
  end
end

# lib/elixir_ai_app/ai/rate_limiter.ex
defmodule ElixirAiApp.AI.RateLimiter do
  @moduledoc """
  Token bucket rate limiter for AI API calls.
  Prevents exceeding provider rate limits.
  """
  use GenServer
  require Logger

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  @doc """
  Attempt to consume a token for an API request.
  Returns :ok if allowed, {:error, :rate_limited} if not.
  """
  def check_rate_limit do
    GenServer.call(__MODULE__, :check_rate_limit)
  end

  @impl true
  def init(opts) do
    max_requests = Keyword.fetch!(opts, :max_requests)
    window_ms = Keyword.fetch!(opts, :window_ms)

    state = %{
      max_requests: max_requests,
      window_ms: window_ms,
      requests: [],
      denied_count: 0
    }

    {:ok, state}
  end

  @impl true
  def handle_call(:check_rate_limit, _from, state) do
    now = System.monotonic_time(:millisecond)
    window_start = now - state.window_ms

    # Remove requests outside current window
    recent_requests =
      state.requests
      |> Enum.filter(fn timestamp -> timestamp > window_start end)

    if length(recent_requests) < state.max_requests do
      # Allow request
      updated_state = %{state |
        requests: [now | recent_requests]
      }

      {:reply, :ok, updated_state}
    else
      # Deny request
      Logger.warning("Rate limit exceeded: #{length(recent_requests)} requests in window")

      updated_state = %{state |
        requests: recent_requests,
        denied_count: state.denied_count + 1
      }

      {:reply, {:error, :rate_limited}, updated_state}
    end
  end
end

# lib/elixir_ai_app/ai/resilient_client.ex
defmodule ElixirAiApp.AI.ResilientClient do
  @moduledoc """
  AI client with exponential backoff retry and circuit breaker.
  """

  require Logger

  @max_retries 3
  @base_delay_ms 1000

  def chat_completion_with_retry(message, opts \\ [], retry_count \\ 0) do
    case ElixirAiApp.AI.RateLimiter.check_rate_limit() do
      :ok ->
        attempt_request(message, opts, retry_count)

      {:error, :rate_limited} ->
        if retry_count < @max_retries do
          delay = calculate_backoff(retry_count)
          Logger.info("Rate limited, retrying in #{delay}ms (attempt #{retry_count + 1})")
          Process.sleep(delay)
          chat_completion_with_retry(message, opts, retry_count + 1)
        else
          {:error, :rate_limit_max_retries}
        end
    end
  end

  defp attempt_request(message, opts, retry_count) do
    case ElixirAiApp.AI.OpenAIClient.chat_completion(message, opts) do
      {:ok, response} ->
        {:ok, response}

      {:error, reason} when retry_count < @max_retries ->
        if retryable_error?(reason) do
          delay = calculate_backoff(retry_count)
          Logger.warning("Request failed (#{inspect(reason)}), retrying in #{delay}ms")
          Process.sleep(delay)
          attempt_request(message, opts, retry_count + 1)
        else
          {:error, reason}
        end

      {:error, reason} ->
        Logger.error("Request failed after #{retry_count} retries: #{inspect(reason)}")
        {:error, :max_retries_exceeded}
    end
  end

  defp calculate_backoff(retry_count) do
    # Exponential backoff with jitter
    base_delay = @base_delay_ms * :math.pow(2, retry_count)
    jitter = :rand.uniform(1000)
    trunc(base_delay + jitter)
  end

  defp retryable_error?(reason) when is_binary(reason) do
    String.contains?(reason, ["timeout", "connection", "network", "503", "500"])
  end

  defp retryable_error?(_), do: false
end

# config/runtime.exs
import Config

if config_env() == :prod do
  # AI API configuration from environment
  config :elixir_ai_app, :openai,
    api_key: System.fetch_env!("OPENAI_API_KEY"),
    base_url: System.get_env("OPENAI_BASE_URL", "https://api.openai.com/v1")

  # Rate limiting configuration
  config :elixir_ai_app, :rate_limiting,
    max_requests_per_minute: String.to_integer(System.get_env("AI_RATE_LIMIT", "100")),
    max_concurrent_requests: String.to_integer(System.get_env("AI_MAX_CONCURRENT", "50"))

  # Phoenix endpoint configuration
  secret_key_base =
    System.fetch_env!("SECRET_KEY_BASE") ||
      raise "environment variable SECRET_KEY_BASE is missing"

  host = System.get_env("PHX_HOST") || "example.com"
  port = String.to_integer(System.get_env("PORT") || "4000")

  config :elixir_ai_app, ElixirAiAppWeb.Endpoint,
    url: [host: host, port: 443, scheme: "https"],
    http: [
      ip: {0, 0, 0, 0, 0, 0, 0, 0},
      port: port
    ],
    secret_key_base: secret_key_base
end

# Build production release
MIX_ENV=prod mix release

# Run in production
_build/prod/rel/elixir_ai_app/bin/elixir_ai_app start

# 1. Check environment variable is set
System.get_env("OPENAI_API_KEY")
# Should not be nil

# 2. Verify config is loaded
Application.get_env(:elixir_ai_app, :openai)[:api_key]

# 3. Check runtime.exs is being evaluated
IO.inspect(Mix.env(), label: "Current Environment")

# 1. Add telemetry to track crashes
defmodule ElixirAiApp.AI.Assistant do
  # ... existing code ...

  @impl true
  def handle_continue(:log_startup, state) do
    :telemetry.execute(
      [:elixir_ai_app, :assistant, :started],
      %{count: 1},
      %{pid: self()}
    )
    {:noreply, state}
  end

  @impl true
  def terminate(reason, state) do
    Logger.error("Assistant terminating: #{inspect(reason)}")
    Logger.debug("Final state: #{inspect(state)}")
    :ok
  end
end

# 2. Check supervisor logs
require Logger
Logger.configure(level: :debug)

# 3. Inspect process info
Process.info(pid, :current_stacktrace)

# 1. Check current rate limiter state
GenServer.call(ElixirAiApp.AI.RateLimiter, :get_stats)

# 2. Increase rate limits in config
config :elixir_ai_app, :rate_limiting,
  max_requests_per_minute: 500  # Increase from 100

# 3. Implement request queuing
defmodule ElixirAiApp.AI.RequestQueue do
  use GenServer

  def enqueue(message) do
    GenServer.cast(__MODULE__, {:enqueue, message})
  end

  def handle_cast({:enqueue, message}, state) do
    # Process when rate limit allows
    spawn(fn -> process_when_ready(message) end)
    {:noreply, state}
  end

  defp process_when_ready(message) do
    case ElixirAiApp.AI.RateLimiter.check_rate_limit() do
      :ok ->
        ElixirAiApp.AI.OpenAIClient.chat_completion(message)

      {:error, :rate_limited} ->
        Process.sleep(1000)
        process_when_ready(message)
    end
  end
end