Struct LlmClient 

pub struct LlmClient { /* private fields */ }

Unified LLM client.

This client provides:

• Unified interface for all LLM operations
• Automatic retry with exponential backoff
• Rate limiting and concurrency control
• JSON response parsing
• Error classification
• Graceful fallback on errors

Example

use vectorless::llm::{LlmClient, LlmConfig};

let config = LlmConfig::new("gpt-4o-mini");
let client = LlmClient::new(config);

// Simple completion
let response = client.complete("You are helpful.", "Hello!").await?;
println!("Response: {}", response);

// JSON completion
#[derive(serde::Deserialize)]
struct Answer {
    answer: String,
}
let answer: Answer = client.complete_json(
    "You answer questions in JSON.",
    "What is 2+2?"
).await?;

Implementations

impl LlmClient

pub fn new(config: LlmConfig) -> Self

Create a new LLM client with the given configuration.

pub fn with_defaults() -> Self

Create a client with default configuration.

pub fn for_model(model: impl Into<String>) -> Self

Create a client for a specific model.

pub fn with_concurrency(self, controller: ConcurrencyController) -> Self

Add concurrency control to the client.

Example

use vectorless::llm::LlmClient;
use vectorless::throttle::{ConcurrencyController, ConcurrencyConfig};

let config = ConcurrencyConfig::new()
    .with_max_concurrent_requests(10)
    .with_requests_per_minute(500);

let client = LlmClient::for_model("gpt-4o-mini")
    .with_concurrency(ConcurrencyController::new(config));

pub fn with_shared_concurrency( self, controller: Arc<ConcurrencyController>, ) -> Self

Add concurrency control from an existing Arc.

pub fn with_fallback(self, chain: FallbackChain) -> Self

Add fallback chain for error recovery.

Example

use vectorless::llm::{LlmClient, FallbackChain, FallbackConfig};

let fallback = FallbackConfig::default();
let client = LlmClient::for_model("gpt-4o")
    .with_fallback(FallbackChain::new(fallback));

assert!(client.fallback().is_some());

pub fn with_shared_fallback(self, chain: Arc<FallbackChain>) -> Self

Add fallback chain from an existing Arc.

pub fn config(&self) -> &LlmConfig

Get the configuration.

pub fn concurrency(&self) -> Option<&ConcurrencyController>

Get the concurrency controller (if any).

pub fn fallback(&self) -> Option<&FallbackChain>

Get the fallback chain (if any).

pub async fn complete(&self, system: &str, user: &str) -> LlmResult<String>

Complete a prompt with system and user messages.

This method includes:

• Automatic rate limiting (if configured)
• Automatic retry with exponential backoff

pub async fn complete_with_max_tokens( &self, system: &str, user: &str, max_tokens: u16, ) -> LlmResult<String>

Complete a prompt with custom max tokens.

pub async fn complete_json<T: DeserializeOwned>( &self, system: &str, user: &str, ) -> LlmResult<T>

Complete a prompt and parse the response as JSON.

This method handles:

• JSON extraction from markdown code blocks
• Bracket matching for nested JSON

Example

#[derive(serde::Deserialize)]
struct TocEntry {
    title: String,
    page: usize,
}

let client = LlmClient::for_model("gpt-4o-mini");
let entries: Vec<TocEntry> = client.complete_json(
    "Extract TOC entries as JSON array.",
    "Chapter 1: Introduction ... 5"
).await?;

pub async fn complete_json_with_max_tokens<T: DeserializeOwned>( &self, system: &str, user: &str, max_tokens: u16, ) -> LlmResult<T>

Complete a prompt and parse the response as JSON with custom max tokens.

Trait Implementations

impl Clone for LlmClient

fn clone(&self) -> LlmClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LlmClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LlmClient

fn default() -> Self

Returns the “default value” for a type.