Struct Credentials

pub struct Credentials { /* private fields */ }

Holds the API key and base URL for an Anthropic-compatible API.

This struct is used to authenticate requests to the Anthropic API. It can be created from environment variables or explicitly with an API key and base URL.

Implementations

impl Credentials

pub fn new(api_key: impl Into<String>, base_url: impl Into<String>) -> Self

Creates credentials with the given API key and base URL.

If the base URL is empty, it will use the default Anthropic API URL.

Examples

use anthropic_api::Credentials;

let credentials = Credentials::new("your-api-key", "");

pub fn from_env() -> Credentials

Fetches the credentials from the environment variables ANTHROPIC_API_KEY and ANTHROPIC_BASE_URL.

Panics

This function will panic if the ANTHROPIC_API_KEY variable is missing from the environment. If only the ANTHROPIC_BASE_URL variable is missing, it will use the default URL.

Examples

use anthropic_api::Credentials;

// Assumes ANTHROPIC_API_KEY is set in the environment
let credentials = Credentials::from_env();

Examples found in repository

examples/models.rs (line 6)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load credentials from environment variables
    let credentials = Credentials::from_env();

    // List all available models
    println!("Listing all available models:");
    let models = ModelList::builder()
        .credentials(credentials.clone())
        // Add the limit to the request if desired
        // .limit(5u32)
        .create()
        .await?;

    println!("Available models:");
    for model in &models.data {
        println!("- {} ({})", model.display_name, model.id);
    }

    // Get details for a specific model
    if let Some(first_model) = models.data.first() {
        println!("\nGetting details for model: {}", first_model.id);
        let model_details = Model::builder(&first_model.id)
            .credentials(credentials)
            .create()
            .await?;

        println!("Model details:");
        println!("  ID: {}", model_details.id);
        println!("  Name: {}", model_details.display_name);
        println!("  Created at: {}", model_details.created_at);
        println!("  Type: {}", model_details.model_type);
    }

    Ok(())
}

examples/tool_use.rs (line 28)

async fn main() {
    let credentials = Credentials::from_env();

    // Define a calculator tool
    let calculator_tool = Tool {
        name: "calculator".to_string(),
        description: "A calculator that can perform basic arithmetic operations".to_string(),
        input_schema: json!({
            "type": "object",
            "properties": {
                "operation": {
                    "type": "string",
                    "enum": ["add", "subtract", "multiply", "divide"]
                },
                "operands": {
                    "type": "array",
                    "items": {"type": "number"},
                    "minItems": 2,
                    "maxItems": 2
                }
            },
            "required": ["operation", "operands"]
        }),
    };

    let content =
        "You are a helpful AI assistant. Please calculate 15 + 27 using the calculator tool.";
    let mut messages = vec![Message {
        role: MessageRole::User,
        content: MessageContent::Text(content.to_string()),
    }];

    println!("Claude: {}", content);

    // Create message request with tool
    let response = MessagesResponse::builder("claude-3-7-sonnet-20250219", messages.clone(), 1024)
        .credentials(credentials.clone())
        .tools(vec![calculator_tool.clone()])
        .tool_choice(ToolChoice::Any)
        .create()
        .await
        .unwrap();

    // Print assistant's response and tool usage
    for content in response.content {
        match content {
            ResponseContentBlock::Text { text } => {
                println!("Assistant: {}", text.trim());
                messages.push(Message {
                    role: MessageRole::Assistant,
                    content: MessageContent::Text(text),
                });
            }
            ResponseContentBlock::ToolUse { name, input, .. } => {
                println!("Claude decided to use the tool: {}: {}", name, input);
            }
            ResponseContentBlock::Thinking {
                signature,
                thinking,
            } => {
                println!("Claude {} is thinking: {}", signature, thinking);
            }
            ResponseContentBlock::RedactedThinking { data } => {
                println!("Claude is thinking: {}", data);
            }
        }
    }
}

examples/message_cli.rs (line 28)

