Embeddings & Rerank

Embeddings

Generate vector embeddings from text or multimodal content. Embeddings are fixed-length numeric arrays that capture semantic meaning – useful for search, clustering, and RAG.

Basic embedding request for a single input string

import asyncio
import os
from liter_llm import create_client
from liter_llm._internal_bindings import EmbeddingRequest

async def main() -> None:
    client = create_client(api_key=os.environ["API_KEY"])
    req = EmbeddingRequest.from_json("{\"input\":\"Hello world\",\"model\":\"text-embedding-3-small\"}")
    result = await client.embed(req)
    print(result.data)
    print(result.data[0].embedding)

asyncio.run(main())

Basic embedding request for a single input string

import { createClient } from "@xberg-io/liter-llm";
async function main() {
  const client = createClient("your-api-key");
  const result = await client.embed({ input: "Hello world", model: "text-embedding-3-small" });
  console.log(result.data);
  console.log(result.data[0].embedding);
}

void main();

Basic embedding request for a single input string

use liter_llm::BatchClient;
use liter_llm::FileClient;
use liter_llm::LlmClient;
use liter_llm::ResponseClient;

#[tokio::main]
async fn main() {
    let req_json: serde_json::Value = serde_json::from_str(r#"{"input":"Hello world","model":"text-embedding-3-small"}"#).unwrap();
    let req = serde_json::from_value(req_json).unwrap();
    let client = liter_llm::create_client(std::env::var("API_KEY").expect("API_KEY must be set"), None, None, None, None).unwrap();
    let result = client.embed(req).await.expect("call failed");
    println!("{:?}", result.data);
    println!("{:?}", result.data[0].embedding);
}

Basic embedding request for a single input string

package main

import (
  "fmt"
  pkg "github.com/xberg-io/liter-llm/packages/go/v2"
)

func main() {
  req := pkg.EmbeddingRequest{
    Model: `text-embedding-3-small`,
    Input: pkg.EmbeddingInput(`Hello world`),
  }
    client, clientErr := pkg.CreateClient("your-api-key", nil, nil, nil, nil)
  if clientErr != nil {
    panic(clientErr)
  }
  defer client.Free()
  result, err := client.Embed(req)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result.Data)
  fmt.Printf("%+v\n", result.Data[0].Embedding)
}

Basic embedding request for a single input string

import io.xberg.literllm.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var reqJson = "{\"input\":\"Hello world\",\"model\":\"text-embedding-3-small\"}";
        var req = JsonUtil.fromJson(reqJson, EmbeddingRequest.class);
        var apiKey = System.getenv("API_KEY");
        if (apiKey == null || apiKey.isEmpty()) throw new IllegalStateException("API_KEY must be set");
        try (var client = LiterLlm.createClient(apiKey, null, null, null, null)) {
        var result = client.embed(req);
        System.out.println(result.data());
        System.out.println(result.data().get(0).embedding());
        }
    }
}

Basic embedding request for a single input string

using System;
using System.Text.Json;
using LiterLlm;

var ConfigOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
var apiKey = Environment.GetEnvironmentVariable("API_KEY") ??
  throw new InvalidOperationException("API_KEY must be set");
  using var client = LiterLlmConverter.CreateClient(apiKey, null, null, null, null);
var result = await client.EmbedAsync(new EmbeddingRequest { Input = JsonSerializer.Deserialize<EmbeddingInput>("\"Hello world\"", ConfigOptions)!, Model = "text-embedding-3-small" });
Console.WriteLine(result.Data);
Console.WriteLine(result.Data[0].Embedding);

Basic embedding request for a single input string

require "liter_llm"
result = LiterLlm.embed(LiterLlm::EmbeddingRequest.new(input: 'Hello world', model: 'text-embedding-3-small'))
puts result.data.inspect
puts result.data[0].embedding.inspect

Basic embedding request for a single input string

