cnb 0.2.0

CNB (cnb.cool) API client for Rust — typed, async, production-ready
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
134
135
136
137
138
139
140

// @generated DO NOT EDIT.
//
// Generated from the CNB OpenAPI specification by `cnb-codegen`.
// Run `cargo run -p cnb-codegen --manifest-path codegen/Cargo.toml \
//      -- --spec codegen/spec/swagger.json --out src` to refresh.

#![allow(clippy::all)]
#![allow(missing_docs)]
#![allow(unused_imports)]
#![allow(unused_mut)]

use reqwest::Method;
use serde::Serialize;

use crate::error::{ApiError, Result};
use crate::http::HttpInner;
use crate::models;

// `KnowledgeBase` resource client (generated, 5 operations).

/// Resource client.
#[derive(Debug, Clone)]
pub struct KnowledgeBaseClient {
    inner: HttpInner,
}

impl KnowledgeBaseClient {
    /// Construct a new resource client. Normally obtained
    /// via [`crate::ApiClient`] rather than directly.
    pub fn new(inner: HttpInner) -> Self {
        Self { inner }
    }

    /// 删除知识库
    ///
    /// `DELETE /{repo}/-/knowledge/base`
    pub async fn delete_knowledge_base(&self, repo: String) -> Result<serde_json::Value> {
        let path = format!("/{}/-/knowledge/base", repo);
        let mut url = self.inner.url(&path)?;
        self.inner
            .execute::<serde_json::Value>(Method::DELETE, url)
            .await
    }

    /// 获取知识库信息
    ///
    /// `GET /{repo}/-/knowledge/base`
    pub async fn get_knowledge_base_info(
        &self,
        repo: String,
    ) -> Result<crate::models::KnowledgeBaseInfoRes> {
        let path = format!("/{}/-/knowledge/base", repo);
        let mut url = self.inner.url(&path)?;
        self.inner
            .execute::<crate::models::KnowledgeBaseInfoRes>(Method::GET, url)
            .await
    }

    /// 获取当前支持的 Embedding 模型列表
    ///
    /// `GET /{repo}/-/knowledge/embedding/models`
    pub async fn get_models(&self, repo: String) -> Result<Vec<crate::models::EmbeddingModel>> {
        let path = format!("/{}/-/knowledge/embedding/models", repo);
        let mut url = self.inner.url(&path)?;
        self.inner
            .execute::<Vec<crate::models::EmbeddingModel>>(Method::GET, url)
            .await
    }

    /// 查询知识库，使用文档：<https://docs.cnb.cool/zh/ai/knowledge-base.html>
    ///
    /// `POST /{repo}/-/knowledge/base/query`
    pub async fn query_knowledge_base(
        &self,
        repo: String,
        body: &crate::models::QueryKnowledgeBaseReq,
    ) -> Result<Vec<crate::models::QueryKnowledgeBaseRes>> {
        let path = format!("/{}/-/knowledge/base/query", repo);
        let mut url = self.inner.url(&path)?;
        self.inner
            .execute_with_body::<Vec<crate::models::QueryKnowledgeBaseRes>, _>(
                Method::POST,
                url,
                body,
            )
            .await
    }

    /// 全局语义搜索 NPC 角色
    ///
    /// `GET /search/npc`
    pub async fn search_npc(
        &self,
        query: &SearchNpcQuery,
    ) -> Result<Vec<crate::models::SearchNpcRes>> {
        let path = "/search/npc".to_string();
        let mut url = self.inner.url(&path)?;
        {
            let mut pairs = url.query_pairs_mut();
            if let Some(ref v) = query.key {
                pairs.append_pair("key", v);
            }
            if let Some(v) = query.top_n {
                pairs.append_pair("top_n", &v.to_string());
            }
            drop(pairs);
        }
        self.inner
            .execute::<Vec<crate::models::SearchNpcRes>>(Method::GET, url)
            .await
    }
}

/// Query parameters for the matching method on the resource client.
#[derive(Debug, Clone, Default, Serialize)]
pub struct SearchNpcQuery {
    /// 搜索关键词
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    /// 返回结果数量，最大20
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_n: Option<i64>,
}

impl SearchNpcQuery {
    /// Construct an empty query.
    pub fn new() -> Self {
        Self::default()
    }
    /// Set `key` query parameter.
    pub fn key(mut self, v: impl Into<String>) -> Self {
        self.key = Some(v.into());
        self
    }
    /// Set `top_n` query parameter.
    pub fn top_n(mut self, v: impl Into<i64>) -> Self {
        self.top_n = Some(v.into());
        self
    }
}