async fn main() {
    // Load .env file containing ANTHROPIC_API_KEY
    let credentials = Credentials::from_env();

    let mut messages = vec![Message {
        role: MessageRole::User,
        content: MessageContent::Text(
            "You are a helpful AI assistant. Please introduce yourself briefly.".to_string(),
        ),
    }];

    // Create initial message request
    let response = MessagesBuilder::builder("claude-3-7-sonnet-20250219", messages.clone(), 2048)
        .credentials(credentials.clone())
        // Uncomment this to enable thinking
        // .thinking(Thinking {
        //     thinking_type: ThinkingType::Enabled,
        //     budget_tokens: 1024,
        // })
        .create()
        .await
        .unwrap();

    // Print assistant's response
    if let Some(content) = response.content.first() {
        match content {
            ResponseContentBlock::Text { text } => {
                println!("Assistant: {}", text.trim());
                messages.push(Message {
                    role: MessageRole::Assistant,
                    content: MessageContent::Text(text.clone()),
                });
            }
            _ => {}
        }
    }

    // Start conversation loop
    loop {
        print!("User: ");
        stdout().flush().unwrap();

        let mut user_input = String::new();
        stdin().read_line(&mut user_input).unwrap();

        // Add user message
        messages.push(Message {
            role: MessageRole::User,
            content: MessageContent::Text(user_input),
        });

        // Send message request
        let response =
            MessagesResponse::builder("claude-3-7-sonnet-20250219", messages.clone(), 1024)
                .credentials(credentials.clone())
                .create()
                .await
                .unwrap();

        // Print assistant's response
        if let Some(content) = response.content.first() {
            match content {
                ResponseContentBlock::Text { text } => {
                    println!("Assistant: {}", text.trim());
                    messages.push(Message {
                        role: MessageRole::Assistant,
                        content: MessageContent::Text(text.clone()),
                    });
                }
                _ => {}
            }
        }
    }
}

examples/streaming.rs (line 29)

async fn main() {
    let credentials = Credentials::from_env();

    let mut messages = vec![Message {
        role: MessageRole::User,
        content: MessageContent::Text(
            "You are a helpful AI assistant. Please introduce yourself briefly.".to_string(),
        ),
    }];

    // Create initial message request with streaming
    let mut stream =
        MessagesResponse::builder("claude-3-7-sonnet-20250219", messages.clone(), 1024)
            .credentials(credentials.clone())
            .create_stream()
            .await
            .unwrap();

    // Print assistant's streaming response
    print!("Assistant: ");
    stdout().flush().unwrap();
    while let Some(event) = stream.recv().await {
        match event {
            StreamEvent::ContentBlockDelta { delta, .. } => {
                if let ContentBlockDelta::Text { text } = delta {
                    print!("{}", text);
                    stdout().flush().unwrap();
                }
            }
            StreamEvent::MessageStop => {
                println!();
            }
            _ => {}
        }
    }

    // Start conversation loop
    loop {
        print!("\nUser: ");
        stdout().flush().unwrap();

        let mut user_input = String::new();
        stdin().read_line(&mut user_input).unwrap();

        // Add user message
        messages.push(Message {
            role: MessageRole::User,
            content: MessageContent::Text(user_input),
        });

        // Send message request with streaming
        let mut stream =
            MessagesResponse::builder("claude-3-7-sonnet-20250219", messages.clone(), 1024)
                .credentials(credentials.clone())
                .create_stream()
                .await
                .unwrap();

        // Print assistant's streaming response and store the text
        print!("\nAssistant: ");
        stdout().flush().unwrap();
        let mut full_response = String::new();
        while let Some(event) = stream.recv().await {
            match event {
                StreamEvent::ContentBlockDelta { delta, .. } => {
                    if let ContentBlockDelta::Text { text } = delta {
                        print!("{}", text);
                        stdout().flush().unwrap();
                        full_response.push_str(&text);
                    }
                }
                StreamEvent::MessageStop => {
                    println!();
                }
                _ => {}
            }
        }

        // Add assistant's complete response to messages
        messages.push(Message {
            role: MessageRole::Assistant,
            content: MessageContent::Text(full_response),
        });
    }
}

pub fn api_key(&self) -> &str

Returns the API key

pub fn base_url(&self) -> &str

Returns the base URL

Trait Implementations

impl Clone for Credentials

fn clone(&self) -> Credentials

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Credentials

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

Formats the value using the given formatter.

impl PartialEq for Credentials

fn eq(&self, other: &Credentials) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Credentials

impl StructuralPartialEq for Credentials