Elixir SDK

def deps do
  [
    {:moonborn, "~> 1.0"}
  ]
end

mix deps.get

{:ok, client} = Moonborn.client(
  api_key: System.fetch_env!("MOONBORN_API_KEY"),
  # base_url: "https://api.moonborn.co",  # kendi sunucuna kurulum
  # timeout: 60_000,                       # ms
  # max_retries: 3
)

{:ok, persona} = Moonborn.Personas.create_persona(client,
  intent: "İstanbul'dan 34 yaşında bir kurucu. Parlak ama huzursuz.",
  workspace_id: "ws_..."
)
 
IO.inspect({persona.id, persona.status})
IO.puts(persona.surface.name.display)

case Moonborn.Personas.create_persona(client, intent: "...", workspace_id: "ws_...") do
  {:ok, %{status: "flagged", id: id, audit: %{score: score}}} ->
    Logger.warning("Flagged: #{id} (audit #{score})")
 
  {:ok, persona} ->
    {:ok, persona}
 
  {:error, %Moonborn.ApiError{code: code}} ->
    {:error, code}
end

{:ok, session} = Moonborn.Chat.create_session(client, persona_id: persona.id)
 
{:ok, reply} = Moonborn.Chat.send_message(client,
  session_id: session.id,
  content: "Seni ne tetikler?"
)
 
IO.puts(reply.content)
IO.puts("Drift: #{reply.drift_score}, Alert: #{reply.drift_alert}")

Moonborn.Chat.stream_message(client,
  session_id: session.id,
  content: "Sessiz bir gerçek söyle."
)
|> Enum.each(fn
  {:token, delta} ->
    IO.write(delta)
 
  {:completed, %{drift_score: ds}} ->
    IO.puts("\ndrift: #{ds}")
 
  {:error, reason} ->
    Logger.error("stream error: #{inspect(reason)}")
end)

Moonborn.Personas.create_persona_stream(client, intent: "Lagos'ta bir market satıcısı.")
|> Enum.each(fn
  {:step_started, %{step: step}} ->
    IO.puts("Başladı: #{step}")
 
  {:step_completed, %{step: step, duration_ms: ms}} ->
    IO.puts("Bitti: #{step} (#{ms}ms)")
 
  {:pipeline_completed, %{persona_id: id}} ->
    IO.puts("Persona: #{id}")
end)

case Moonborn.Personas.get_persona(client, id: "per_...") do
  {:ok, persona} ->
    persona
 
  {:error, %Moonborn.ApiError{code: "rate_limited", retry_after: ms}} ->
    Process.sleep(ms)
    # yeniden dene
 
  {:error, %Moonborn.ApiError{code: "not_found"}} ->
    nil
 
  {:error, %Moonborn.ApiError{code: "validation_failed", details: details}} ->
    Logger.error("invalid body: #{inspect(details)}")
    {:error, :invalid}
 
  {:error, reason} ->
    Logger.error("unknown: #{inspect(reason)}")
    {:error, reason}
end

{:ok, persona} = Moonborn.Personas.create_persona(client,
  intent: "...",
  workspace_id: "ws_...",
  idempotency_key: "persona-build-2026-05-17-mert"
)

# lib/my_app/application.ex
defmodule MyApp.Application do
  use Application
 
  def start(_type, _args) do
    children = [
      # SDK yapılandırmasını singleton olarak tut
      {Moonborn.Supervisor,
        api_key: System.fetch_env!("MOONBORN_API_KEY"),
        name: MyApp.Moonborn},
 
      # Phoenix uç noktası vb.
      MyAppWeb.Endpoint
    ]
 
    Supervisor.start_link(children, strategy: :one_for_one, name: MyApp.Supervisor)
  end
end
 
# lib/my_app/persona_creator.ex
defmodule MyApp.PersonaCreator do
  def create(intent, workspace_id) do
    Moonborn.Personas.create_persona(MyApp.Moonborn,
      intent: intent,
      workspace_id: workspace_id,
      idempotency_key: "#{workspace_id}-#{:erlang.phash2(intent)}"
    )
  end
end

# lib/my_app_web/controllers/persona_controller.ex
defmodule MyAppWeb.PersonaController do
  use MyAppWeb, :controller
 
  def create(conn, %{"intent" => intent}) do
    case MyApp.PersonaCreator.create(intent, conn.assigns.workspace_id) do
      {:ok, persona} ->
        conn |> put_status(:created) |> json(persona)
 
      {:error, %Moonborn.ApiError{code: "validation_failed", details: details}} ->
        conn |> put_status(:bad_request) |> json(%{error: "invalid", details: details})
 
      {:error, %Moonborn.ApiError{code: "rate_limited", retry_after: ms}} ->
        conn |> put_resp_header("retry-after", to_string(div(ms, 1000)))
             |> put_status(:too_many_requests)
             |> json(%{error: "rate_limited"})
    end
  end
end