SDKs
Rust SDK
Install and use the Assisters Rust SDK
Installation
Add to Cargo.toml:
[dependencies]
assisters = "0.1"
tokio = { version = "1", features = ["full"] }Quick Start
use assisters::{Client, types::ChatMessage};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = Client::new(std::env::var("ASSISTERS_API_KEY")?);
let response = client
.chat()
.completions()
.create(assisters::types::ChatCompletionRequest {
model: "assisters-chat-v1".into(),
messages: vec![ChatMessage {
role: "user".into(),
content: "Hello, world!".into(),
}],
..Default::default()
})
.await?;
println!("{}", response.choices[0].message.content);
Ok(())
}Available Methods
| Method | Description |
|---|---|
client.chat().completions().create(req) | Create a chat completion |
client.chat().completions().create_stream(req) | Create a streaming chat completion, returns impl Stream<Item = ChatCompletionChunk> |
client.embeddings().create(req) | Generate embeddings for one or more inputs |
client.moderations().create(req) | Moderate text content |
client.rerank().create(req) | Rerank documents against a query |
client.models().list() | List available models |
client.audio().transcriptions().create(req) | Transcribe audio to text |
Key Types
pub struct ChatCompletionRequest {
pub model: String,
pub messages: Vec<ChatMessage>,
pub temperature: Option<f32>,
pub max_tokens: Option<u32>,
pub stream: Option<bool>,
}
pub struct ChatMessage {
pub role: String, // "system" | "user" | "assistant"
pub content: String,
}
pub struct EmbeddingRequest {
pub model: String,
pub input: Vec<String>,
}
pub struct RerankRequest {
pub model: String,
pub query: String,
pub documents: Vec<String>,
pub top_n: Option<u32>,
}Streaming
use futures_util::StreamExt;
let mut stream = client
.chat()
.completions()
.create_stream(ChatCompletionRequest {
model: "assisters-chat-v1".into(),
messages: vec![ChatMessage { role: "user".into(), content: "Tell me a story".into() }],
stream: Some(true),
..Default::default()
})
.await?;
while let Some(chunk) = stream.next().await {
let chunk = chunk?;
if let Some(content) = &chunk.choices[0].delta.content {
print!("{content}");
}
}Error Handling
use assisters::error::AssistersError;
match client.chat().completions().create(req).await {
Ok(resp) => println!("{}", resp.choices[0].message.content),
Err(AssistersError::Api { status, message }) => {
eprintln!("API error {status}: {message}");
}
Err(AssistersError::Network(e)) => {
eprintln!("Network error: {e}");
}
Err(e) => eprintln!("Error: {e}"),
}