openai4rs 0.1.0

A non-official Rust crate for calling the OpenAI service
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

# openai4rs

[简体中文](README.md) | English

## Introduction

openai4rs is an unofficial Rust implementation based on `tokio` and `reqwest`, designed for asynchronous interaction with large language model providers following the OpenAI specification.

## Usage Guide

1. Chat functionality

- **Non-streaming**

```rust
use openai4rs::{OpenAI, chat_request, user};

#[tokio::main]
async fn main() {
    let base_url = "your base_url";
    let api_key = "your api_key";
    let client = OpenAI::new(api_key, base_url);
    let messages = vec![user!("hello")];
    let chat_completion = client
        .chat()
        .create(chat_request("your model name", &messages))
        .await
        .unwrap();
    println!("{:#?}", chat_completion);
}
```

- **Streaming**

```rust
use futures::StreamExt;
use openai4rs::{OpenAI, chat_request, user};

#[tokio::main]
async fn main() {
    let base_url = "your base_url";
    let api_key = "your api_key";
    let client = OpenAI::new(api_key, base_url);
    let messages = vec![user!("hello")];
    let mut stream = client
        .chat()
        .create_stream(chat_request("your model name", &messages))
        .await
        .unwrap();
    while let Some(result) = stream.next().await {
        let chat_completion_chunk = result.unwrap();
        println!("{:#?}", chat_completion_chunk);
    }
}
```

- **Using Tools**

```rust
use futures::StreamExt;
use openai4rs::{ChatCompletionToolParam, OpenAI, chat_request, user};

#[tokio::main]
async fn main() {
    let base_url = "your base_url";
    let api_key = "your api_key";
    let client = OpenAI::new(api_key, base_url);
    // Define tools
    let tools = vec![ChatCompletionToolParam::function(
        "get_time",
        "Get current time",
        serde_json::json!({
            "type": "object",
            "properties": {}
        }),
    )];

    let messages = vec![user!("What time is it now?")];
    let mut stream = client
        .chat()
        .create_stream(
            chat_request("your model name", &messages)
                .tools(tools.clone())
                .tool_choice(openai4rs::ToolChoice::Auto), // Choose tool mode
        )
        .await
        .unwrap();
    while let Some(result) = stream.next().await {
        match result {
            Ok(chunk) => {
                println!("{:#?}", chunk);
            }
            Err(err) => {
                println!("{:#?}", err);
            }
        }
    }
}
```

Reasoning Model
The model must support the reasoning functionality, for example, qwen's qwq-32b

```rust
use futures::StreamExt;
use openai4rs::{OpenAI, chat_request, user};

# [tokio::main]
async fn main() {
    let base_url = "your base_url";
    let api_key = "your api_key";
    let client = OpenAI::new(api_key, base_url);
    let messages = vec![user!("hello")];
    let mut stream = client
        .chat()
        .create_stream(chat_request("your model name", &messages))
        .await
        .unwrap();
    while let Some(result) = stream.next().await {
        let chat_completion_chunk = result.unwrap();
        for choice in chat_completion_chunk.choices.iter() {
            if choice.delta.is_reasoning() {
                println!("## REASONING\n{}", choice.delta.get_reasoning_str())
            }
            if let Some(content) = &choice.delta.content {
                if !content.is_empty() {
                    println!("## CONTENT\n{}", content);
                }
            }
        }
    }
}
```