Public symbols

A guided tour of include/llama.h. The header is grouped roughly by lifecycle: backend init, model loading, context init, batch construction, decoding, KV cache management, sampling, grammar, chat, state save/load.

For the binding to internal C++ implementations, see Library entry point.

Backend

void llama_backend_init(void);
void llama_backend_free(void);

// Optional NUMA hint
void llama_numa_init(enum ggml_numa_strategy numa);

llama_backend_init is called once at process start. It loads every linked or dynamically-discovered ggml backend (see Backends).

Model

struct llama_model;
struct llama_model_params llama_model_default_params(void);

struct llama_model * llama_model_load_from_file(
        const char * path_model,
        struct llama_model_params params);

struct llama_model * llama_model_load_from_splits(
        const char ** paths, size_t n_paths,
        struct llama_model_params params);

void llama_model_free(struct llama_model * model);

uint64_t llama_model_size(const struct llama_model * model);
int32_t  llama_model_n_params(const struct llama_model * model);
int32_t  llama_model_meta_count(const struct llama_model * model);
// ... and many getters for hparams, arch name, chat template, etc.

llama_model_params is the load-time configuration struct: n_gpu_layers, tensor_split, main_gpu, vocab_only, use_mmap, use_mlock, kv_overrides, etc. See Reference → Configuration.

Vocab

const struct llama_vocab * llama_model_get_vocab(const struct llama_model * model);

int32_t llama_tokenize(const struct llama_vocab * vocab,
                       const char * text, int32_t text_len,
                       llama_token * tokens, int32_t n_tokens_max,
                       bool add_special, bool parse_special);

int32_t llama_token_to_piece(const struct llama_vocab * vocab,
                             llama_token token, char * buf, int32_t length,
                             int32_t lstrip, bool special);

int32_t llama_detokenize(const struct llama_vocab * vocab,
                         const llama_token * tokens, int32_t n_tokens,
                         char * text, int32_t text_len_max,
                         bool remove_special, bool unparse_special);

Plus a long list of accessors for special tokens (bos, eos, pad, ...). See Vocab and tokenizer.

Context

struct llama_context;
struct llama_context_params llama_context_default_params(void);

struct llama_context * llama_init_from_model(
        struct llama_model * model,
        struct llama_context_params params);

void llama_free(struct llama_context * ctx);

uint32_t llama_n_ctx(const struct llama_context * ctx);
uint32_t llama_n_batch(const struct llama_context * ctx);
// ...

llama_context_params is the runtime config: n_ctx, n_batch, n_ubatch, n_seq_max, n_threads, rope_freq_*, pooling_type, attention_type, cache_type_k, cache_type_v, embeddings, flash_attn, etc. See Reference → Configuration.

Batch and decode

struct llama_batch llama_batch_init(int32_t n_tokens, int32_t embd, int32_t n_seq_max);
struct llama_batch llama_batch_get_one(llama_token * tokens, int32_t n_tokens);
void               llama_batch_free(struct llama_batch batch);

int32_t llama_encode(struct llama_context * ctx, struct llama_batch batch);
int32_t llama_decode(struct llama_context * ctx, struct llama_batch batch);

float * llama_get_logits(struct llama_context * ctx);
float * llama_get_logits_ith(struct llama_context * ctx, int32_t i);
float * llama_get_embeddings(struct llama_context * ctx);
float * llama_get_embeddings_seq(struct llama_context * ctx, llama_seq_id seq_id);

llama_decode is the workhorse — it builds a per-batch graph, schedules it across backends, executes it, and updates KV state. See Computation graph.

KV cache and memory

typedef int32_t llama_seq_id;

void llama_kv_self_clear     (struct llama_context * ctx);
void llama_kv_self_seq_rm    (struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1);
void llama_kv_self_seq_cp    (struct llama_context * ctx, llama_seq_id src, llama_seq_id dst, llama_pos p0, llama_pos p1);
void llama_kv_self_seq_keep  (struct llama_context * ctx, llama_seq_id seq_id);
void llama_kv_self_seq_add   (struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1, llama_pos delta);
void llama_kv_self_seq_div   (struct llama_context * ctx, llama_seq_id seq_id, llama_pos p0, llama_pos p1, int d);
llama_pos llama_kv_self_seq_pos_max(struct llama_context * ctx, llama_seq_id seq_id);
void llama_kv_self_defrag    (struct llama_context * ctx);

