use_completions/
use_completions.rs

1use schemars::JsonSchema;
2use serde::Deserialize;
3use serde::Serialize;
4
5use allms::{
6    llm::{
7        AnthropicModels, AwsBedrockModels, DeepSeekModels, GoogleModels, LLMModel, MistralModels,
8        OpenAIModels, PerplexityModels, XAIModels,
9    },
10    Completions,
11};
12
13#[derive(Deserialize, Serialize, JsonSchema, Debug, Clone)]
14struct TranslationResponse {
15    pub spanish: String,
16    pub french: String,
17    pub german: String,
18    pub polish: String,
19}
20
21#[tokio::main]
22async fn main() {
23    env_logger::init();
24
25    // Example context and instructions
26    let instructions =
27        "Translate the following English sentence to all the languages in the response type: Rust is best for working with LLMs";
28
29    // Get answer using AWS Bedrock Converse
30    // AWS Bedrock SDK requires `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment variables to be defined and matching your AWS account
31    let model = AwsBedrockModels::try_from_str("amazon.nova-lite-v1:0")
32        .unwrap_or(AwsBedrockModels::NovaLite); // Choose the model
33    println!("AWS Bedrock model: {:#?}", model.as_str());
34
35    let aws_completion = Completions::new(model, "", None, None);
36
37    match aws_completion
38        .get_answer::<TranslationResponse>(instructions)
39        .await
40    {
41        Ok(response) => println!("AWS Bedrock response: {:#?}", response),
42        Err(e) => eprintln!("Error: {:?}", e),
43    }
44
45    // Get answer using OpenAI Completions API
46    let openai_api_key: String = std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY not set");
47    let model = OpenAIModels::try_from_str("gpt-5.4").unwrap_or(OpenAIModels::Gpt5_4); // Choose the model
48    println!("OpenAI model: {:#?}", model.as_str());
49
50    let openai_completion = Completions::new(model, &openai_api_key, None, None);
51
52    match openai_completion
53        .get_answer::<TranslationResponse>(instructions)
54        .await
55    {
56        Ok(response) => println!("OpenAI Completions API response: {:#?}", response),
57        Err(e) => eprintln!("Error: {:?}", e),
58    }
59
60    // Get answer using OpenAI (on Azure)
61    // Ensure `OPENAI_API_URL` is set to your Azure OpenAI resource endpoint
62    let azure_openai_completion =
63        Completions::new(OpenAIModels::Gpt5_2, &openai_api_key, None, None)
64            .version("azure:2024-08-01-preview");
65    match azure_openai_completion
66        .get_answer::<TranslationResponse>(instructions)
67        .await
68    {
69        Ok(response) => println!("Azure OpenAI response: {:#?}", response),
70        Err(e) => eprintln!("Error: {:?}", e),
71    }
72
73    // Get answer using Anthropic
74    let anthropic_api_key: String =
75        std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY not set");
76    let model = AnthropicModels::try_from_str("claude-haiku-4-5")
77        .unwrap_or(AnthropicModels::Claude4_5Haiku); // Choose the model
78    println!("Anthropic model: {:#?}", model.as_str());
79
80    let anthropic_completion = Completions::new(model, &anthropic_api_key, None, None);
81
82    match anthropic_completion
83        .get_answer::<TranslationResponse>(instructions)
84        .await
85    {
86        Ok(response) => println!("Anthropic response: {:#?}", response),
87        Err(e) => eprintln!("Error: {:?}", e),
88    }
89
90    // Get answer using Mistral
91    let mistral_api_key: String =
92        std::env::var("MISTRAL_API_KEY").expect("MISTRAL_API_KEY not set");
93    let model = MistralModels::try_from_str("mistral-medium-latest")
94        .unwrap_or(MistralModels::MistralMedium3_1); // Choose the model
95    println!("Mistral model: {:#?}", model.as_str());
96
97    let mistral_completion = Completions::new(model, &mistral_api_key, None, None);
98
99    match mistral_completion
100        .get_answer::<TranslationResponse>(instructions)
101        .await
102    {
103        Ok(response) => println!("Mistral response: {:#?}", response),
104        Err(e) => eprintln!("Error: {:?}", e),
105    }
106
107    // Get answer using Google Studio
108    let model = GoogleModels::try_from_str("gemini-2.5-flash-lite")
109        .unwrap_or(GoogleModels::Gemini2_5FlashLite); // Choose the model
110    println!("Google Gemini model: {:#?}", model.as_str());
111
112    let google_token_str: String =
113        std::env::var("GOOGLE_AI_STUDIO_API_KEY").expect("GOOGLE_AI_STUDIO_API_KEY not set");
114
115    let gemini_completion =
116        Completions::new(model, &google_token_str, None, None).version("google-studio");
117
118    match gemini_completion
119        .get_answer::<TranslationResponse>(instructions)
120        .await
121    {
122        Ok(response) => println!("Gemini response: {:#?}", response),
123        Err(e) => eprintln!("Error: {:?}", e),
124    }
125
126    // Get answer using Perplexity
127    let model = PerplexityModels::try_from_str("sonar-pro").unwrap_or(PerplexityModels::Sonar); // Choose the model
128    println!("Perplexity model: {:#?}", model.as_str());
129
130    let perplexity_token_str: String =
131        std::env::var("PERPLEXITY_API_KEY").expect("PERPLEXITY_API_KEY not set");
132
133    let perplexity_completion = Completions::new(model, &perplexity_token_str, None, None);
134
135    match perplexity_completion
136        .get_answer::<TranslationResponse>(instructions)
137        .await
138    {
139        Ok(response) => println!("Perplexity response: {:#?}", response),
140        Err(e) => eprintln!("Error: {:?}", e),
141    }
142
143    // Get answer using DeepSeek
144    let model =
145        DeepSeekModels::try_from_str("deepseek-chat").unwrap_or(DeepSeekModels::DeepSeekChat); // Choose the model
146    println!("DeepSeek model: {:#?}", model.as_str());
147
148    let deepseek_token_str: String =
149        std::env::var("DEEPSEEK_API_KEY").expect("DEEPSEEK_API_KEY not set");
150
151    let deepseek_completion = Completions::new(model, &deepseek_token_str, None, None);
152
153    match deepseek_completion
154        .get_answer::<TranslationResponse>(instructions)
155        .await
156    {
157        Ok(response) => println!("DeepSeek response: {:#?}", response),
158        Err(e) => eprintln!("Error: {:?}", e),
159    }
160
161    // Get answer using xAI Grok
162    let xai_api_key: String = std::env::var("XAI_API_KEY").expect("XAI_API_KEY not set");
163    let model = XAIModels::try_from_str("grok-3-mini").unwrap_or(XAIModels::Grok3Mini); // Choose the model
164    println!("xAI Grok model: {:#?}", model.as_str());
165
166    let xai_completion = Completions::new(model, &xai_api_key, None, None);
167
168    match xai_completion
169        .get_answer::<TranslationResponse>(instructions)
170        .await
171    {
172        Ok(response) => println!("xAI Grok response: {:#?}", response),
173        Err(e) => eprintln!("Error: {:?}", e),
174    }
175}
use_completions/use_completions.rs

use_completions/
use_completions.rs
