python/resources/vector_stores/index.md 2026-05-18 22:01 UTC to 2026-05-19 06:34 UTC

1# Vector Stores

2 

3## List vector stores

4 

5`vector_stores.list(VectorStoreListParams**kwargs) -> SyncCursorPage[VectorStore]`

6 

7**get** `/vector_stores`

8 

9Returns a list of vector stores.

10 

11### Parameters

12 

13- `after: Optional[str]`

14 

15 A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.

16 

17- `before: Optional[str]`

18 

19 A cursor for use in pagination. `before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.

20 

21- `limit: Optional[int]`

22 

23 A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.

24 

25- `order: Optional[Literal["asc", "desc"]]`

26 

27 Sort order by the `created_at` timestamp of the objects. `asc` for ascending order and `desc` for descending order.

28 

29 - `"asc"`

30 

31 - `"desc"`

32 

33### Returns

34 

35- `class VectorStore: …`

36 

37 A vector store is a collection of processed files can be used by the `file_search` tool.

38 

39 - `id: str`

40 

41 The identifier, which can be referenced in API endpoints.

42 

43 - `created_at: int`

44 

45 The Unix timestamp (in seconds) for when the vector store was created.

46 

47 - `file_counts: FileCounts`

48 

49 - `cancelled: int`

50 

51 The number of files that were cancelled.

52 

53 - `completed: int`

54 

55 The number of files that have been successfully processed.

56 

57 - `failed: int`

58 

59 The number of files that have failed to process.

60 

61 - `in_progress: int`

62 

63 The number of files that are currently being processed.

64 

65 - `total: int`

66 

67 The total number of files.

68 

69 - `last_active_at: Optional[int]`

70 

71 The Unix timestamp (in seconds) for when the vector store was last active.

72 

73 - `metadata: Optional[Metadata]`

74 

75 Set of 16 key-value pairs that can be attached to an object. This can be

76 useful for storing additional information about the object in a structured

77 format, and querying for objects via API or the dashboard.

78 

79 Keys are strings with a maximum length of 64 characters. Values are strings

80 with a maximum length of 512 characters.

81 

82 - `name: str`

83 

84 The name of the vector store.

85 

86 - `object: Literal["vector_store"]`

87 

88 The object type, which is always `vector_store`.

89 

90 - `"vector_store"`

91 

92 - `status: Literal["expired", "in_progress", "completed"]`

93 

94 The status of the vector store, which can be either `expired`, `in_progress`, or `completed`. A status of `completed` indicates that the vector store is ready for use.

95 

96 - `"expired"`

97 

98 - `"in_progress"`

99 

100 - `"completed"`

101 

102 - `usage_bytes: int`

103 

104 The total number of bytes used by the files in the vector store.

105 

106 - `expires_after: Optional[ExpiresAfter]`

107 

108 The expiration policy for a vector store.

109 

110 - `anchor: Literal["last_active_at"]`

111 

112 Anchor timestamp after which the expiration policy applies. Supported anchors: `last_active_at`.

113 

114 - `"last_active_at"`

115 

116 - `days: int`

117 

118 The number of days after the anchor time that the vector store will expire.

119 

120 - `expires_at: Optional[int]`

121 

122 The Unix timestamp (in seconds) for when the vector store will expire.

123 

124### Example

125 

126```python

127import os

128from openai import OpenAI

129 

130client = OpenAI(

131 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

132)

133page = client.vector_stores.list()

134page = page.data[0]

135print(page.id)

136```

137 

138#### Response

139 

140```json

141{

142 "data": [

143 {

144 "id": "id",

145 "created_at": 0,

146 "file_counts": {

147 "cancelled": 0,

148 "completed": 0,

149 "failed": 0,

150 "in_progress": 0,

151 "total": 0

152 },

153 "last_active_at": 0,

154 "metadata": {

155 "foo": "string"

156 },

157 "name": "name",

158 "object": "vector_store",

159 "status": "expired",

160 "usage_bytes": 0,

161 "expires_after": {

162 "anchor": "last_active_at",

163 "days": 1

164 },

165 "expires_at": 0

166 }

167 ],

168 "first_id": "vs_abc123",

169 "has_more": false,

170 "last_id": "vs_abc456",

171 "object": "list"

172}

173```

174 

175### Example

176 

177```python

178from openai import OpenAI

179client = OpenAI()

180 

181vector_stores = client.vector_stores.list()

182print(vector_stores)

183```

184 

185#### Response

186 

187```json

188{

189 "object": "list",

190 "data": [

191 {

192 "id": "vs_abc123",

193 "object": "vector_store",

194 "created_at": 1699061776,

195 "name": "Support FAQ",

196 "description": "Contains commonly asked questions and answers, organized by topic.",

197 "bytes": 139920,

198 "file_counts": {

199 "in_progress": 0,

200 "completed": 3,

201 "failed": 0,

202 "cancelled": 0,

203 "total": 3

204 }

205 },

206 {

207 "id": "vs_abc456",

208 "object": "vector_store",

209 "created_at": 1699061776,

210 "name": "Support FAQ v2",

211 "description": null,

212 "bytes": 139920,

213 "file_counts": {

214 "in_progress": 0,

215 "completed": 3,

216 "failed": 0,

217 "cancelled": 0,

218 "total": 3

219 }

220 }

221 ],

222 "first_id": "vs_abc123",

223 "last_id": "vs_abc456",

224 "has_more": false

225}

