Skip to main content

novel_openai/vectorstores/
vector_store_files.rs

1use crate::config::Config;
2use crate::error::OpenAIError;
3use crate::spec::vectorstores::{
4    CreateVectorStoreFileRequest, DeleteVectorStoreFileResponse, ListVectorStoreFilesResponse,
5    UpdateVectorStoreFileAttributesRequest, VectorStoreFileContentResponse, VectorStoreFileObject,
6};
7use crate::{Client, RequestOptions};
8
9/// Vector store files represent files inside a vector store.
10///
11/// Related guide: [File Search](https://platform.openai.com/docs/assistants/tools/file-search)
12pub struct VectorStoreFiles<'c, C: Config> {
13    client: &'c Client<C>,
14    pub vector_store_id: String,
15    pub(crate) request_options: RequestOptions,
16}
17
18impl<'c, C: Config> VectorStoreFiles<'c, C> {
19    pub fn new(client: &'c Client<C>, vector_store_id: &str) -> Self {
20        Self {
21            client,
22            vector_store_id: vector_store_id.into(),
23            request_options: RequestOptions::new(),
24        }
25    }
26
27    /// Create a vector store file by attaching a [File](https://platform.openai.com/docs/api-reference/files) to a [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object).
28    #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
29    pub async fn create(
30        &self,
31        request: CreateVectorStoreFileRequest,
32    ) -> Result<VectorStoreFileObject, OpenAIError> {
33        self.client
34            .post(
35                &format!("/vector_stores/{}/files", &self.vector_store_id),
36                request,
37                &self.request_options,
38            )
39            .await
40    }
41
42    /// Retrieves a vector store file.
43    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
44    pub async fn retrieve(&self, file_id: &str) -> Result<VectorStoreFileObject, OpenAIError> {
45        self.client
46            .get(
47                &format!("/vector_stores/{}/files/{file_id}", &self.vector_store_id),
48                &self.request_options,
49            )
50            .await
51    }
52
53    /// Delete a vector store file. This will remove the file from the vector store but the file itself will not be deleted. To delete the file, use the [delete file](https://platform.openai.com/docs/api-reference/files/delete) endpoint.
54    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
55    pub async fn delete(
56        &self,
57        file_id: &str,
58    ) -> Result<DeleteVectorStoreFileResponse, OpenAIError> {
59        self.client
60            .delete(
61                &format!("/vector_stores/{}/files/{file_id}", &self.vector_store_id),
62                &self.request_options,
63            )
64            .await
65    }
66
67    /// Returns a list of vector store files.
68    #[crate::byot(R = serde::de::DeserializeOwned)]
69    pub async fn list(&self) -> Result<ListVectorStoreFilesResponse, OpenAIError> {
70        self.client
71            .get(
72                &format!("/vector_stores/{}/files", &self.vector_store_id),
73                &self.request_options,
74            )
75            .await
76    }
77
78    /// Update attributes on a vector store file.
79    #[crate::byot(T0 = std::fmt::Display, T1 = serde::Serialize, R = serde::de::DeserializeOwned)]
80    pub async fn update(
81        &self,
82        file_id: &str,
83        request: UpdateVectorStoreFileAttributesRequest,
84    ) -> Result<VectorStoreFileObject, OpenAIError> {
85        self.client
86            .post(
87                &format!("/vector_stores/{}/files/{file_id}", &self.vector_store_id),
88                request,
89                &self.request_options,
90            )
91            .await
92    }
93
94    /// Retrieve the parsed contents of a vector store file.
95    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
96    pub async fn retrieve_file_content(
97        &self,
98        file_id: &str,
99    ) -> Result<VectorStoreFileContentResponse, OpenAIError> {
100        self.client
101            .get(
102                &format!(
103                    "/vector_stores/{}/files/{file_id}/content",
104                    &self.vector_store_id
105                ),
106                &self.request_options,
107            )
108            .await
109    }
110}
111
112#[cfg(all(test, feature = "vectorstore", feature = "file"))]
113mod tests {
114    use crate::Client;
115    use crate::spec::files::{CreateFileRequest, FileInput, FilePurpose};
116    use crate::spec::vectorstores::CreateVectorStoreRequest;
117
118    #[tokio::test]
119    async fn vector_store_file_creation_and_deletion()
120    -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
121        let client = Client::new();
122
123        // Create a file
124        let openai_file = client
125            .files()
126            .create(CreateFileRequest {
127                file: FileInput::from_vec_u8(
128                    String::from("meow.txt"),
129                    String::from(":3").into_bytes(),
130                ),
131                purpose: FilePurpose::UserData,
132                expires_after: None,
133            })
134            .await?;
135
136        // Create a vector store
137        let vecor_store_object = client
138            .vector_stores()
139            .create(CreateVectorStoreRequest {
140                file_ids: Some(vec![openai_file.id.clone()]),
141                name: None,
142                description: None,
143                expires_after: None,
144                chunking_strategy: None,
145                metadata: None,
146            })
147            .await?;
148
149        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
150
151        let vector_store_file_object = client
152            .vector_stores()
153            .files(&vecor_store_object.id)
154            .retrieve(&openai_file.id)
155            .await?;
156
157        assert_eq!(vector_store_file_object.id, openai_file.id);
158        // Delete the vector store
159        client
160            .vector_stores()
161            .delete(&vecor_store_object.id)
162            .await?;
163
164        // Delete the file
165        client.files().delete(&openai_file.id).await?;
166
167        Ok(())
168    }
169}