async_openai/vectorstores/
vector_store_files.rs

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