See KV cache and memory. The llama_state_* family (omitted here) saves/restores either the entire context or a single sequence — used by examples/save-load-state/ and the server's POST /slots/{id} endpoint.

Sampling

struct llama_sampler;
struct llama_sampler_chain_params llama_sampler_chain_default_params(void);

struct llama_sampler * llama_sampler_chain_init(struct llama_sampler_chain_params params);
void llama_sampler_chain_add(struct llama_sampler * chain, struct llama_sampler * smpl);

struct llama_sampler * llama_sampler_init_top_k(int32_t k);
struct llama_sampler * llama_sampler_init_top_p(float p, size_t min_keep);
struct llama_sampler * llama_sampler_init_min_p(float p, size_t min_keep);
struct llama_sampler * llama_sampler_init_temp(float t);
struct llama_sampler * llama_sampler_init_typical(float p, size_t min_keep);
struct llama_sampler * llama_sampler_init_mirostat_v2(uint32_t seed, float tau, float eta);
struct llama_sampler * llama_sampler_init_grammar(...);
struct llama_sampler * llama_sampler_init_dist(uint32_t seed);
struct llama_sampler * llama_sampler_init_greedy(void);
// ... many more

void                   llama_sampler_apply (struct llama_sampler * smpl, llama_token_data_array * cur_p);
llama_token            llama_sampler_sample(struct llama_sampler * smpl, struct llama_context * ctx, int32_t idx);
void                   llama_sampler_accept(struct llama_sampler * smpl, llama_token token);
void                   llama_sampler_free  (struct llama_sampler * smpl);

See Sampler.

Grammar

struct llama_grammar;
struct llama_grammar * llama_grammar_init_impl(...);
void                   llama_grammar_free_impl(struct llama_grammar * grammar);
void                   llama_grammar_accept_impl(struct llama_grammar * grammar, llama_token token);

Most users don't touch these directly — llama_sampler_init_grammar wraps them. See Grammar.

Chat

int32_t llama_chat_apply_template(
        const char * tmpl,
        const struct llama_chat_message * chat, size_t n_msg,
        bool add_ass,
        char * buf, int32_t length);

For the full Jinja-based path, see common/chat.cpp and Chat templates.

Adapters

struct llama_adapter_lora;
struct llama_adapter_lora * llama_adapter_lora_init(struct llama_model * model, const char * path_lora);
void                        llama_adapter_lora_free(struct llama_adapter_lora * adapter);

int32_t llama_set_adapter_lora(struct llama_context * ctx,
                               struct llama_adapter_lora * adapter,
                               float scale);
int32_t llama_rm_adapter_lora (struct llama_context * ctx,
                               struct llama_adapter_lora * adapter);
void    llama_clear_adapter_lora(struct llama_context * ctx);

See Adapters.

State save/load

size_t  llama_state_get_size      (struct llama_context * ctx);
size_t  llama_state_get_data      (struct llama_context * ctx, uint8_t * dst, size_t size);
size_t  llama_state_set_data      (struct llama_context * ctx, const uint8_t * src, size_t size);
size_t  llama_state_seq_get_size  (struct llama_context * ctx, llama_seq_id seq);
size_t  llama_state_seq_get_data  (struct llama_context * ctx, uint8_t * dst, size_t size, llama_seq_id seq);
size_t  llama_state_seq_set_data  (struct llama_context * ctx, const uint8_t * src, size_t size, llama_seq_id seq);
bool    llama_state_load_file     (struct llama_context * ctx, const char * path, ...);
bool    llama_state_save_file     (struct llama_context * ctx, const char * path, ...);

Used by examples/save-load-state/ and the server's slot-save endpoint.

Logging

void llama_log_set(ggml_log_callback log_callback, void * user_data);

Tools register their own callback through common/log.cpp. Default behavior writes to stderr.

Quantization

struct llama_model_quantize_params llama_model_quantize_default_params(void);
uint32_t llama_model_quantize(const char * fname_inp, const char * fname_out,
                              const struct llama_model_quantize_params * params);

Used by tools/quantize. See Quantization.