226```

227 

228## Create vector store

229 

230`vector_stores.create(VectorStoreCreateParams**kwargs) -> VectorStore`

231 

232**post** `/vector_stores`

233 

234Create a vector store.

235 

236### Parameters

237 

238- `chunking_strategy: Optional[FileChunkingStrategyParam]`

239 

240 The chunking strategy used to chunk the file(s). If not set, will use the `auto` strategy. Only applicable if `file_ids` is non-empty.

241 

242 - `class AutoFileChunkingStrategyParam: …`

243 

244 The default strategy. This strategy currently uses a `max_chunk_size_tokens` of `800` and `chunk_overlap_tokens` of `400`.

245 

246 - `type: Literal["auto"]`

247 

248 Always `auto`.

249 

250 - `"auto"`

251 

252 - `class StaticFileChunkingStrategyObjectParam: …`

253 

254 Customize your own chunking strategy by setting chunk size and chunk overlap.

255 

256 - `static: StaticFileChunkingStrategy`

257 

258 - `chunk_overlap_tokens: int`

259 

260 The number of tokens that overlap between chunks. The default value is `400`.

261 

262 Note that the overlap must not exceed half of `max_chunk_size_tokens`.

263 

264 - `max_chunk_size_tokens: int`

265 

266 The maximum number of tokens in each chunk. The default value is `800`. The minimum value is `100` and the maximum value is `4096`.

267 

268 - `type: Literal["static"]`

269 

270 Always `static`.

271 

272 - `"static"`

273 

274- `description: Optional[str]`

275 

276 A description for the vector store. Can be used to describe the vector store's purpose.

277 

278- `expires_after: Optional[ExpiresAfter]`

279 

280 The expiration policy for a vector store.

281 

282 - `anchor: Literal["last_active_at"]`

283 

284 Anchor timestamp after which the expiration policy applies. Supported anchors: `last_active_at`.

285 

286 - `"last_active_at"`

287 

288 - `days: int`

289 

290 The number of days after the anchor time that the vector store will expire.

291 

292- `file_ids: Optional[Sequence[str]]`

293 

294 A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that the vector store should use. Useful for tools like `file_search` that can access files.

295 

296- `metadata: Optional[Metadata]`

297 

298 Set of 16 key-value pairs that can be attached to an object. This can be

299 useful for storing additional information about the object in a structured

300 format, and querying for objects via API or the dashboard.

301 

302 Keys are strings with a maximum length of 64 characters. Values are strings

303 with a maximum length of 512 characters.

304 

305- `name: Optional[str]`

306 

307 The name of the vector store.

308 

309### Returns

310 

311- `class VectorStore: …`

312 

313 A vector store is a collection of processed files can be used by the `file_search` tool.

314 

315 - `id: str`

316 

317 The identifier, which can be referenced in API endpoints.

318 

319 - `created_at: int`

320 

321 The Unix timestamp (in seconds) for when the vector store was created.

322 

323 - `file_counts: FileCounts`

324 

325 - `cancelled: int`

326 

327 The number of files that were cancelled.

328 

329 - `completed: int`

330 

331 The number of files that have been successfully processed.

332 

333 - `failed: int`

334 

335 The number of files that have failed to process.

336 

337 - `in_progress: int`

338 

339 The number of files that are currently being processed.

340 

341 - `total: int`

342 

343 The total number of files.

344 

345 - `last_active_at: Optional[int]`

346 

347 The Unix timestamp (in seconds) for when the vector store was last active.

348 

349 - `metadata: Optional[Metadata]`

350 

351 Set of 16 key-value pairs that can be attached to an object. This can be

352 useful for storing additional information about the object in a structured

353 format, and querying for objects via API or the dashboard.

354 

355 Keys are strings with a maximum length of 64 characters. Values are strings

356 with a maximum length of 512 characters.

357 

358 - `name: str`

359 

360 The name of the vector store.

361 

362 - `object: Literal["vector_store"]`

363 

364 The object type, which is always `vector_store`.

365 

366 - `"vector_store"`

367 

368 - `status: Literal["expired", "in_progress", "completed"]`

369 

370 The status of the vector store, which can be either `expired`, `in_progress`, or `completed`. A status of `completed` indicates that the vector store is ready for use.

371 

372 - `"expired"`

373 

374 - `"in_progress"`

375 

376 - `"completed"`

377 

378 - `usage_bytes: int`

379 

380 The total number of bytes used by the files in the vector store.

381 

382 - `expires_after: Optional[ExpiresAfter]`

383 

384 The expiration policy for a vector store.

385 

386 - `anchor: Literal["last_active_at"]`

387 

388 Anchor timestamp after which the expiration policy applies. Supported anchors: `last_active_at`.

389 

390 - `"last_active_at"`

391 

392 - `days: int`

393 

394 The number of days after the anchor time that the vector store will expire.

395 

396 - `expires_at: Optional[int]`

397 

398 The Unix timestamp (in seconds) for when the vector store will expire.

399 

400### Example

401 

402```python

403import os

404from openai import OpenAI

405 

406client = OpenAI(

407 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

408)

409vector_store = client.vector_stores.create()

410print(vector_store.id)

411```

412 

413#### Response

414 

415```json

416{

417 "id": "id",

418 "created_at": 0,

419 "file_counts": {

420 "cancelled": 0,

421 "completed": 0,

422 "failed": 0,

423 "in_progress": 0,

424 "total": 0

425 },

426 "last_active_at": 0,

427 "metadata": {

428 "foo": "string"

429 },

430 "name": "name",

431 "object": "vector_store",

432 "status": "expired",

433 "usage_bytes": 0,

434 "expires_after": {

435 "anchor": "last_active_at",

436 "days": 1

437 },

438 "expires_at": 0

439}

440```

441 

442### Example

443 

444```python

445from openai import OpenAI

446client = OpenAI()

447 

448vector_store = client.vector_stores.create(

449 name="Support FAQ"

450)

451print(vector_store)

452```

453 

454#### Response

455 

456```json

457{

458 "id": "vs_abc123",

459 "object": "vector_store",

460 "created_at": 1699061776,

461 "name": "Support FAQ",

462 "description": "Contains commonly asked questions and answers, organized by topic.",

463 "bytes": 139920,

464 "file_counts": {

465 "in_progress": 0,

466 "completed": 3,

467 "failed": 0,

468 "cancelled": 0,

469 "total": 3

470 }

471}

472```

473 

474## Retrieve vector store

475 

476`vector_stores.retrieve(strvector_store_id) -> VectorStore`

477 

478**get** `/vector_stores/{vector_store_id}`

479 

480Retrieves a vector store.

481 

482### Parameters

483 

484- `vector_store_id: str`

485 

486### Returns

487 

488- `class VectorStore: …`

489 

490 A vector store is a collection of processed files can be used by the `file_search` tool.

491 

492 - `id: str`

493 

494 The identifier, which can be referenced in API endpoints.

495 

496 - `created_at: int`

497 

498 The Unix timestamp (in seconds) for when the vector store was created.

499 

500 - `file_counts: FileCounts`

501 

502 - `cancelled: int`

503 

504 The number of files that were cancelled.

505 

506 - `completed: int`

507 

508 The number of files that have been successfully processed.

509 

510 - `failed: int`

511 

512 The number of files that have failed to process.

513 

514 - `in_progress: int`

515 

516 The number of files that are currently being processed.

517 

518 - `total: int`

519 

520 The total number of files.

521 

522 - `last_active_at: Optional[int]`

523 

524 The Unix timestamp (in seconds) for when the vector store was last active.

525 

526 - `metadata: Optional[Metadata]`

527 

528 Set of 16 key-value pairs that can be attached to an object. This can be

529 useful for storing additional information about the object in a structured

530 format, and querying for objects via API or the dashboard.

531 

532 Keys are strings with a maximum length of 64 characters. Values are strings

533 with a maximum length of 512 characters.

534 

535 - `name: str`

536 

537 The name of the vector store.

538 

539 - `object: Literal["vector_store"]`

540 

541 The object type, which is always `vector_store`.

542 

543 - `"vector_store"`

544 

545 - `status: Literal["expired", "in_progress", "completed"]`

546 

547 The status of the vector store, which can be either `expired`, `in_progress`, or `completed`. A status of `completed` indicates that the vector store is ready for use.

548 

549 - `"expired"`

550 

551 - `"in_progress"`

552 

553 - `"completed"`

554 

555 - `usage_bytes: int`

556 

557 The total number of bytes used by the files in the vector store.

558 

559 - `expires_after: Optional[ExpiresAfter]`

560 

561 The expiration policy for a vector store.

562 

563 - `anchor: Literal["last_active_at"]`

564 

565 Anchor timestamp after which the expiration policy applies. Supported anchors: `last_active_at`.

566 

567 - `"last_active_at"`

568 

569 - `days: int`

570 

571 The number of days after the anchor time that the vector store will expire.

572 

573 - `expires_at: Optional[int]`

574 

575 The Unix timestamp (in seconds) for when the vector store will expire.

576 

577### Example

578 

579```python

