Struct OpenAIClientBuilder

pub struct OpenAIClientBuilder { /* private fields */ }

Implementations

impl OpenAIClientBuilder

pub fn new() -> Self

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

Examples found in repository

examples/audio_translations.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let req = AudioTranslationRequest::new(
        "examples/data/problem_cn.mp3".to_string(),
        WHISPER_1.to_string(),
    );

    let result = client.audio_translation(req).await?;
    println!("{:?}", result);

    Ok(())
}

examples/embedding.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let mut req = EmbeddingRequest::new(
        TEXT_EMBEDDING_3_SMALL.to_string(),
        vec!["story time".to_string(), "Once upon a time".to_string()],
    );
    req.dimensions = Some(10);

    let result = client.embedding(req).await?;
    println!("{:?}", result.data);

    Ok(())
}

examples/model.rs (line 7)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let result = client.list_models().await?;
    let models = result.data;

    for model in models {
        println!("Model id: {:?}", model.id);
    }

    let result = client.retrieve_model("gpt-4.1".to_string()).await?;
    println!("Model id: {:?}", result.id);
    println!("Model object: {:?}", result.object);

    Ok(())
}

examples/audio_speech.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let req = AudioSpeechRequest::new(
        TTS_1.to_string(),
        String::from("Money is not the problem, the problem is no money."),
        audio::VOICE_ALLOY.to_string(),
        String::from("examples/data/problem.mp3"),
    );

    let result = client.audio_speech(req).await?;
    println!("{:?}", result);

    Ok(())
}

examples/completion.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let req = CompletionRequest::new(
        completion::GPT3_TEXT_DAVINCI_003.to_string(),
        String::from("What is Bitcoin?"),
    )
    .max_tokens(3000)
    .temperature(0.9)
    .top_p(1.0)
    .stop(vec![String::from(" Human:"), String::from(" AI:")])
    .presence_penalty(0.6)
    .frequency_penalty(0.0);

    let result = client.completion(req).await?;
    println!("{:}", result.choices[0].text);

    Ok(())
}

examples/openrouter.rs (line 11)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENROUTER_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder()
        .with_endpoint("https://openrouter.ai/api/v1")
        .with_api_key(api_key)
        .build()?;

    let req = ChatCompletionRequest::new(
        GPT4_O_MINI.to_string(),
        vec![chat_completion::ChatCompletionMessage {
            role: chat_completion::MessageRole::user,
            content: chat_completion::Content::Text(String::from("What is bitcoin?")),
            name: None,
            tool_calls: None,
            tool_call_id: None,
        }],
    );

    let result = client.chat_completion(req).await?;
    println!("Content: {:?}", result.choices[0].message.content);
    println!("Response Headers: {:?}", client.response_headers);

    Ok(())
}

Additional examples can be found in:

• examples/chat_completion.rs
• examples/audio_transcriptions.rs
• examples/vision.rs
• examples/batch.rs
• examples/openrouter_reasoning.rs
• examples/assistant.rs
• examples/function_call.rs
• examples/function_call_role.rs

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

Examples found in repository

examples/openrouter.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENROUTER_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder()
        .with_endpoint("https://openrouter.ai/api/v1")
        .with_api_key(api_key)
        .build()?;

    let req = ChatCompletionRequest::new(
        GPT4_O_MINI.to_string(),
        vec![chat_completion::ChatCompletionMessage {
            role: chat_completion::MessageRole::user,
            content: chat_completion::Content::Text(String::from("What is bitcoin?")),
            name: None,
            tool_calls: None,
            tool_call_id: None,
        }],
    );

    let result = client.chat_completion(req).await?;
    println!("Content: {:?}", result.choices[0].message.content);
    println!("Response Headers: {:?}", client.response_headers);

    Ok(())
}

