rustglm 1.0.0

Production-oriented async Rust SDK for Zhipu GLM, Realtime, Batch, RAG, and MCP
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

use std::path::Path;

use rustglm::{
    DocumentChunking, DocumentListQuery, RagDocumentUpload, ReEmbeddingRequest, UrlDocument,
    UrlDocumentUploadRequest, ZhipuClient,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = std::env::args().skip(1);
    let operation = args.next().unwrap_or_else(|| "list".to_owned());
    let client = ZhipuClient::new(std::env::var("ZHIPU_API_KEY")?)?;
    match operation.as_str() {
        "list" => {
            let knowledge_id = args
                .next()
                .ok_or("knowledge_documents list <knowledge-id>")?;
            println!(
                "{:#?}",
                client
                    .knowledge_documents(&DocumentListQuery::new(knowledge_id))
                    .await?
            );
        }
        "upload" => {
            let knowledge_id = args
                .next()
                .ok_or("knowledge_documents upload <knowledge-id> <file>")?;
            let input = args
                .next()
                .ok_or("knowledge_documents upload <knowledge-id> <file>")?;
            let path = Path::new(&input);
            let file_name = path
                .file_name()
                .and_then(|value| value.to_str())
                .ok_or("path must have a UTF-8 file name")?;
            let request = RagDocumentUpload::from_bytes(file_name, std::fs::read(path)?);
            println!(
                "{:#?}",
                client
                    .upload_knowledge_document(&knowledge_id, request)
                    .await?
            );
        }
        "url" => {
            let knowledge_id = args
                .next()
                .ok_or("knowledge_documents url <knowledge-id> <url>")?;
            let url = args
                .next()
                .ok_or("knowledge_documents url <knowledge-id> <url>")?;
            let request = UrlDocumentUploadRequest {
                knowledge_id,
                upload_detail: vec![UrlDocument::new(url, DocumentChunking::Heading)],
            };
            println!("{:#?}", client.upload_knowledge_urls(&request).await?);
        }
        "get" => {
            let id = args.next().ok_or("knowledge_documents get <document-id>")?;
            println!("{:#?}", client.knowledge_document(&id).await?);
        }
        "images" => {
            let id = args
                .next()
                .ok_or("knowledge_documents images <document-id>")?;
            println!("{:#?}", client.knowledge_document_images(&id).await?);
        }
        "reembed" => {
            let id = args
                .next()
                .ok_or("knowledge_documents reembed <document-id>")?;
            println!(
                "{:#?}",
                client
                    .reembed_knowledge_document(&id, &ReEmbeddingRequest::default())
                    .await?
            );
        }
        "delete" => {
            let id = args
                .next()
                .ok_or("knowledge_documents delete <document-id>")?;
            println!("{:#?}", client.delete_knowledge_document(&id).await?);
        }
        _ => {
            return Err(
                "operation must be list, upload, url, get, images, reembed, or delete".into(),
            );
        }
    }
    Ok(())
}