Struct clust::Client

pub struct Client { /* private fields */ }

The API client.

Implementations

impl Client

pub fn from_env() -> Result<Self, VarError>

Create a new API client with the API key loaded from the environment variable: ANTHROPIC_API_KEY and default options.

Example

use clust::Client;

let client = Client::from_env().unwrap();

pub fn from_api_key(api_key: ApiKey) -> Self

Create a new API client with the API key and default options.

Arguments

• api_key - The API key.

Example

use clust::Client;

let api_key = clust::ApiKey::new("api-key");

let client = Client::from_api_key(api_key);

impl Client

pub async fn create_a_message( &self, request_body: MessagesRequestBody ) -> Result<MessagesResponseBody, MessagesError>

Create a Message.

Send a structured list of input messages with text and/or image content, and the model will generate the next message in the conversation.

The Messages API can be used for either single queries or stateless multi-turn conversations.

See also Create a Message.

Arguments

• request_body - The request body.

NOTE

The stream option must be None or StreamOption::ReturnOnce.

Example

use clust::Client;
use clust::messages::{MessagesRequestBody, ClaudeModel, Message, Role, MaxTokens};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = Client::from_env()?;
    let model = ClaudeModel::Claude3Sonnet20240229;
    let max_tokens = MaxTokens::new(1024, model)?;
    let request_body = MessagesRequestBody {
        model,
        max_tokens,
        messages: vec![
            Message::user("Hello, Claude!"),
        ],
        ..Default::default()
    };

    let response = client
        .create_a_message(request_body)
        .await?;

    Ok(())
}

pub async fn create_a_message_stream( &self, request_body: MessagesRequestBody ) -> Result<impl Stream<Item = Result<MessageChunk, StreamError>>, MessagesError>

Create a Message with incrementally streaming the response using server-sent events (SSE).

See also Streaming Messages.

Arguments

• request_body - The request body.

NOTE

The stream option must be StreamOption::ReturnStream.

Example

use clust::Client;
use clust::messages::{MessagesRequestBody, ClaudeModel, Message, Role, MaxTokens, StreamOption};
use tokio_stream::StreamExt; // or futures_util::StreamExt to `stream.next().await`.

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = Client::from_env()?;
    let model = ClaudeModel::Claude3Sonnet20240229;
    let max_tokens = MaxTokens::new(1024, model)?;
    let request_body = MessagesRequestBody {
        model,
        max_tokens,
        messages: vec![
            Message::user("Hello, Claude!"),
        ],
        stream: Some(StreamOption::ReturnStream),
        ..Default::default()
    };

    let mut stream = client
        .create_a_message_stream(request_body)
        .await?;

    while let Some(chunk) = stream.next().await {
        match chunk {
            Ok(chunk) => {
                // Process the chunk.
            }
            Err(error) => {
                // Handle the error.
            }
        }
    }

    Ok(())
}

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.