examples/openrouter_reasoning.rs (line 11)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENROUTER_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder()
        .with_endpoint("https://openrouter.ai/api/v1")
        .with_api_key(api_key)
        .build()?;

    // Example 1: Using reasoning with effort
    let mut req = ChatCompletionRequest::new(
        "x-ai/grok-3-mini".to_string(), // Grok model that supports reasoning
        vec![chat_completion::ChatCompletionMessage {
            role: chat_completion::MessageRole::user,
            content: chat_completion::Content::Text(String::from(
                "Explain quantum computing in simple terms.",
            )),
            name: None,
            tool_calls: None,
            tool_call_id: None,
        }],
    );

    // Set reasoning with high effort
    req.reasoning = Some(Reasoning {
        mode: Some(ReasoningMode::Effort {
            effort: ReasoningEffort::High,
        }),
        exclude: Some(false), // Include reasoning in response
        enabled: None,
    });

    let result = client.chat_completion(req).await?;
    println!("Content: {:?}", result.choices[0].message.content);

    // Example 2: Using reasoning with max_tokens
    let mut req2 = ChatCompletionRequest::new(
        "anthropic/claude-4-sonnet".to_string(), // Claude model that supports max_tokens
        vec![chat_completion::ChatCompletionMessage {
            role: chat_completion::MessageRole::user,
            content: chat_completion::Content::Text(String::from(
                "What's the most efficient sorting algorithm?",
            )),
            name: None,
            tool_calls: None,
            tool_call_id: None,
        }],
    );

    // Set reasoning with max_tokens
    req2.reasoning = Some(Reasoning {
        mode: Some(ReasoningMode::MaxTokens { max_tokens: 2000 }),
        exclude: None,
        enabled: None,
    });

    let result2 = client.chat_completion(req2).await?;
    println!("Content: {:?}", result2.choices[0].message.content);

    Ok(())
}

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

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

pub fn with_timeout(self, timeout: u64) -> Self

pub fn with_header( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

pub fn build(self) -> Result<OpenAIClient, Box<dyn Error>>

Examples found in repository

examples/audio_translations.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let req = AudioTranslationRequest::new(
        "examples/data/problem_cn.mp3".to_string(),
        WHISPER_1.to_string(),
    );

    let result = client.audio_translation(req).await?;
    println!("{:?}", result);

    Ok(())
}

examples/embedding.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let mut req = EmbeddingRequest::new(
        TEXT_EMBEDDING_3_SMALL.to_string(),
        vec!["story time".to_string(), "Once upon a time".to_string()],
    );
    req.dimensions = Some(10);

    let result = client.embedding(req).await?;
    println!("{:?}", result.data);

    Ok(())
}

examples/model.rs (line 7)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let result = client.list_models().await?;
    let models = result.data;

    for model in models {
        println!("Model id: {:?}", model.id);
    }

    let result = client.retrieve_model("gpt-4.1".to_string()).await?;
    println!("Model id: {:?}", result.id);
    println!("Model object: {:?}", result.object);

    Ok(())
}

examples/audio_speech.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let req = AudioSpeechRequest::new(
        TTS_1.to_string(),
        String::from("Money is not the problem, the problem is no money."),
        audio::VOICE_ALLOY.to_string(),
        String::from("examples/data/problem.mp3"),
    );

    let result = client.audio_speech(req).await?;
    println!("{:?}", result);

    Ok(())
}

examples/completion.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENAI_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder().with_api_key(api_key).build()?;

    let req = CompletionRequest::new(
        completion::GPT3_TEXT_DAVINCI_003.to_string(),
        String::from("What is Bitcoin?"),
    )
    .max_tokens(3000)
    .temperature(0.9)
    .top_p(1.0)
    .stop(vec![String::from(" Human:"), String::from(" AI:")])
    .presence_penalty(0.6)
    .frequency_penalty(0.0);

    let result = client.completion(req).await?;
    println!("{:}", result.choices[0].text);

    Ok(())
}

examples/openrouter.rs (line 12)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("OPENROUTER_API_KEY").unwrap().to_string();
    let mut client = OpenAIClient::builder()
        .with_endpoint("https://openrouter.ai/api/v1")
        .with_api_key(api_key)
        .build()?;

    let req = ChatCompletionRequest::new(
        GPT4_O_MINI.to_string(),
        vec![chat_completion::ChatCompletionMessage {
            role: chat_completion::MessageRole::user,
            content: chat_completion::Content::Text(String::from("What is bitcoin?")),
            name: None,
            tool_calls: None,
            tool_call_id: None,
        }],
    );

    let result = client.chat_completion(req).await?;
    println!("Content: {:?}", result.choices[0].message.content);
    println!("Response Headers: {:?}", client.response_headers);

    Ok(())
}

Additional examples can be found in:

• examples/chat_completion.rs
• examples/audio_transcriptions.rs
• examples/vision.rs
• examples/batch.rs
• examples/openrouter_reasoning.rs
• examples/assistant.rs
• examples/function_call.rs
• examples/function_call_role.rs

Trait Implementations

impl Default for OpenAIClientBuilder

fn default() -> OpenAIClientBuilder

Returns the “default value” for a type.