580import os

581from openai import OpenAI

582 

583client = OpenAI(

584 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

585)

586vector_store = client.vector_stores.retrieve(

587 "vector_store_id",

588)

589print(vector_store.id)

590```

591 

592#### Response

593 

594```json

595{

596 "id": "id",

597 "created_at": 0,

598 "file_counts": {

599 "cancelled": 0,

600 "completed": 0,

601 "failed": 0,

602 "in_progress": 0,

603 "total": 0

604 },

605 "last_active_at": 0,

606 "metadata": {

607 "foo": "string"

608 },

609 "name": "name",

610 "object": "vector_store",

611 "status": "expired",

612 "usage_bytes": 0,

613 "expires_after": {

614 "anchor": "last_active_at",

615 "days": 1

616 },

617 "expires_at": 0

618}

619```

620 

621### Example

622 

623```python

624from openai import OpenAI

625client = OpenAI()

626 

627vector_store = client.vector_stores.retrieve(

628 vector_store_id="vs_abc123"

629)

630print(vector_store)

631```

632 

633#### Response

634 

635```json

636{

637 "id": "vs_abc123",

638 "object": "vector_store",

639 "created_at": 1699061776

640}

641```

642 

643## Modify vector store

644 

645`vector_stores.update(strvector_store_id, VectorStoreUpdateParams**kwargs) -> VectorStore`

646 

647**post** `/vector_stores/{vector_store_id}`

648 

649Modifies a vector store.

650 

651### Parameters

652 

653- `vector_store_id: str`

654 

655- `expires_after: Optional[ExpiresAfter]`

656 

657 The expiration policy for a vector store.

658 

659 - `anchor: Literal["last_active_at"]`

660 

661 Anchor timestamp after which the expiration policy applies. Supported anchors: `last_active_at`.

662 

663 - `"last_active_at"`

664 

665 - `days: int`

666 

667 The number of days after the anchor time that the vector store will expire.

668 

669- `metadata: Optional[Metadata]`

670 

671 Set of 16 key-value pairs that can be attached to an object. This can be

672 useful for storing additional information about the object in a structured

673 format, and querying for objects via API or the dashboard.

674 

675 Keys are strings with a maximum length of 64 characters. Values are strings

676 with a maximum length of 512 characters.

677 

678- `name: Optional[str]`

679 

680 The name of the vector store.

681 

682### Returns

683 

684- `class VectorStore: …`

685 

686 A vector store is a collection of processed files can be used by the `file_search` tool.

687 

688 - `id: str`

689 

690 The identifier, which can be referenced in API endpoints.

691 

692 - `created_at: int`

693 

694 The Unix timestamp (in seconds) for when the vector store was created.

695 

696 - `file_counts: FileCounts`

697 

698 - `cancelled: int`

699 

700 The number of files that were cancelled.

701 

702 - `completed: int`

703 

704 The number of files that have been successfully processed.

705 

706 - `failed: int`

707 

708 The number of files that have failed to process.

709 

710 - `in_progress: int`

711 

712 The number of files that are currently being processed.

713 

714 - `total: int`

715 

716 The total number of files.

717 

718 - `last_active_at: Optional[int]`

719 

720 The Unix timestamp (in seconds) for when the vector store was last active.

721 

722 - `metadata: Optional[Metadata]`

723 

724 Set of 16 key-value pairs that can be attached to an object. This can be

725 useful for storing additional information about the object in a structured

726 format, and querying for objects via API or the dashboard.

727 

728 Keys are strings with a maximum length of 64 characters. Values are strings

729 with a maximum length of 512 characters.

730 

731 - `name: str`

732 

733 The name of the vector store.

734 

735 - `object: Literal["vector_store"]`

736 

737 The object type, which is always `vector_store`.

738 

739 - `"vector_store"`

740 

741 - `status: Literal["expired", "in_progress", "completed"]`

742 

743 The status of the vector store, which can be either `expired`, `in_progress`, or `completed`. A status of `completed` indicates that the vector store is ready for use.

744 

745 - `"expired"`

746 

747 - `"in_progress"`

748 

749 - `"completed"`

750 

751 - `usage_bytes: int`

752 

753 The total number of bytes used by the files in the vector store.

754 

755 - `expires_after: Optional[ExpiresAfter]`

756 

757 The expiration policy for a vector store.

758 

759 - `anchor: Literal["last_active_at"]`

760 

761 Anchor timestamp after which the expiration policy applies. Supported anchors: `last_active_at`.

762 

763 - `"last_active_at"`

764 

765 - `days: int`

766 

767 The number of days after the anchor time that the vector store will expire.

768 

769 - `expires_at: Optional[int]`

770 

771 The Unix timestamp (in seconds) for when the vector store will expire.

772 

773### Example

774 

775```python

776import os

777from openai import OpenAI

778 

779client = OpenAI(

780 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

781)

782vector_store = client.vector_stores.update(

783 vector_store_id="vector_store_id",

784)

785print(vector_store.id)

786```

787 

788#### Response

789 

790```json

791{

792 "id": "id",

793 "created_at": 0,

794 "file_counts": {

795 "cancelled": 0,

796 "completed": 0,

797 "failed": 0,

798 "in_progress": 0,

799 "total": 0

800 },

801 "last_active_at": 0,

802 "metadata": {

803 "foo": "string"

804 },

805 "name": "name",

806 "object": "vector_store",

807 "status": "expired",

808 "usage_bytes": 0,

809 "expires_after": {

810 "anchor": "last_active_at",

811 "days": 1

812 },

813 "expires_at": 0

814}

