llamero: Skill for Claude Code

Cloud provider clients with llamero

llamero gives Crystal apps one client API over OpenAI, Anthropic, Groq, and OpenRouter, with automatic retry and failover. Define one subclass of Llamero::Client per app and use it everywhere.

Llamero::Client is abstract — you cannot Llamero::Client.new. Subclass it, or use a concrete provider client directly (Llamero::OpenAIClient.new).

Setup

API keys come from environment variables (or the project config file):

export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export GROQ_API_KEY="gsk_..."
export OPENROUTER_API_KEY="sk-or-..."

Only the providers you actually list need keys.

Storage root

If the same app also uses llamero native models/adapters/audio, set the app-owned storage root at boot before creating runtimes:

Llamero.storage_root = Path.home.join(".scribe")

LLAMERO_HOME=/path/to/root is the env alternative; programmatic wins.

Recipe: chat with failover (complete program)

require "llamero"

class MyAIClient < Llamero::Client
  def initialize
    super(primary: :openai, fallbacks: [:anthropic, :groq])
  end
end

client = MyAIClient.new

response = client.chat([
  Llamero::Message.user("What is the capital of France?"),
])
puts response.content       # "The capital of France is Paris."
puts response.provider_used # :openai (or a fallback if openai failed)

Provider symbols: :openai, :anthropic, :groq, :openrouter. Optional named args on chat: model : String?, temperature : Float32?, max_tokens : Int32?.

Recipe: structured JSON output into a Crystal object

class PersonInfo < Llamero::BaseGrammar
  property name : String = ""
  property age : Int32 = 0
  property occupation : String = ""
end

response = client.chat_structured(
  [Llamero::Message.user("Generate a random person's info")],
  PersonInfo
)
person = response.parsed.not_nil!
puts "#{person.name}, #{person.age}, #{person.occupation}"

Schema classes inherit Llamero::BaseGrammar and every property needs a default value. Failover automatically skips providers that lack structured output support.