litellm.core — tech.unravel/litellm-clj 0.3.0-alpha.1

Core API for LiteLLM - Direct provider calls with model names as-is

anthropic-completion clj

(anthropic-completion model request-map & {:as config})

Direct Anthropic completion

calculate-cost clj

(calculate-cost provider-name model prompt-tokens completion-tokens)

Calculate cost for a request/response

chat clj

(chat provider-name model message & {:keys [system-prompt] :as config})

Simple chat completion function for single user messages.

Convenience wrapper around completion for simple question-answer interactions.

Parameters:

• provider-name - Provider keyword (:openai, :anthropic, etc.)
• model - Model name string
• message - User message string
• config - Optional keyword args including :system-prompt, :api-key, etc.

Examples:

;; Simple question
(chat :openai "gpt-4" "What is 2+2?" 
      :api-key "sk-...")

;; With system prompt
(chat :openai "gpt-4" "Explain quantum physics"
      :api-key "sk-..."
      :system-prompt "You are a physics professor")

See also: completion, extract-content

completion clj

(completion provider-name model request-map)

(completion provider-name model request-map config)

Direct completion function - accepts provider keyword and model name as-is.

Supports both streaming and non-streaming requests. For streaming requests, returns a core.async channel.

Parameters:

• provider - Provider keyword (:openai, :anthropic, :gemini, :mistral, :ollama, :openrouter)
• model - Model name string (e.g., "gpt-4", "claude-3-opus-20240229")
• request-map - Request with :messages, :temperature, :max-tokens, etc.
• config - Optional config with :api-key, :api-base, :timeout

Returns:

• Non-streaming: Response map with :choices, :usage, etc.
• Streaming: core.async channel with response chunks

Examples:

;; Non-streaming completion
(completion :openai "gpt-4" 
            {:messages [{:role :user :content "Hello"}]}
            {:api-key "sk-..."})

;; Streaming completion (returns channel)
(completion :openai "gpt-4"
            {:messages [{:role :user :content "Hello"}]
             :stream true}
            {:api-key "sk-..."})

;; Anthropic Claude
(completion :anthropic "claude-3-sonnet-20240229"
            {:messages [{:role :user :content "Hello"}]}
            {:api-key "sk-ant-..."})

See also: chat, extract-content, extract-message

embedding clj

(embedding provider-name model request-map)

(embedding provider-name model request-map config)

Generate embeddings for text input.

Parameters:

• provider - Provider keyword (:openai, :mistral, :gemini)
• model - Model name string (e.g., "text-embedding-3-small", "mistral-embed")
• request-map - Request with :input (string or vector of strings)
• config - Optional config with :api-key, :api-base, :timeout

Returns:

• Response map with :data (vector of embeddings), :usage, etc.

Examples:

;; Single text embedding
(embedding :openai "text-embedding-3-small" 
           {:input "Hello world"}
           {:api-key "sk-..."})

;; Multiple texts
(embedding :openai "text-embedding-3-small"
           {:input ["Hello" "World"]}
           {:api-key "sk-..."})

;; Mistral embeddings
(embedding :mistral "mistral-embed"
           {:input "Hello world"}
           {:api-key "..."})

;; Gemini embeddings
(embedding :gemini "text-embedding-004"
           {:input "Hello world"}
           {:api-key "..."})

See also: openai-embedding, mistral-embedding, gemini-embedding

estimate-request-tokens clj

(estimate-request-tokens request)

Estimate token count for a request

estimate-tokens clj

(estimate-tokens text)

Estimate token count for text

extract-content clj

(extract-content response)

Extract text content from a completion response.

Retrieves the generated text from the first choice in the response.

Example:

(def response (completion :openai "gpt-4" {...}))
(extract-content response)
;; => "The generated text content..."

See also: extract-message, extract-usage

extract-message clj

(extract-message response)

Extract the full message object from a completion response.

Returns the complete message including :content, :role, and :tool-calls (if any).

Example:

(def response (completion :openai "gpt-4" {...}))
(extract-message response)
;; => {:role :assistant :content "..." :tool-calls [...]}

See also: extract-content, extract-usage

extract-usage clj

(extract-usage response)

Extract token usage information from a completion response.

Returns a map with :prompt-tokens, :completion-tokens, and :total-tokens.

Example:

(def response (completion :openai "gpt-4" {...}))
(extract-usage response)
;; => {:prompt-tokens 10 :completion-tokens 20 :total-tokens 30}

See also: extract-content, calculate-cost

gemini-completion clj

(gemini-completion model request-map & {:as config})

Direct Gemini completion

gemini-embedding clj

(gemini-embedding model request-map & {:as config})

Direct Gemini embedding

list-providers clj

(list-providers)

List all available providers (registered via multimethods)

mistral-completion clj

(mistral-completion model request-map & {:as config})

Direct Mistral completion

mistral-embedding clj

(mistral-embedding model request-map & {:as config})

Direct Mistral embedding

ollama-completion clj

(ollama-completion model request-map & {:as config})

Direct Ollama completion

openai-completion clj

(openai-completion model request-map & {:as config})

Direct OpenAI completion

openai-embedding clj

(openai-embedding model request-map & {:as config})

Direct OpenAI embedding

openrouter-completion clj

(openrouter-completion model request-map & {:as config})

Direct OpenRouter completion

provider-available? clj

(provider-available? provider-name)

Check if a provider is available

provider-info clj

(provider-info provider-name)

Get information about a provider

supports-function-calling? clj

(supports-function-calling? provider-name)

Check if provider supports function calling

supports-streaming? clj

(supports-streaming? provider-name)

Check if provider supports streaming

validate-request clj

(validate-request provider-name request)

Validate a request against provider capabilities

with-error-handling clj

(with-error-handling f)

Execute function with comprehensive error handling