815```

816 

817### Example

818 

819```python

820from openai import OpenAI

821client = OpenAI()

822 

823vector_store = client.vector_stores.update(

824 vector_store_id="vs_abc123",

825 name="Support FAQ"

826)

827print(vector_store)

828```

829 

830#### Response

831 

832```json

833{

834 "id": "vs_abc123",

835 "object": "vector_store",

836 "created_at": 1699061776,

837 "name": "Support FAQ",

838 "description": "Contains commonly asked questions and answers, organized by topic.",

839 "bytes": 139920,

840 "file_counts": {

841 "in_progress": 0,

842 "completed": 3,

843 "failed": 0,

844 "cancelled": 0,

845 "total": 3

846 }

847}

848```

849 

850## Delete vector store

851 

852`vector_stores.delete(strvector_store_id) -> VectorStoreDeleted`

853 

854**delete** `/vector_stores/{vector_store_id}`

855 

856Delete a vector store.

857 

858### Parameters

859 

860- `vector_store_id: str`

861 

862### Returns

863 

864- `class VectorStoreDeleted: …`

865 

866 - `id: str`

867 

868 - `deleted: bool`

869 

870 - `object: Literal["vector_store.deleted"]`

871 

872 - `"vector_store.deleted"`

873 

874### Example

875 

876```python

877import os

878from openai import OpenAI

879 

880client = OpenAI(

881 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

882)

883vector_store_deleted = client.vector_stores.delete(

884 "vector_store_id",

885)

886print(vector_store_deleted.id)

887```

888 

889#### Response

890 

891```json

892{

893 "id": "id",

894 "deleted": true,

895 "object": "vector_store.deleted"

896}

897```

898 

899### Example

900 

901```python

902from openai import OpenAI

903client = OpenAI()

904 

905deleted_vector_store = client.vector_stores.delete(

906 vector_store_id="vs_abc123"

907)

908print(deleted_vector_store)

909```

910 

911#### Response

912 

913```json

914{

915 id: "vs_abc123",

916 object: "vector_store.deleted",

917 deleted: true

918}

919```

920 

921## Search vector store

922 

923`vector_stores.search(strvector_store_id, VectorStoreSearchParams**kwargs) -> SyncPage[VectorStoreSearchResponse]`

924 

925**post** `/vector_stores/{vector_store_id}/search`

926 

927Search a vector store for relevant chunks based on a query and file attributes filter.

928 

929### Parameters

930 

931- `vector_store_id: str`

932 

933- `query: Union[str, Sequence[str]]`

934 

935 A query string for a search

936 

937 - `str`

938 

939 - `Sequence[str]`

940 

941- `filters: Optional[Filters]`

942 

943 A filter to apply based on file attributes.

944 

945 - `class ComparisonFilter: …`

946 

947 A filter used to compare a specified attribute key to a given value using a defined comparison operation.

948 

949 - `key: str`

950 

951 The key to compare against the value.

952 

953 - `type: Literal["eq", "ne", "gt", 5 more]`

954 

955 Specifies the comparison operator: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`, `nin`.

956 

957 - `eq`: equals

958 - `ne`: not equal

959 - `gt`: greater than

960 - `gte`: greater than or equal

961 - `lt`: less than

962 - `lte`: less than or equal

963 - `in`: in

964 - `nin`: not in

965 

966 - `"eq"`

967 

968 - `"ne"`

969 

970 - `"gt"`

971 

972 - `"gte"`

973 

974 - `"lt"`

975 

976 - `"lte"`

977 

978 - `"in"`

979 

980 - `"nin"`

981 

982 - `value: Union[str, float, bool, List[Union[str, float]]]`

983 

984 The value to compare against the attribute key; supports string, number, or boolean types.

985 

986 - `str`

987 

988 - `float`

989 

990 - `bool`

991 

992 - `List[Union[str, float]]`

993 

994 - `str`

995 

996 - `float`

997 

998 - `class CompoundFilter: …`

999 

1000 Combine multiple filters using `and` or `or`.

1001 

1002 - `filters: List[Filter]`

1003 

1004 Array of filters to combine. Items can be `ComparisonFilter` or `CompoundFilter`.

1005 

1006 - `class ComparisonFilter: …`

1007 

1008 A filter used to compare a specified attribute key to a given value using a defined comparison operation.

1009 

1010 - `object`

1011 

1012 - `type: Literal["and", "or"]`

1013 

1014 Type of operation: `and` or `or`.

1015 

1016 - `"and"`

1017 

1018 - `"or"`

1019 

1020- `max_num_results: Optional[int]`

1021 

1022 The maximum number of results to return. This number should be between 1 and 50 inclusive.

1023 

1024- `ranking_options: Optional[RankingOptions]`

1025 

1026 Ranking options for search.

1027 

1028 - `ranker: Optional[Literal["none", "auto", "default-2024-11-15"]]`

1029 

1030 Enable re-ranking; set to `none` to disable, which can help reduce latency.

1031 

1032 - `"none"`

1033 

1034 - `"auto"`

1035 

1036 - `"default-2024-11-15"`

1037 

1038 - `score_threshold: Optional[float]`

1039 

1040- `rewrite_query: Optional[bool]`

1041 

1042 Whether to rewrite the natural language query for vector search.

1043 

1044### Returns

1045 

1046- `class VectorStoreSearchResponse: …`

1047 

1048 - `attributes: Optional[Dict[str, Union[str, float, bool]]]`

1049 

1050 Set of 16 key-value pairs that can be attached to an object. This can be

1051 useful for storing additional information about the object in a structured

1052 format, and querying for objects via API or the dashboard. Keys are strings

1053 with a maximum length of 64 characters. Values are strings with a maximum

1054 length of 512 characters, booleans, or numbers.

1055 

1056 - `str`

1057 

1058 - `float`

1059 

1060 - `bool`

1061 

1062 - `content: List[Content]`

1063 

1064 Content chunks from the file.

1065 

1066 - `text: str`

1067 

1068 The text content returned from search.

1069 

1070 - `type: Literal["text"]`

1071 

1072 The type of content.

1073 

1074 - `"text"`

1075 

1076 - `file_id: str`

1077 

1078 The ID of the vector store file.

1079 

1080 - `filename: str`

1081 

1082 The name of the vector store file.

1083 

1084 - `score: float`

1085 

1086 The similarity score for the result.

1087 

1088### Example

1089 

