A unified interface (Nexus) for interacting with various Large Language Model (LLM) providers in Elixir.

Nexlm abstracts away provider-specific implementations while offering a clean, consistent API for developers. This enables easy integration with different LLM services like OpenAI's GPT, Anthropic's Claude, and Google's Gemini.

Features

• Single, unified API for multiple LLM providers
• Support for text and multimodal (image) inputs
• Built-in validation and error handling
• Configurable request parameters
• Provider-agnostic message format
• Caching support for reduced costs

Provider Support

Currently supported providers:

• OpenAI (GPT-4, GPT-3.5)
• Anthropic (Claude)
• Google (Gemini)

Model Names

Model names must be prefixed with the provider name:

• "anthropic/claude-3-haiku-20240307"
• "openai/gpt-4"
• "google/gemini-pro"

Basic Usage

Simple Text Completion

messages = [%{
  "role" => "user",
  "content" => "What is the capital of France?"
}]

{:ok, response} = Nexlm.complete("anthropic/claude-3-haiku-20240307", messages)
# => {:ok, %{role: "assistant", content: "The capital of France is Paris."}}

With System Message

messages = [
  %{
    "role" => "system",
    "content" => "You are a mathematician who only responds with numbers"
  },
  %{
    "role" => "user",
    "content" => "What is five plus five?"
  }
]

{:ok, response} = Nexlm.complete("openai/gpt-4", messages, temperature: 0.7)
# => {:ok, %{role: "assistant", content: "10"}}

Image Analysis

image_data = File.read!("image.jpg") |> Base.encode64()

messages = [
  %{
    "role" => "user",
    "content" => [
      %{"type" => "text", "text" => "What's in this image?"},
      %{
        "type" => "image",
        "mime_type" => "image/jpeg",
        "data" => image_data,
        "cache" => true  # Enable caching for this content
      }
    ]
  }
]

{:ok, response} = Nexlm.complete(
  "google/gemini-pro-vision",
  messages,
  max_tokens: 100
)

Configuration

Configure provider API keys in your application's runtime configuration:

# config/runtime.exs
config :nexlm, Nexlm.Providers.OpenAI,
  api_key: System.get_env("OPENAI_API_KEY")

config :nexlm, Nexlm.Providers.Anthropic,
  api_key: System.get_env("ANTHROPIC_API_KEY")

config :nexlm, Nexlm.Providers.Google,
  api_key: System.get_env("GOOGLE_API_KEY")

Debug Logging

Enable detailed debug logging to see request/response details:

# In configuration
config :nexlm, :debug, true

# Or via environment variable
export NEXLM_DEBUG=true

Debug logs include:

• Provider and model information
• Complete HTTP requests (headers, body) with sensitive data redacted
• Complete HTTP responses (status, headers, body)
• Message transformations and validation steps
• Request timing information

Example debug output:

[debug] [Nexlm] Starting request for model: anthropic/claude-3-haiku-20240307
[debug] [Nexlm] Provider: anthropic
[debug] [Nexlm] Request: POST https://api.anthropic.com/v1/messages
[debug] [Nexlm] Headers: %{"x-api-key" => "[REDACTED]", ...}
[debug] [Nexlm] Body: %{model: "claude-3-haiku-20240307", messages: [...]}
[debug] [Nexlm] Response: 200 OK (342ms)
[debug] [Nexlm] Response Body: %{content: [...], role: "assistant"}

Error Handling

The library provides structured error handling:

case Nexlm.complete(model, messages, opts) do
  {:ok, response} ->
    handle_success(response)

  {:error, %Nexlm.Error{type: :network_error}} ->
    retry_request()

  {:error, %Nexlm.Error{type: :provider_error, message: msg, details: details}} ->
    status = Map.get(details, :status, "n/a")
    Logger.error("Provider error (status #{status}): #{msg}")
    handle_provider_error(status)

  {:error, %Nexlm.Error{type: :authentication_error}} ->
    refresh_credentials()

  {:error, error} ->
    Logger.error("Unexpected error: #{inspect(error)}")
    handle_generic_error()
end

Message Format

Simple Text Message

%{
  "role" => "user",  # "user", "assistant", or "system"
  "content" => "Hello, world!"
}

Message with Image

%{
  "role" => "user",
  "content" => [
    %{"type" => "text", "text" => "What's in this image?"},
    %{
      "type" => "image",
      "mime_type" => "image/jpeg",
      "data" => "base64_encoded_data",
      "cache" => true  # Optional caching flag
    }
  ]
}

System Message

%{
  "role" => "system",
  "content" => "You are a helpful assistant"
}

Content Caching

Nexlm supports provider-level message caching through content item configuration:

# Image with caching enabled
%{
  "type" => "image",
  "mime_type" => "image/jpeg",
  "data" => "base64_data",
  "cache" => true  # Enable caching
}

Currently supported by:

• Anthropic (via cache_control in content items)
• Other providers may add support in future updates