Search & OCR

Search

Search the web or documents across 12 providers (Brave, Tavily, Google PSE, etc.):

Python

Basic web search request with a simple query

Python

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

async def main() -> None:
    client = create_client(api_key=os.environ["API_KEY"])
    req = SearchRequest.from_json("{\"model\":\"brave/web-search\",\"query\":\"What is Rust programming language?\"}")
    result = await client.search(req)
    print(result)

asyncio.run(main())

TypeScript

Basic web search request with a simple query

TypeScript

import { createClient } from "@xberg-io/liter-llm";
async function main() {
  const client = createClient("your-api-key");
  const result = await client.search({ model: "brave/web-search", query: "What is Rust programming language?" });
  console.log(result);
}

void main();

Rust

Basic web search request with a simple query

Rust

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#"{"model":"brave/web-search","query":"What is Rust programming language?"}"#).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.search(req).await;
    println!("{:?}", result);
}

Go

Basic web search request with a simple query

Go

package main

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

func main() {
  req := pkg.SearchRequest{
    Model: `brave/web-search`,
    Query: `What is Rust programming language?`,
  }
    client, clientErr := pkg.CreateClient("your-api-key", nil, nil, nil, nil)
  if clientErr != nil {
    panic(clientErr)
  }
  defer client.Free()
  result, err := client.Search(req)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result)
}

Java

Basic web search request with a simple query

Java

import io.xberg.literllm.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var reqJson = "{\"model\":\"brave/web-search\",\"query\":\"What is Rust programming language?\"}";
        var req = JsonUtil.fromJson(reqJson, SearchRequest.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.search(req);
        System.out.println(result);
        }
    }
}

C#

Basic web search request with a simple query

C#

using System;
using LiterLlm;

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.SearchAsync(new SearchRequest { Model = "brave/web-search", Query = "What is Rust programming language?" });
Console.WriteLine(result);

Ruby

Basic web search request with a simple query

Ruby

require "liter_llm"
result = LiterLlm.search(LiterLlm::SearchRequest.new(model: 'brave/web-search', query: 'What is Rust programming language?'))
puts result.inspect

PHP

Basic web search request with a simple query

PHP

<?php

declare(strict_types=1);

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

use Liter\Llm\LiterLlm;
use Liter\Llm\SearchRequest;
$result = LiterLlm::search(new \Liter\Llm\SearchRequest(model: "brave/web-search",
query: "What is Rust programming language?"));
var_dump($result);

Elixir

Basic web search request with a simple query

Elixir

api_key = System.fetch_env!("API_KEY")
{:ok, client} = LiterLlm.create_client(api_key)
result = LiterLlm.defaultclient_search_async(client, "{\"model\":\"brave/web-search\",\"query\":\"What is Rust programming language?\"}")
IO.inspect(result)

WASM

Basic web search request with a simple query

WebAssembly

import { WasmSearchRequest, createClient } from "@xberg-io/liter-llm-wasm";
async function main() {
  const req: WasmSearchRequest = (() => { const _u0 = WasmSearchRequest.default(); _u0.model = "brave/web-search"; _u0.query = "What is Rust programming language?"; return _u0; })();
  const client = createClient("your-api-key");
  try {
    const result = await client.search(req);
    console.log(result);
  } finally {
    client.free();
  }
}

void main();

Search Parameters

Parameter	Type	Description
model	string	Search provider (e.g. "brave/web-search")
query	string	Search query
max_results	int	Maximum results to return
search_domain_filter	array	Restrict to specific domains
country	string	ISO country code for localized results

Search Providers

The registry ships 12 search providers. Browse the full Providers capability matrix; the most common are:

Provider	Prefix
Brave	brave/
Tavily	tavily/
Google PSE	google_pse/
Serper	serper/
DuckDuckGo	duckduckgo/
Exa	exa_ai/
Firecrawl	firecrawl/
Linkup	linkup/
Parallel AI	parallel_ai/
Perplexity	perplexity/
SearXNG	searxng/
DataForSEO	dataforseo/

OCR

Extract text from documents via OCR across 4 providers (Mistral, Azure Doc Intelligence, etc.):

Python

OCR request with a document URL input

Python

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