1090```python

1091import os

1092from openai import OpenAI

1093 

1094client = OpenAI(

1095 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

1096)

1097page = client.vector_stores.search(

1098 vector_store_id="vs_abc123",

1099 query="string",

1100)

1101page = page.data[0]

1102print(page.file_id)

1103```

1104 

1105#### Response

1106 

1107```json

1108{

1109 "data": [

1110 {

1111 "attributes": {

1112 "foo": "string"

1113 },

1114 "content": [

1115 {

1116 "text": "text",

1117 "type": "text"

1118 }

1119 ],

1120 "file_id": "file_id",

1121 "filename": "filename",

1122 "score": 0

1123 }

1124 ],

1125 "has_more": true,

1126 "next_page": "next_page",

1127 "object": "vector_store.search_results.page",

1128 "search_query": [

1129 "string"

1130 ]

1131}

1132```

1133 

1134## Domain Types

1135 

1136### Auto File Chunking Strategy Param

1137 

1138- `class AutoFileChunkingStrategyParam: …`

1139 

1140 The default strategy. This strategy currently uses a `max_chunk_size_tokens` of `800` and `chunk_overlap_tokens` of `400`.

1141 

1142 - `type: Literal["auto"]`

1143 

1144 Always `auto`.

1145 

1146 - `"auto"`

1147 

1148### File Chunking Strategy

1149 

1150- `FileChunkingStrategy`

1151 

1152 The strategy used to chunk the file.

1153 

1154 - `class StaticFileChunkingStrategyObject: …`

1155 

1156 - `static: StaticFileChunkingStrategy`

1157 

1158 - `chunk_overlap_tokens: int`

1159 

1160 The number of tokens that overlap between chunks. The default value is `400`.

1161 

1162 Note that the overlap must not exceed half of `max_chunk_size_tokens`.

1163 

1164 - `max_chunk_size_tokens: int`

1165 

1166 The maximum number of tokens in each chunk. The default value is `800`. The minimum value is `100` and the maximum value is `4096`.

1167 

1168 - `type: Literal["static"]`

1169 

1170 Always `static`.

1171 

1172 - `"static"`

1173 

1174 - `class OtherFileChunkingStrategyObject: …`

1175 

1176 This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the `chunking_strategy` concept was introduced in the API.

1177 

1178 - `type: Literal["other"]`

1179 

1180 Always `other`.

1181 

1182 - `"other"`

1183 

1184### File Chunking Strategy Param

1185 

1186- `FileChunkingStrategyParam`

1187 

1188 The chunking strategy used to chunk the file(s). If not set, will use the `auto` strategy. Only applicable if `file_ids` is non-empty.

1189 

1190 - `class AutoFileChunkingStrategyParam: …`

1191 

1192 The default strategy. This strategy currently uses a `max_chunk_size_tokens` of `800` and `chunk_overlap_tokens` of `400`.

1193 

1194 - `type: Literal["auto"]`

1195 

1196 Always `auto`.

1197 

1198 - `"auto"`

1199 

1200 - `class StaticFileChunkingStrategyObjectParam: …`

1201 

1202 Customize your own chunking strategy by setting chunk size and chunk overlap.

1203 

1204 - `static: StaticFileChunkingStrategy`

1205 

1206 - `chunk_overlap_tokens: int`

1207 

1208 The number of tokens that overlap between chunks. The default value is `400`.

1209 

1210 Note that the overlap must not exceed half of `max_chunk_size_tokens`.

1211 

1212 - `max_chunk_size_tokens: int`

1213 

1214 The maximum number of tokens in each chunk. The default value is `800`. The minimum value is `100` and the maximum value is `4096`.

1215 

1216 - `type: Literal["static"]`

1217 

1218 Always `static`.

1219 

1220 - `"static"`

1221 

1222### Other File Chunking Strategy Object

1223 

1224- `class OtherFileChunkingStrategyObject: …`

1225 

1226 This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the `chunking_strategy` concept was introduced in the API.

1227 

1228 - `type: Literal["other"]`

1229 

1230 Always `other`.

1231 

1232 - `"other"`

1233 

1234### Static File Chunking Strategy

1235 

1236- `class StaticFileChunkingStrategy: …`

1237 

1238 - `chunk_overlap_tokens: int`

1239 

1240 The number of tokens that overlap between chunks. The default value is `400`.

1241 

1242 Note that the overlap must not exceed half of `max_chunk_size_tokens`.

1243 

1244 - `max_chunk_size_tokens: int`

1245 

1246 The maximum number of tokens in each chunk. The default value is `800`. The minimum value is `100` and the maximum value is `4096`.

1247 

1248### Static File Chunking Strategy Object

1249 

1250- `class StaticFileChunkingStrategyObject: …`

1251 

1252 - `static: StaticFileChunkingStrategy`

1253 

1254 - `chunk_overlap_tokens: int`

1255 

1256 The number of tokens that overlap between chunks. The default value is `400`.

1257 

1258 Note that the overlap must not exceed half of `max_chunk_size_tokens`.

1259 

1260 - `max_chunk_size_tokens: int`

1261 

1262 The maximum number of tokens in each chunk. The default value is `800`. The minimum value is `100` and the maximum value is `4096`.

1263 

1264 - `type: Literal["static"]`

1265 

1266 Always `static`.

1267 

1268 - `"static"`

1269 

1270### Static File Chunking Strategy Object Param

1271 

1272- `class StaticFileChunkingStrategyObjectParam: …`

1273 

1274 Customize your own chunking strategy by setting chunk size and chunk overlap.

1275 

1276 - `static: StaticFileChunkingStrategy`

1277 

1278 - `chunk_overlap_tokens: int`

1279 

1280 The number of tokens that overlap between chunks. The default value is `400`.

1281 

1282 Note that the overlap must not exceed half of `max_chunk_size_tokens`.

1283 

1284 - `max_chunk_size_tokens: int`

1285 

1286 The maximum number of tokens in each chunk. The default value is `800`. The minimum value is `100` and the maximum value is `4096`.

1287 

1288 - `type: Literal["static"]`

1289 

1290 Always `static`.

1291 

1292 - `"static"`

1293 

1294### Vector Store

1295 

1296- `class VectorStore: …`

1297 

1298 A vector store is a collection of processed files can be used by the `file_search` tool.

1299 

1300 - `id: str`

1301 

1302 The identifier, which can be referenced in API endpoints.

1303 

1304 - `created_at: int`

1305 

1306 The Unix timestamp (in seconds) for when the vector store was created.

1307 

1308 - `file_counts: FileCounts`

1309 

1310 - `cancelled: int`

1311 

1312 The number of files that were cancelled.

1313 

1314 - `completed: int`

1315 

1316 The number of files that have been successfully processed.