<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use Liter\Llm\LiterLlm;
use Liter\Llm\EmbeddingRequest;
$req = \Liter\Llm\EmbeddingRequest::from_json(json_encode(["input" => "Hello world", "model" => "text-embedding-3-small"]));
$result = LiterLlm::embed($req);
var_dump($result->getData());
var_dump($result->getData()[0]->embedding);

Basic embedding request for a single input string

api_key = System.fetch_env!("API_KEY")
{:ok, client} = LiterLlm.create_client(api_key)
result = LiterLlm.defaultclient_embed_async(client, "{\"input\":\"Hello world\",\"model\":\"text-embedding-3-small\"}")
IO.inspect(result.data)
IO.inspect(Enum.at(result.data, 0).embedding)

Basic embedding request for a single input string

import { WasmEmbeddingRequest, createClient } from "@xberg-io/liter-llm-wasm";
async function main() {
  const req: WasmEmbeddingRequest = (() => { const _u0 = WasmEmbeddingRequest.default(); _u0.input = "Hello world"; _u0.model = "text-embedding-3-small"; return _u0; })();
  const client = createClient("your-api-key");
  try {
    const result = await client.embed(req);
    console.log(result.data);
    console.log(result.data[0].embedding);
  } finally {
    client.free();
  }
}

void main();

Embedding Parameters

Parameter	Type	Description
`model`	string	Embedding model (e.g. `"openai/text-embedding-3-small"`)
`input`	string/array	Text, text batches, or tagged text and image parts
`encoding_format`	string	Output format (`"float"` or `"base64"`)
`dimensions`	int	Output dimensionality (model-dependent)

Embedding Providers

Provider	Prefix	Example Model
OpenAI	`openai/`	`text-embedding-3-small`, `text-embedding-3-large`
Cohere	`cohere/`	`embed-english-v3.0`
Voyage AI	`voyage/`	`voyage-3`
Mistral	`mistral/`	`mistral-embed`
Google Vertex AI	`vertex_ai/`	`text-embedding-004`
AWS Bedrock	`bedrock/`	`amazon.titan-embed-text-v2:0`
Ollama	`ollama/`	`nomic-embed-text`
LM Studio	`lmstudio/`	Depends on loaded model
vLLM	`vllm/`	`BAAI/bge-base-en-v1.5`
llama.cpp	`llamacpp/`	Depends on loaded GGUF
LocalAI	`localai/`	Depends on configuration
llamafile	`llamafile/`	Depends on loaded model
Jina AI	`jina_ai/`	`jina-embeddings-v3`

See the Providers page for the complete capability matrix.

Multimodal RAG

Send a tagged array of text and image parts to a multimodal-compatible custom or self-hosted embedding endpoint:

use liter_llm::types::{EmbeddingContentPart, EmbeddingInput, EmbeddingRequest};

let request = EmbeddingRequest {
    model: "custom/multimodal-embedding".into(),
    input: EmbeddingInput::Multimodal(vec![
        EmbeddingContentPart::text("product photo"),
        EmbeddingContentPart::image_url("https://example.com/product.png"),
    ]),
    ..Default::default()
};

Use EmbeddingContentPart::image_bytes to encode raw bytes as a data URL. The custom endpoint must accept the tagged multimodal payload. The built-in Bedrock, Google AI, and Vertex AI embedding adapters remain text-only and return a bad-request error for multimodal input.

Store the source image alongside its vector and pass a retrieved match directly into a chat request:

use liter_llm::types::ImageUrl;

metadata.image_url = Some(ImageUrl {
    url: "https://example.com/product.png".into(),
    detail: None,
});

if let Some(image_part) = matched.metadata.image_content_part() {
    // ~keep Add image_part to UserContent::Parts for a vision-capable chat model.
}

Existing EmbeddingProvider implementations must change embed to accept &EmbeddingInput instead of &str. Existing VectorMetadata literals must set image_url, usually to None.