Struct ExtractBuilder 

pub struct ExtractBuilder<'a, T> { /* private fields */ }

Builder for configuring an extraction request.

Created by Client::extract. Call .await to execute the request.

Implementations

impl<T> ExtractBuilder<'_, T>

where T: DeserializeOwned + JsonSchema,

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

Override the model for this request.

pub fn system(self, system: impl Into<String>) -> Self

Override the system prompt for this request.

pub fn temperature(self, temp: f64) -> Self

Set the temperature (0.0 = deterministic, 1.0 = creative).

pub fn max_tokens(self, tokens: u32) -> Self

Set the maximum output tokens.

pub fn max_retries(self, retries: u32) -> Self

Set the maximum retry attempts on parse/validation failure.

pub fn context(self, ctx: impl Into<String>) -> Self

Add extra context to the prompt.

pub fn messages(self, msgs: Vec<Message>) -> Self

Set prior message history for multi-turn conversations.

Messages are prepended before the extraction prompt.

use instructors::Message;

#[derive(Deserialize, JsonSchema)]
struct Summary { text: String }

let client = instructors::Client::openai("sk-...");
let result = client.extract::<Summary>("summarize the above")
    .messages(vec![
        Message::user("Here is a long document..."),
        Message::assistant("I see the document."),
    ])
    .await?;

pub fn on_request<F>(self, f: F) -> Self

where F: Fn(&str, &str) + Send + Sync + 'static,

Register a hook called before each API request.

Receives (model, prompt).

pub fn on_response<F>(self, f: F) -> Self

where F: Fn(&Usage) + Send + Sync + 'static,

Register a hook called after a successful extraction.

Receives the final Usage.

pub fn validate<F>(self, f: F) -> Self

where F: Fn(&T) -> Result<(), ValidationError> + Send + Sync + 'static,

Add a custom validation function. If validation fails, the error message is fed back to the LLM and the request is retried.

#[derive(Deserialize, JsonSchema)]
struct User { name: String, age: u32 }

let client = instructors::Client::openai("sk-...");
let user: User = client.extract("...")
    .validate(|u: &User| {
        if u.age > 150 { Err("age must be <= 150".into()) } else { Ok(()) }
    })
    .await?.value;

impl<T> ExtractBuilder<'_, T>

where T: DeserializeOwned + JsonSchema + Validate,

pub fn validated(self) -> Self

Enable trait-based validation. Calls T::validate() after deserialization. If validation fails, the error is fed back to the LLM for retry.

Requires T: Validate.

#[derive(Deserialize, JsonSchema)]
struct Email { address: String }

impl Validate for Email {
    fn validate(&self) -> Result<(), ValidationError> {
        if self.address.contains('@') { Ok(()) }
        else { Err("invalid email".into()) }
    }
}

let client = instructors::Client::openai("sk-...");
let email: Email = client.extract("...").validated().await?.value;

Trait Implementations

impl<'a, T> IntoFuture for ExtractBuilder<'a, T>

where T: DeserializeOwned + JsonSchema + Send + 'static,

type Output = Result<ExtractResult<T>, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <ExtractBuilder<'a, T> as IntoFuture>::Output> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.