1317 

1318 - `failed: int`

1319 

1320 The number of files that have failed to process.

1321 

1322 - `in_progress: int`

1323 

1324 The number of files that are currently being processed.

1325 

1326 - `total: int`

1327 

1328 The total number of files.

1329 

1330 - `last_active_at: Optional[int]`

1331 

1332 The Unix timestamp (in seconds) for when the vector store was last active.

1333 

1334 - `metadata: Optional[Metadata]`

1335 

1336 Set of 16 key-value pairs that can be attached to an object. This can be

1337 useful for storing additional information about the object in a structured

1338 format, and querying for objects via API or the dashboard.

1339 

1340 Keys are strings with a maximum length of 64 characters. Values are strings

1341 with a maximum length of 512 characters.

1342 

1343 - `name: str`

1344 

1345 The name of the vector store.

1346 

1347 - `object: Literal["vector_store"]`

1348 

1349 The object type, which is always `vector_store`.

1350 

1351 - `"vector_store"`

1352 

1353 - `status: Literal["expired", "in_progress", "completed"]`

1354 

1355 The status of the vector store, which can be either `expired`, `in_progress`, or `completed`. A status of `completed` indicates that the vector store is ready for use.

1356 

1357 - `"expired"`

1358 

1359 - `"in_progress"`

1360 

1361 - `"completed"`

1362 

1363 - `usage_bytes: int`

1364 

1365 The total number of bytes used by the files in the vector store.

1366 

1367 - `expires_after: Optional[ExpiresAfter]`

1368 

1369 The expiration policy for a vector store.

1370 

1371 - `anchor: Literal["last_active_at"]`

1372 

1373 Anchor timestamp after which the expiration policy applies. Supported anchors: `last_active_at`.

1374 

1375 - `"last_active_at"`

1376 

1377 - `days: int`

1378 

1379 The number of days after the anchor time that the vector store will expire.

1380 

1381 - `expires_at: Optional[int]`

1382 

1383 The Unix timestamp (in seconds) for when the vector store will expire.

1384 

1385### Vector Store Deleted

1386 

1387- `class VectorStoreDeleted: …`

1388 

1389 - `id: str`

1390 

1391 - `deleted: bool`

1392 

1393 - `object: Literal["vector_store.deleted"]`

1394 

1395 - `"vector_store.deleted"`

1396 

1397### Vector Store Search Response

1398 

1399- `class VectorStoreSearchResponse: …`

1400 

1401 - `attributes: Optional[Dict[str, Union[str, float, bool]]]`

1402 

1403 Set of 16 key-value pairs that can be attached to an object. This can be

1404 useful for storing additional information about the object in a structured

1405 format, and querying for objects via API or the dashboard. Keys are strings

1406 with a maximum length of 64 characters. Values are strings with a maximum

1407 length of 512 characters, booleans, or numbers.

1408 

1409 - `str`

1410 

1411 - `float`

1412 

1413 - `bool`

1414 

1415 - `content: List[Content]`

1416 

1417 Content chunks from the file.

1418 

1419 - `text: str`

1420 

1421 The text content returned from search.

1422 

1423 - `type: Literal["text"]`

1424 

1425 The type of content.

1426 

1427 - `"text"`

1428 

1429 - `file_id: str`

1430 

1431 The ID of the vector store file.

1432 

1433 - `filename: str`

1434 

1435 The name of the vector store file.

1436 

1437 - `score: float`

1438 

1439 The similarity score for the result.

1440 

1441# Files

1442 

1443## List vector store files

1444 

1445`vector_stores.files.list(strvector_store_id, FileListParams**kwargs) -> SyncCursorPage[VectorStoreFile]`

1446 

1447**get** `/vector_stores/{vector_store_id}/files`

1448 

1449Returns a list of vector store files.

1450 

1451### Parameters

1452 

1453- `vector_store_id: str`

1454 

1455- `after: Optional[str]`

1456 

1457 A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.

1458 

1459- `before: Optional[str]`

1460 

1461 A cursor for use in pagination. `before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.

1462 

1463- `filter: Optional[Literal["in_progress", "completed", "failed", "cancelled"]]`

1464 

1465 Filter by file status. One of `in_progress`, `completed`, `failed`, `cancelled`.

1466 

1467 - `"in_progress"`

1468 

1469 - `"completed"`

1470 

1471 - `"failed"`

1472 

1473 - `"cancelled"`

1474 

1475- `limit: Optional[int]`

1476 

1477 A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.

1478 

1479- `order: Optional[Literal["asc", "desc"]]`

1480 

1481 Sort order by the `created_at` timestamp of the objects. `asc` for ascending order and `desc` for descending order.

1482 

1483 - `"asc"`

1484 

1485 - `"desc"`

1486 

1487### Returns

1488 

1489- `class VectorStoreFile: …`

1490 

1491 A list of files attached to a vector store.

1492 

1493 - `id: str`

1494 

1495 The identifier, which can be referenced in API endpoints.

1496 

1497 - `created_at: int`

1498 

1499 The Unix timestamp (in seconds) for when the vector store file was created.

1500 

1501 - `last_error: Optional[LastError]`

1502 

1503 The last error associated with this vector store file. Will be `null` if there are no errors.

1504 

1505 - `code: Literal["server_error", "unsupported_file", "invalid_file"]`

1506 

1507 One of `server_error`, `unsupported_file`, or `invalid_file`.

1508 

1509 - `"server_error"`

1510 

1511 - `"unsupported_file"`

1512 

1513 - `"invalid_file"`

1514 

1515 - `message: str`

1516 

1517 A human-readable description of the error.

1518 

1519 - `object: Literal["vector_store.file"]`

1520 

1521 The object type, which is always `vector_store.file`.

1522 

1523 - `"vector_store.file"`

1524 

1525 - `status: Literal["in_progress", "completed", "cancelled", "failed"]`

1526 

1527 The status of the vector store file, which can be either `in_progress`, `completed`, `cancelled`, or `failed`. The status `completed` indicates that the vector store file is ready for use.

1528 

1529 - `"in_progress"`

1530 

1531 - `"completed"`

1532 

1533 - `"cancelled"`

1534 

1535 - `"failed"`

1536 

1537 - `usage_bytes: int`

1538 

1539 The total vector store usage in bytes. Note that this may be different from the original file size.

1540 

1541 - `vector_store_id: str`

1542 

1543 The ID of the [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object) that the [File](https://platform.openai.com/docs/api-reference/files) is attached to.

1544 

1545 - `attributes: Optional[Dict[str, Union[str, float, bool]]]`

1546 

1547 Set of 16 key-value pairs that can be attached to an object. This can be

1548 useful for storing additional information about the object in a structured

1549 format, and querying for objects via API or the dashboard. Keys are strings

1550 with a maximum length of 64 characters. Values are strings with a maximum

1551 length of 512 characters, booleans, or numbers.

1552 

1553 - `str`

1554 

1555 - `float`

1556 

1557 - `bool`

1558 

1559 - `chunking_strategy: Optional[FileChunkingStrategy]`

1560 

1561 The strategy used to chunk the file.

1562 

1563 - `class StaticFileChunkingStrategyObject: …`

1564 

1565 - `static: StaticFileChunkingStrategy`

1566 

1567 - `chunk_overlap_tokens: int`

1568 

1569 The number of tokens that overlap between chunks. The default value is `400`.

1570 

1571 Note that the overlap must not exceed half of `max_chunk_size_tokens`.

1572 

1573 - `max_chunk_size_tokens: int`

1574 

1575 The maximum number of tokens in each chunk. The default value is `800`. The minimum value is `100` and the maximum value is `4096`.

1576 

1577 - `type: Literal["static"]`

1578 

1579 Always `static`.

1580 

1581 - `"static"`

1582 

1583 - `class OtherFileChunkingStrategyObject: …`

1584 

1585 This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the `chunking_strategy` concept was introduced in the API.

1586 

1587 - `type: Literal["other"]`

1588 

1589 Always `other`.

1590 

1591 - `"other"`

1592 

1593### Example

1594 

1595```python