async def main() -> None:
    client = create_client(api_key=os.environ["API_KEY"])
    req = OcrRequest.from_json("{\"document\":{\"type\":\"document_url\",\"url\":\"https://example.com/doc.pdf\"},\"model\":\"mistral/mistral-ocr-latest\"}")
    result = await client.ocr(req)
    print(result)

asyncio.run(main())

TypeScript

OCR request with a document URL input

TypeScript

import { OcrDocument, createClient } from "@xberg-io/liter-llm";
async function main() {
  const client = createClient("your-api-key");
  const result = await client.ocr({ document: { type: "document_url", url: "https://example.com/doc.pdf" } as OcrDocument, model: "mistral/mistral-ocr-latest" });
  console.log(result);
}

void main();

Rust

OCR request with a document URL input

Rust

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#"{"document":{"type":"document_url","url":"https://example.com/doc.pdf"},"model":"mistral/mistral-ocr-latest"}"#).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.ocr(req).await;
    println!("{:?}", result);
}

Go

OCR request with a document URL input

Go

package main

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

func main() {
  req := pkg.OcrRequest{
    Model:    `mistral/mistral-ocr-latest`,
    Document: pkg.OcrDocumentURL{URL: `https://example.com/doc.pdf`},
  }
    client, clientErr := pkg.CreateClient("your-api-key", nil, nil, nil, nil)
  if clientErr != nil {
    panic(clientErr)
  }
  defer client.Free()
  result, err := client.Ocr(req)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result)
}

Java

OCR request with a document URL input

Java

import io.xberg.literllm.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var reqJson = "{\"document\":{\"type\":\"document_url\",\"url\":\"https://example.com/doc.pdf\"},\"model\":\"mistral/mistral-ocr-latest\"}";
        var req = JsonUtil.fromJson(reqJson, OcrRequest.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.ocr(req);
        System.out.println(result);
        }
    }
}

C#

OCR request with a document URL input

C#

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.OcrAsync(new OcrRequest { Document = JsonSerializer.Deserialize<OcrDocument>("{\"type\":\"document_url\",\"url\":\"https://example.com/doc.pdf\"}", ConfigOptions)!, Model = "mistral/mistral-ocr-latest" });
Console.WriteLine(result);

Ruby

OCR request with a document URL input

Ruby

require "liter_llm"
result = LiterLlm.ocr(LiterLlm::OcrRequest.new(document: { 'type' => 'document_url', 'url' => 'https://example.com/doc.pdf' }, model: 'mistral/mistral-ocr-latest'))
puts result.inspect

PHP

OCR request with a document URL input

PHP

<?php

declare(strict_types=1);

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

use Liter\Llm\LiterLlm;
use Liter\Llm\OcrRequest;
$req = \Liter\Llm\OcrRequest::from_json(json_encode(["document" => ["type" => "document_url", "url" => "https://example.com/doc.pdf"], "model" => "mistral/mistral-ocr-latest"]));
$result = LiterLlm::ocr($req);
var_dump($result);

Elixir

OCR request with a document URL input

Elixir

api_key = System.fetch_env!("API_KEY")
{:ok, client} = LiterLlm.create_client(api_key)
result = LiterLlm.defaultclient_ocr_async(client, "{\"document\":{\"type\":\"document_url\",\"url\":\"https://example.com/doc.pdf\"},\"model\":\"mistral/mistral-ocr-latest\"}")
IO.inspect(result)

WASM

OCR request with a document URL input

WebAssembly

import { WasmOcrRequest, createClient } from "@xberg-io/liter-llm-wasm";
async function main() {
  const req: WasmOcrRequest = (() => { const _u0 = WasmOcrRequest.default(); _u0.document = { type: "document_url", url: "https://example.com/doc.pdf" }; _u0.model = "mistral/mistral-ocr-latest"; return _u0; })();
  const client = createClient("your-api-key");
  try {
    const result = await client.ocr(req);
    console.log(result);
  } finally {
    client.free();
  }
}

void main();

OCR Parameters

Parameter	Type	Description
model	string	OCR provider (e.g. "mistral/mistral-ocr-latest")
document	object	Document input (URL or base64)
pages	array	Specific pages to process (1-indexed)
include_image_base64	bool	Include extracted images

Document Input Formats

URL:

{ "type": "document_url", "url": "https://example.com/invoice.pdf" }

Base64:

{ "type": "base64", "data": "...", "media_type": "application/pdf" }