gems 0.1.4

💎 A cli, tui, and sdk for interacting with the Gemini API (WIP)
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

use crate::client::Client;
use crate::messages::Message;
use crate::models::Model;
use crate::requests::Content;
use crate::requests::GeminiEmbedRequest;
use crate::requests::GeminiEmbedRequests;
use crate::responses::BatchEmbedContentsResponse;
use crate::responses::EmbedContentResponse;
use crate::traits::CTrait;
use anyhow::Result;
use derive_builder::Builder;
use reqwest::Method;

#[derive(Builder, Default, Clone)]
#[builder(setter(into), default)]
pub struct Embedding {
    pub model: Model,
    pub input: Message,
}

#[derive(Builder, Default, Clone)]
#[builder(setter(into), default)]
pub struct BatchEmbedding {
    pub model: Model,
    pub input: Vec<Message>,
}

#[derive(Clone)]
pub struct Embeddings {
    pub client: Client,
}

impl Embeddings {
    pub async fn create(&self, params: Embedding) -> Result<EmbedContentResponse> {
        let request_body = GeminiEmbedRequest {
            model: format!("models/{}", params.model.to_string()),
            content: Content {
                parts: vec![params.input.to_part()],
            },
        };

        let req = self
            .client
            .request(Method::POST, "embedContent")?
            .json(&request_body);

        let res = req.send().await?;
        Ok(res.json().await?)
    }

    pub async fn batch(&self, params: BatchEmbedding) -> Result<BatchEmbedContentsResponse> {
        let requests = params
            .input
            .into_iter()
            .map(|message| GeminiEmbedRequest {
                model: format!("models/{}", params.model.to_string()),
                content: Content {
                    parts: vec![message.to_part()],
                },
            })
            .collect::<Vec<GeminiEmbedRequest>>();

        let request_body = GeminiEmbedRequests { requests };

        let req = self
            .client
            .request(Method::POST, "batchEmbedContents")?
            .json(&request_body);

        let res = req.send().await?;
        Ok(res.json().await?)
    }
}