1596import os

1597from openai import OpenAI

1598 

1599client = OpenAI(

1600 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

1601)

1602page = client.vector_stores.files.list(

1603 vector_store_id="vector_store_id",

1604)

1605page = page.data[0]

1606print(page.id)

1607```

1608 

1609#### Response

1610 

1611```json

1612{

1613 "data": [

1614 {

1615 "id": "id",

1616 "created_at": 0,

1617 "last_error": {

1618 "code": "server_error",

1619 "message": "message"

1620 },

1621 "object": "vector_store.file",

1622 "status": "in_progress",

1623 "usage_bytes": 0,

1624 "vector_store_id": "vector_store_id",

1625 "attributes": {

1626 "foo": "string"

1627 },

1628 "chunking_strategy": {

1629 "static": {

1630 "chunk_overlap_tokens": 0,

1631 "max_chunk_size_tokens": 100

1632 },

1633 "type": "static"

1634 }

1635 }

1636 ],

1637 "first_id": "file-abc123",

1638 "has_more": false,

1639 "last_id": "file-abc456",

1640 "object": "list"

1641}

1642```

1643 

1644### Example

1645 

1646```python

1647from openai import OpenAI

1648client = OpenAI()

1649 

1650vector_store_files = client.vector_stores.files.list(

1651 vector_store_id="vs_abc123"

1652)

1653print(vector_store_files)

1654```

1655 

1656#### Response

1657 

1658```json

1659{

1660 "object": "list",

1661 "data": [

1662 {

1663 "id": "file-abc123",

1664 "object": "vector_store.file",

1665 "created_at": 1699061776,

1666 "vector_store_id": "vs_abc123"

1667 },

1668 {

1669 "id": "file-abc456",

1670 "object": "vector_store.file",

1671 "created_at": 1699061776,

1672 "vector_store_id": "vs_abc123"

1673 }

1674 ],

1675 "first_id": "file-abc123",

1676 "last_id": "file-abc456",

1677 "has_more": false

1678}

1679```

1680 

1681## Create vector store file

1682 

1683`vector_stores.files.create(strvector_store_id, FileCreateParams**kwargs) -> VectorStoreFile`

1684 

1685**post** `/vector_stores/{vector_store_id}/files`

1686 

1687Create 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).

1688 

1689### Parameters

1690 

1691- `vector_store_id: str`

1692 

1693- `file_id: str`

1694 

1695 A [File](https://platform.openai.com/docs/api-reference/files) ID that the vector store should use. Useful for tools like `file_search` that can access files. For multi-file ingestion, we recommend [`file_batches`](https://platform.openai.com/docs/api-reference/vector-stores-file-batches/createBatch) to minimize per-vector-store write requests.

1696 

1697- `attributes: Optional[Dict[str, Union[str, float, bool]]]`

1698 

1699 Set of 16 key-value pairs that can be attached to an object. This can be

1700 useful for storing additional information about the object in a structured

1701 format, and querying for objects via API or the dashboard. Keys are strings

1702 with a maximum length of 64 characters. Values are strings with a maximum

1703 length of 512 characters, booleans, or numbers.

1704 

1705 - `str`

1706 

1707 - `float`

1708 

1709 - `bool`

1710 

1711- `chunking_strategy: Optional[FileChunkingStrategyParam]`

1712 

1713 The chunking strategy used to chunk the file(s). If not set, will use the `auto` strategy. Only applicable if `file_ids` is non-empty.

1714 

1715 - `class AutoFileChunkingStrategyParam: …`

1716 

1717 The default strategy. This strategy currently uses a `max_chunk_size_tokens` of `800` and `chunk_overlap_tokens` of `400`.

1718 

1719 - `type: Literal["auto"]`

1720 

1721 Always `auto`.

1722 

1723 - `"auto"`

1724 

1725 - `class StaticFileChunkingStrategyObjectParam: …`

1726 

1727 Customize your own chunking strategy by setting chunk size and chunk overlap.

1728 

1729 - `static: StaticFileChunkingStrategy`

1730 

1731 - `chunk_overlap_tokens: int`

1732 

1733 The number of tokens that overlap between chunks. The default value is `400`.

1734 

1735 Note that the overlap must not exceed half of `max_chunk_size_tokens`.

1736 

1737 - `max_chunk_size_tokens: int`

1738 

1739 The maximum number of tokens in each chunk. The default value is `800`. The minimum value is `100` and the maximum value is `4096`.

1740 

1741 - `type: Literal["static"]`

1742 

1743 Always `static`.

1744 

1745 - `"static"`

1746 

1747### Returns

1748 

1749- `class VectorStoreFile: …`

1750 

1751 A list of files attached to a vector store.

1752 

1753 - `id: str`

1754 

1755 The identifier, which can be referenced in API endpoints.

1756 

1757 - `created_at: int`

1758 

1759 The Unix timestamp (in seconds) for when the vector store file was created.

1760 

1761 - `last_error: Optional[LastError]`

1762 

1763 The last error associated with this vector store file. Will be `null` if there are no errors.

1764 

1765 - `code: Literal["server_error", "unsupported_file", "invalid_file"]`

1766 

1767 One of `server_error`, `unsupported_file`, or `invalid_file`.

1768 

1769 - `"server_error"`

1770 

1771 - `"unsupported_file"`

1772 

1773 - `"invalid_file"`

1774 

1775 - `message: str`

1776 

1777 A human-readable description of the error.

1778 

1779 - `object: Literal["vector_store.file"]`

1780 

1781 The object type, which is always `vector_store.file`.

1782 

1783 - `"vector_store.file"`

1784 

1785 - `status: Literal["in_progress", "completed", "cancelled", "failed"]`

1786 

1787 The status of the vector store file, which can be either `in_progress`, `completed`, `cancelled`, or `failed`. The status `completed` indicates that the vector store file is ready for use.

1788 

1789 - `"in_progress"`

1790 

1791 - `"completed"`

1792 

1793 - `"cancelled"`

1794 

1795 - `"failed"`

1796 

1797 - `usage_bytes: int`

1798 

1799 The total vector store usage in bytes. Note that this may be different from the original file size.

1800 

1801 - `vector_store_id: str`

1802 

1803 The ID of the [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object) that the [File](https://platform.openai.com/docs/api-reference/files) is attached to.

1804 

1805 - `attributes: Optional[Dict[str, Union[str, float, bool]]]`

1806 

1807 Set of 16 key-value pairs that can be attached to an object. This can be

1808 useful for storing additional information about the object in a structured

1809 format, and querying for objects via API or the dashboard. Keys are strings

1810 with a maximum length of 64 characters. Values are strings with a maximum

1811 length of 512 characters, booleans, or numbers.

1812 

1813 - `str`

1814 

1815 - `float`

1816 

1817 - `bool`

1818 

1819 - `chunking_strategy: Optional[FileChunkingStrategy]`

1820 

1821 The strategy used to chunk the file.

1822 

1823 - `class StaticFileChunkingStrategyObject: …`

1824 

1825 - `static: StaticFileChunkingStrategy`

1826 

1827 - `chunk_overlap_tokens: int`

1828 

1829 The number of tokens that overlap between chunks. The default value is `400`.

1830 

1831 Note that the overlap must not exceed half of `max_chunk_size_tokens`.

1832 

1833 - `max_chunk_size_tokens: int`

1834 

1835 The maximum number of tokens in each chunk. The default value is `800`. The minimum value is `100` and the maximum value is `4096`.

1836 

1837 - `type: Literal["static"]`

1838 

1839 Always `static`.

1840 

1841 - `"static"`

1842 

1843 - `class OtherFileChunkingStrategyObject: …`

1844 

1845 This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the `chunking_strategy` concept was introduced in the API.

1846 

1847 - `type: Literal["other"]`

1848 

1849 Always `other`.

1850 

1851 - `"other"`

1852 

1853### Example

1854 

1855```python

1856import os

1857from openai import OpenAI

1858 

1859client = OpenAI(

1860 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

1861)

1862vector_store_file = client.vector_stores.files.create(

1863 vector_store_id="vs_abc123",

1864 file_id="file_id",

1865)

1866print(vector_store_file.id)

1867```

1868 

1869#### Response

1870 

1871```json

1872{

1873 "id": "id",

1874 "created_at": 0,

1875 "last_error": {

1876 "code": "server_error",

1877 "message": "message"

1878 },

1879 "object": "vector_store.file",

1880 "status": "in_progress",

1881 "usage_bytes": 0,

1882 "vector_store_id": "vector_store_id",

1883 "attributes": {

1884 "foo": "string"

1885 },

1886 "chunking_strategy": {

1887 "static": {

1888 "chunk_overlap_tokens": 0,

1889 "max_chunk_size_tokens": 100

1890 },

1891 "type": "static"

1892 }

1893}

1894```

1895 

1896### Example

1897 

1898```python

1899from openai import OpenAI

1900client = OpenAI()

1901 

1902vector_store_file = client.vector_stores.files.create(

1903 vector_store_id="vs_abc123",

1904 file_id="file-abc123"

1905)

1906print(vector_store_file)

1907```

1908 

1909#### Response

1910 

1911```json

1912{

1913 "id": "file-abc123",

1914 "object": "vector_store.file",

1915 "created_at": 1699061776,

1916 "usage_bytes": 1234,

1917 "vector_store_id": "vs_abcd",

1918 "status": "completed",

1919 "last_error": null

1920}

1921```

1922 

1923## Update vector store file attributes

1924 

1925`vector_stores.files.update(strfile_id, FileUpdateParams**kwargs) -> VectorStoreFile`

1926 

1927**post** `/vector_stores/{vector_store_id}/files/{file_id}`

1928 

1929Update attributes on a vector store file.

1930 

1931### Parameters

1932 

1933- `vector_store_id: str`

1934 

1935- `file_id: str`

1936 

1937- `attributes: Optional[Dict[str, Union[str, float, bool]]]`

1938 

1939 Set of 16 key-value pairs that can be attached to an object. This can be

1940 useful for storing additional information about the object in a structured

1941 format, and querying for objects via API or the dashboard. Keys are strings

1942 with a maximum length of 64 characters. Values are strings with a maximum

1943 length of 512 characters, booleans, or numbers.

1944 

1945 - `str`

1946 

1947 - `float`

1948 

1949 - `bool`

1950 

1951### Returns

1952 

1953- `class VectorStoreFile: …`

1954 

1955 A list of files attached to a vector store.

1956 

1957 - `id: str`

1958 

1959 The identifier, which can be referenced in API endpoints.

1960 

1961 - `created_at: int`

1962 

1963 The Unix timestamp (in seconds) for when the vector store file was created.

1964 

1965 - `last_error: Optional[LastError]`

1966 

1967 The last error associated with this vector store file. Will be `null` if there are no errors.

1968 

1969 - `code: Literal["server_error", "unsupported_file", "invalid_file"]`

1970 

1971 One of `server_error`, `unsupported_file`, or `invalid_file`.

1972 

1973 - `"server_error"`

1974 

1975 - `"unsupported_file"`

1976 

1977 - `"invalid_file"`

1978 

1979 - `message: str`

1980 

1981 A human-readable description of the error.

1982 

1983 - `object: Literal["vector_store.file"]`

1984 

1985 The object type, which is always `vector_store.file`.

1986 

1987 - `"vector_store.file"`

1988 

1989 - `status: Literal["in_progress", "completed", "cancelled", "failed"]`

1990 

1991 The status of the vector store file, which can be either `in_progress`, `completed`, `cancelled`, or `failed`. The status `completed` indicates that the vector store file is ready for use.

1992 

1993 - `"in_progress"`

1994 

1995 - `"completed"`

1996