Vector Stores

List vector stores

vector_stores.list(**kwargs) -> CursorPage<VectorStore>

get /vector_stores

Returns a list of vector stores.

Parameters

after: String

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.
before: String

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.
limit: Integer

A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
order: :asc | :desc

Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
- :asc
- :desc

Returns

class VectorStore

A vector store is a collection of processed files can be used by the file_search tool.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store was created.
- file_counts: FileCounts{ cancelled, completed, failed, 2 more}
  - cancelled: Integer
    
    The number of files that were cancelled.
  - completed: Integer
    
    The number of files that have been successfully processed.
  - failed: Integer
    
    The number of files that have failed to process.
  - in_progress: Integer
    
    The number of files that are currently being processed.
  - total: Integer
    
    The total number of files.
- last_active_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- metadata: Metadata
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- name: String
  
  The name of the vector store.
- object: :vector_store
  
  The object type, which is always vector_store.
  - :vector_store
- status: :expired | :in_progress | :completed
  
  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.
  - :expired
  - :in_progress
  - :completed
- usage_bytes: Integer
  
  The total number of bytes used by the files in the vector store.
- expires_after: ExpiresAfter{ anchor, days}
  
  The expiration policy for a vector store.
  - anchor: :last_active_at
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - :last_active_at
  - days: Integer
    
    The number of days after the anchor time that the vector store will expire.
- expires_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

page = openai.vector_stores.list

puts(page)

Response

{
  "data": [
    {
      "id": "id",
      "created_at": 0,
      "file_counts": {
        "cancelled": 0,
        "completed": 0,
        "failed": 0,
        "in_progress": 0,
        "total": 0
      },
      "last_active_at": 0,
      "metadata": {
        "foo": "string"
      },
      "name": "name",
      "object": "vector_store",
      "status": "expired",
      "usage_bytes": 0,
      "expires_after": {
        "anchor": "last_active_at",
        "days": 1
      },
      "expires_at": 0
    }
  ],
  "first_id": "vs_abc123",
  "has_more": false,
  "last_id": "vs_abc456",
  "object": "list"
}

Create vector store

vector_stores.create(**kwargs) -> VectorStore

post /vector_stores

Create a vector store.

Parameters

chunking_strategy: FileChunkingStrategyParam

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.
- class AutoFileChunkingStrategyParam
  
  The default strategy. This strategy currently uses a max_chunk_size_tokens of 800 and chunk_overlap_tokens of 400.
  - type: :auto
    
    Always auto.
    - :auto
- class StaticFileChunkingStrategyObjectParam
  
  Customize your own chunking strategy by setting chunk size and chunk overlap.
  - static: StaticFileChunkingStrategy
    - chunk_overlap_tokens: Integer
      
      The number of tokens that overlap between chunks. The default value is 400.
      
      Note that the overlap must not exceed half of max_chunk_size_tokens.
    - max_chunk_size_tokens: Integer
      
      The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
  - type: :static
    
    Always static.
    - :static
description: String

A description for the vector store. Can be used to describe the vector store's purpose.
expires_after: ExpiresAfter{ anchor, days}

The expiration policy for a vector store.
- anchor: :last_active_at
  
  Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
  - :last_active_at
- days: Integer
  
  The number of days after the anchor time that the vector store will expire.
file_ids: Array[String]

A list of File IDs that the vector store should use. Useful for tools like file_search that can access files.
metadata: Metadata

Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.

Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
name: String

The name of the vector store.

Returns

class VectorStore

A vector store is a collection of processed files can be used by the file_search tool.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store was created.
- file_counts: FileCounts{ cancelled, completed, failed, 2 more}
  - cancelled: Integer
    
    The number of files that were cancelled.
  - completed: Integer
    
    The number of files that have been successfully processed.
  - failed: Integer
    
    The number of files that have failed to process.
  - in_progress: Integer
    
    The number of files that are currently being processed.
  - total: Integer
    
    The total number of files.
- last_active_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- metadata: Metadata
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- name: String
  
  The name of the vector store.
- object: :vector_store
  
  The object type, which is always vector_store.
  - :vector_store
- status: :expired | :in_progress | :completed
  
  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.
  - :expired
  - :in_progress
  - :completed
- usage_bytes: Integer
  
  The total number of bytes used by the files in the vector store.
- expires_after: ExpiresAfter{ anchor, days}
  
  The expiration policy for a vector store.
  - anchor: :last_active_at
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - :last_active_at
  - days: Integer
    
    The number of days after the anchor time that the vector store will expire.
- expires_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store = openai.vector_stores.create

puts(vector_store)

Response

{
  "id": "id",
  "created_at": 0,
  "file_counts": {
    "cancelled": 0,
    "completed": 0,
    "failed": 0,
    "in_progress": 0,
    "total": 0
  },
  "last_active_at": 0,
  "metadata": {
    "foo": "string"
  },
  "name": "name",
  "object": "vector_store",
  "status": "expired",
  "usage_bytes": 0,
  "expires_after": {
    "anchor": "last_active_at",
    "days": 1
  },
  "expires_at": 0
}

Retrieve vector store

vector_stores.retrieve(vector_store_id) -> VectorStore

get /vector_stores/{vector_store_id}

Retrieves a vector store.

Parameters

vector_store_id: String

Returns

class VectorStore

A vector store is a collection of processed files can be used by the file_search tool.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store was created.
- file_counts: FileCounts{ cancelled, completed, failed, 2 more}
  - cancelled: Integer
    
    The number of files that were cancelled.
  - completed: Integer
    
    The number of files that have been successfully processed.
  - failed: Integer
    
    The number of files that have failed to process.
  - in_progress: Integer
    
    The number of files that are currently being processed.
  - total: Integer
    
    The total number of files.
- last_active_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- metadata: Metadata
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- name: String
  
  The name of the vector store.
- object: :vector_store
  
  The object type, which is always vector_store.
  - :vector_store
- status: :expired | :in_progress | :completed
  
  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.
  - :expired
  - :in_progress
  - :completed
- usage_bytes: Integer
  
  The total number of bytes used by the files in the vector store.
- expires_after: ExpiresAfter{ anchor, days}
  
  The expiration policy for a vector store.
  - anchor: :last_active_at
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - :last_active_at
  - days: Integer
    
    The number of days after the anchor time that the vector store will expire.
- expires_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store = openai.vector_stores.retrieve("vector_store_id")

puts(vector_store)

Response

{
  "id": "id",
  "created_at": 0,
  "file_counts": {
    "cancelled": 0,
    "completed": 0,
    "failed": 0,
    "in_progress": 0,
    "total": 0
  },
  "last_active_at": 0,
  "metadata": {
    "foo": "string"
  },
  "name": "name",
  "object": "vector_store",
  "status": "expired",
  "usage_bytes": 0,
  "expires_after": {
    "anchor": "last_active_at",
    "days": 1
  },
  "expires_at": 0
}

Modify vector store

vector_stores.update(vector_store_id, **kwargs) -> VectorStore

post /vector_stores/{vector_store_id}

Modifies a vector store.

Parameters

vector_store_id: String
expires_after: ExpiresAfter{ anchor, days}

The expiration policy for a vector store.
- anchor: :last_active_at
  
  Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
  - :last_active_at
- days: Integer
  
  The number of days after the anchor time that the vector store will expire.
metadata: Metadata

Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.

Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
name: String

The name of the vector store.

Returns

class VectorStore

A vector store is a collection of processed files can be used by the file_search tool.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store was created.
- file_counts: FileCounts{ cancelled, completed, failed, 2 more}
  - cancelled: Integer
    
    The number of files that were cancelled.
  - completed: Integer
    
    The number of files that have been successfully processed.
  - failed: Integer
    
    The number of files that have failed to process.
  - in_progress: Integer
    
    The number of files that are currently being processed.
  - total: Integer
    
    The total number of files.
- last_active_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- metadata: Metadata
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- name: String
  
  The name of the vector store.
- object: :vector_store
  
  The object type, which is always vector_store.
  - :vector_store
- status: :expired | :in_progress | :completed
  
  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.
  - :expired
  - :in_progress
  - :completed
- usage_bytes: Integer
  
  The total number of bytes used by the files in the vector store.
- expires_after: ExpiresAfter{ anchor, days}
  
  The expiration policy for a vector store.
  - anchor: :last_active_at
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - :last_active_at
  - days: Integer
    
    The number of days after the anchor time that the vector store will expire.
- expires_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store = openai.vector_stores.update("vector_store_id")

puts(vector_store)

Response

{
  "id": "id",
  "created_at": 0,
  "file_counts": {
    "cancelled": 0,
    "completed": 0,
    "failed": 0,
    "in_progress": 0,
    "total": 0
  },
  "last_active_at": 0,
  "metadata": {
    "foo": "string"
  },
  "name": "name",
  "object": "vector_store",
  "status": "expired",
  "usage_bytes": 0,
  "expires_after": {
    "anchor": "last_active_at",
    "days": 1
  },
  "expires_at": 0
}

Delete vector store

vector_stores.delete(vector_store_id) -> VectorStoreDeleted

delete /vector_stores/{vector_store_id}

Delete a vector store.

Parameters

vector_store_id: String

Returns

class VectorStoreDeleted
- id: String
- deleted: bool
- object: :"vector_store.deleted"
  - :"vector_store.deleted"

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store_deleted = openai.vector_stores.delete("vector_store_id")

puts(vector_store_deleted)

Response

{
  "id": "id",
  "deleted": true,
  "object": "vector_store.deleted"
}

Search vector store

vector_stores.search(vector_store_id, **kwargs) -> Page<VectorStoreSearchResponse>

post /vector_stores/{vector_store_id}/search

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

Parameters

vector_store_id: String
query: String | Array[String]

A query string for a search
- String = String
- UnionMember1 = Array[String]
filters: ComparisonFilter | CompoundFilter

A filter to apply based on file attributes.
- class ComparisonFilter
  
  A filter used to compare a specified attribute key to a given value using a defined comparison operation.
  - key: String
    
    The key to compare against the value.
  - type: :eq | :ne | :gt | 5 more
    
    Specifies the comparison operator: eq, ne, gt, gte, lt, lte, in, nin.
    - eq: equals
    - ne: not equal
    - gt: greater than
    - gte: greater than or equal
    - lt: less than
    - lte: less than or equal
    - in: in
    - nin: not in
    - :eq
    - :ne
    - :gt
    - :gte
    - :lt
    - :lte
    - :in
    - :nin
  - value: String | Float | bool | Array[String | Float]
    
    The value to compare against the attribute key; supports string, number, or boolean types.
    - String = String
    - Float = Float
    - UnionMember2 = bool
    - UnionMember3 = Array[String | Float]
      - String = String
      - Float = Float
- class CompoundFilter
  
  Combine multiple filters using and or or.
  - filters: Array[ComparisonFilter | untyped]
    
    Array of filters to combine. Items can be ComparisonFilter or CompoundFilter.
    - class ComparisonFilter
      
      A filter used to compare a specified attribute key to a given value using a defined comparison operation.
    - UnionMember1 = untyped
  - type: :and | :or
    
    Type of operation: and or or.
    - :and
    - :or
max_num_results: Integer

The maximum number of results to return. This number should be between 1 and 50 inclusive.
ranking_options: RankingOptions{ ranker, score_threshold}

Ranking options for search.
- ranker: :none | :auto | :"default-2024-11-15"
  
  Enable re-ranking; set to none to disable, which can help reduce latency.
  - :none
  - :auto
  - :"default-2024-11-15"
- score_threshold: Float
rewrite_query: bool

Whether to rewrite the natural language query for vector search.

Returns

class VectorStoreSearchResponse
- attributes: Hash[Symbol, String | Float | bool]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
  - String = String
  - Float = Float
  - UnionMember2 = bool
- content: Array[Content{ text, type}]
  
  Content chunks from the file.
  - text: String
    
    The text content returned from search.
  - type: :text
    
    The type of content.
    - :text
- file_id: String
  
  The ID of the vector store file.
- filename: String
  
  The name of the vector store file.
- score: Float
  
  The similarity score for the result.

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

page = openai.vector_stores.search("vs_abc123", query: "string")

puts(page)

Response

{
  "data": [
    {
      "attributes": {
        "foo": "string"
      },
      "content": [
        {
          "text": "text",
          "type": "text"
        }
      ],
      "file_id": "file_id",
      "filename": "filename",
      "score": 0
    }
  ],
  "has_more": true,
  "next_page": "next_page",
  "object": "vector_store.search_results.page",
  "search_query": [
    "string"
  ]
}

Domain Types

Auto File Chunking Strategy Param

class AutoFileChunkingStrategyParam

The default strategy. This strategy currently uses a max_chunk_size_tokens of 800 and chunk_overlap_tokens of 400.
- type: :auto
  
  Always auto.
  - :auto

File Chunking Strategy

FileChunkingStrategy = StaticFileChunkingStrategyObject | OtherFileChunkingStrategyObject

The strategy used to chunk the file.
- class StaticFileChunkingStrategyObject
  - static: StaticFileChunkingStrategy
    - chunk_overlap_tokens: Integer
      
      The number of tokens that overlap between chunks. The default value is 400.
      
      Note that the overlap must not exceed half of max_chunk_size_tokens.
    - max_chunk_size_tokens: Integer
      
      The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
  - type: :static
    
    Always static.
    - :static
- class OtherFileChunkingStrategyObject
  
  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.
  - type: :other
    
    Always other.
    - :other

File Chunking Strategy Param

FileChunkingStrategyParam = AutoFileChunkingStrategyParam | StaticFileChunkingStrategyObjectParam

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.
- class AutoFileChunkingStrategyParam
  
  The default strategy. This strategy currently uses a max_chunk_size_tokens of 800 and chunk_overlap_tokens of 400.
  - type: :auto
    
    Always auto.
    - :auto
- class StaticFileChunkingStrategyObjectParam
  
  Customize your own chunking strategy by setting chunk size and chunk overlap.
  - static: StaticFileChunkingStrategy
    - chunk_overlap_tokens: Integer
      
      The number of tokens that overlap between chunks. The default value is 400.
      
      Note that the overlap must not exceed half of max_chunk_size_tokens.
    - max_chunk_size_tokens: Integer
      
      The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
  - type: :static
    
    Always static.
    - :static

Other File Chunking Strategy Object

class OtherFileChunkingStrategyObject

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.
- type: :other
  
  Always other.
  - :other

Static File Chunking Strategy

class StaticFileChunkingStrategy
- chunk_overlap_tokens: Integer
  
  The number of tokens that overlap between chunks. The default value is 400.
  
  Note that the overlap must not exceed half of max_chunk_size_tokens.
- max_chunk_size_tokens: Integer
  
  The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.

Static File Chunking Strategy Object

class StaticFileChunkingStrategyObject
- static: StaticFileChunkingStrategy
  - chunk_overlap_tokens: Integer
    
    The number of tokens that overlap between chunks. The default value is 400.
    
    Note that the overlap must not exceed half of max_chunk_size_tokens.
  - max_chunk_size_tokens: Integer
    
    The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
- type: :static
  
  Always static.
  - :static

Static File Chunking Strategy Object Param

class StaticFileChunkingStrategyObjectParam

Customize your own chunking strategy by setting chunk size and chunk overlap.
- static: StaticFileChunkingStrategy
  - chunk_overlap_tokens: Integer
    
    The number of tokens that overlap between chunks. The default value is 400.
    
    Note that the overlap must not exceed half of max_chunk_size_tokens.
  - max_chunk_size_tokens: Integer
    
    The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
- type: :static
  
  Always static.
  - :static

Vector Store

class VectorStore

A vector store is a collection of processed files can be used by the file_search tool.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store was created.
- file_counts: FileCounts{ cancelled, completed, failed, 2 more}
  - cancelled: Integer
    
    The number of files that were cancelled.
  - completed: Integer
    
    The number of files that have been successfully processed.
  - failed: Integer
    
    The number of files that have failed to process.
  - in_progress: Integer
    
    The number of files that are currently being processed.
  - total: Integer
    
    The total number of files.
- last_active_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- metadata: Metadata
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- name: String
  
  The name of the vector store.
- object: :vector_store
  
  The object type, which is always vector_store.
  - :vector_store
- status: :expired | :in_progress | :completed
  
  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.
  - :expired
  - :in_progress
  - :completed
- usage_bytes: Integer
  
  The total number of bytes used by the files in the vector store.
- expires_after: ExpiresAfter{ anchor, days}
  
  The expiration policy for a vector store.
  - anchor: :last_active_at
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - :last_active_at
  - days: Integer
    
    The number of days after the anchor time that the vector store will expire.
- expires_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Vector Store Deleted

class VectorStoreDeleted
- id: String
- deleted: bool
- object: :"vector_store.deleted"
  - :"vector_store.deleted"

Vector Store Search Response

class VectorStoreSearchResponse
- attributes: Hash[Symbol, String | Float | bool]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
  - String = String
  - Float = Float
  - UnionMember2 = bool
- content: Array[Content{ text, type}]
  
  Content chunks from the file.
  - text: String
    
    The text content returned from search.
  - type: :text
    
    The type of content.
    - :text
- file_id: String
  
  The ID of the vector store file.
- filename: String
  
  The name of the vector store file.
- score: Float
  
  The similarity score for the result.

Files

List vector store files

vector_stores.files.list(vector_store_id, **kwargs) -> CursorPage<VectorStoreFile>

get /vector_stores/{vector_store_id}/files

Returns a list of vector store files.

Parameters

vector_store_id: String
after: String

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.
before: String

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.
filter: :in_progress | :completed | :failed | :cancelled

Filter by file status. One of in_progress, completed, failed, cancelled.
- :in_progress
- :completed
- :failed
- :cancelled
limit: Integer

A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
order: :asc | :desc

Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
- :asc
- :desc

Returns

class VectorStoreFile

A list of files attached to a vector store.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- last_error: LastError{ code, message}
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - code: :server_error | :unsupported_file | :invalid_file
    
    One of server_error, unsupported_file, or invalid_file.
    - :server_error
    - :unsupported_file
    - :invalid_file
  - message: String
    
    A human-readable description of the error.
- object: :"vector_store.file"
  
  The object type, which is always vector_store.file.
  - :"vector_store.file"
- status: :in_progress | :completed | :cancelled | :failed
  
  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.
  - :in_progress
  - :completed
  - :cancelled
  - :failed
- usage_bytes: Integer
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- vector_store_id: String
  
  The ID of the vector store that the File is attached to.
- attributes: Hash[Symbol, String | Float | bool]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
  - String = String
  - Float = Float
  - UnionMember2 = bool
- chunking_strategy: FileChunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject
    - static: StaticFileChunkingStrategy
      - chunk_overlap_tokens: Integer
        
        The number of tokens that overlap between chunks. The default value is 400.
        
        Note that the overlap must not exceed half of max_chunk_size_tokens.
      - max_chunk_size_tokens: Integer
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - type: :static
      
      Always static.
      - :static
  - class OtherFileChunkingStrategyObject
    
    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.
    - type: :other
      
      Always other.
      - :other

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

page = openai.vector_stores.files.list("vector_store_id")

puts(page)

Response

{
  "data": [
    {
      "id": "id",
      "created_at": 0,
      "last_error": {
        "code": "server_error",
        "message": "message"
      },
      "object": "vector_store.file",
      "status": "in_progress",
      "usage_bytes": 0,
      "vector_store_id": "vector_store_id",
      "attributes": {
        "foo": "string"
      },
      "chunking_strategy": {
        "static": {
          "chunk_overlap_tokens": 0,
          "max_chunk_size_tokens": 100
        },
        "type": "static"
      }
    }
  ],
  "first_id": "file-abc123",
  "has_more": false,
  "last_id": "file-abc456",
  "object": "list"
}

Create vector store file

vector_stores.files.create(vector_store_id, **kwargs) -> VectorStoreFile

post /vector_stores/{vector_store_id}/files

Create a vector store file by attaching a File to a vector store.

Parameters

vector_store_id: String
file_id: String

A File 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 to minimize per-vector-store write requests.
attributes: Hash[Symbol, String | Float | bool]

Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
- String = String
- Float = Float
- UnionMember2 = bool
chunking_strategy: FileChunkingStrategyParam

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.
- class AutoFileChunkingStrategyParam
  
  The default strategy. This strategy currently uses a max_chunk_size_tokens of 800 and chunk_overlap_tokens of 400.
  - type: :auto
    
    Always auto.
    - :auto
- class StaticFileChunkingStrategyObjectParam
  
  Customize your own chunking strategy by setting chunk size and chunk overlap.
  - static: StaticFileChunkingStrategy
    - chunk_overlap_tokens: Integer
      
      The number of tokens that overlap between chunks. The default value is 400.
      
      Note that the overlap must not exceed half of max_chunk_size_tokens.
    - max_chunk_size_tokens: Integer
      
      The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
  - type: :static
    
    Always static.
    - :static

Returns

class VectorStoreFile

A list of files attached to a vector store.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- last_error: LastError{ code, message}
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - code: :server_error | :unsupported_file | :invalid_file
    
    One of server_error, unsupported_file, or invalid_file.
    - :server_error
    - :unsupported_file
    - :invalid_file
  - message: String
    
    A human-readable description of the error.
- object: :"vector_store.file"
  
  The object type, which is always vector_store.file.
  - :"vector_store.file"
- status: :in_progress | :completed | :cancelled | :failed
  
  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.
  - :in_progress
  - :completed
  - :cancelled
  - :failed
- usage_bytes: Integer
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- vector_store_id: String
  
  The ID of the vector store that the File is attached to.
- attributes: Hash[Symbol, String | Float | bool]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
  - String = String
  - Float = Float
  - UnionMember2 = bool
- chunking_strategy: FileChunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject
    - static: StaticFileChunkingStrategy
      - chunk_overlap_tokens: Integer
        
        The number of tokens that overlap between chunks. The default value is 400.
        
        Note that the overlap must not exceed half of max_chunk_size_tokens.
      - max_chunk_size_tokens: Integer
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - type: :static
      
      Always static.
      - :static
  - class OtherFileChunkingStrategyObject
    
    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.
    - type: :other
      
      Always other.
      - :other

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store_file = openai.vector_stores.files.create("vs_abc123", file_id: "file_id")

puts(vector_store_file)

Response

{
  "id": "id",
  "created_at": 0,
  "last_error": {
    "code": "server_error",
    "message": "message"
  },
  "object": "vector_store.file",
  "status": "in_progress",
  "usage_bytes": 0,
  "vector_store_id": "vector_store_id",
  "attributes": {
    "foo": "string"
  },
  "chunking_strategy": {
    "static": {
      "chunk_overlap_tokens": 0,
      "max_chunk_size_tokens": 100
    },
    "type": "static"
  }
}

Update vector store file attributes

vector_stores.files.update(file_id, **kwargs) -> VectorStoreFile

post /vector_stores/{vector_store_id}/files/{file_id}

Update attributes on a vector store file.

Parameters

vector_store_id: String
file_id: String
attributes: Hash[Symbol, String | Float | bool]

Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
- String = String
- Float = Float
- UnionMember2 = bool

Returns

class VectorStoreFile

A list of files attached to a vector store.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- last_error: LastError{ code, message}
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - code: :server_error | :unsupported_file | :invalid_file
    
    One of server_error, unsupported_file, or invalid_file.
    - :server_error
    - :unsupported_file
    - :invalid_file
  - message: String
    
    A human-readable description of the error.
- object: :"vector_store.file"
  
  The object type, which is always vector_store.file.
  - :"vector_store.file"
- status: :in_progress | :completed | :cancelled | :failed
  
  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.
  - :in_progress
  - :completed
  - :cancelled
  - :failed
- usage_bytes: Integer
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- vector_store_id: String
  
  The ID of the vector store that the File is attached to.
- attributes: Hash[Symbol, String | Float | bool]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
  - String = String
  - Float = Float
  - UnionMember2 = bool
- chunking_strategy: FileChunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject
    - static: StaticFileChunkingStrategy
      - chunk_overlap_tokens: Integer
        
        The number of tokens that overlap between chunks. The default value is 400.
        
        Note that the overlap must not exceed half of max_chunk_size_tokens.
      - max_chunk_size_tokens: Integer
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - type: :static
      
      Always static.
      - :static
  - class OtherFileChunkingStrategyObject
    
    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.
    - type: :other
      
      Always other.
      - :other

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store_file = openai.vector_stores.files.update(
  "file-abc123",
  vector_store_id: "vs_abc123",
  attributes: {foo: "string"}
)

puts(vector_store_file)

Response

{
  "id": "id",
  "created_at": 0,
  "last_error": {
    "code": "server_error",
    "message": "message"
  },
  "object": "vector_store.file",
  "status": "in_progress",
  "usage_bytes": 0,
  "vector_store_id": "vector_store_id",
  "attributes": {
    "foo": "string"
  },
  "chunking_strategy": {
    "static": {
      "chunk_overlap_tokens": 0,
      "max_chunk_size_tokens": 100
    },
    "type": "static"
  }
}

Retrieve vector store file

vector_stores.files.retrieve(file_id, **kwargs) -> VectorStoreFile

get /vector_stores/{vector_store_id}/files/{file_id}

Retrieves a vector store file.

Parameters

vector_store_id: String
file_id: String

Returns

class VectorStoreFile

A list of files attached to a vector store.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- last_error: LastError{ code, message}
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - code: :server_error | :unsupported_file | :invalid_file
    
    One of server_error, unsupported_file, or invalid_file.
    - :server_error
    - :unsupported_file
    - :invalid_file
  - message: String
    
    A human-readable description of the error.
- object: :"vector_store.file"
  
  The object type, which is always vector_store.file.
  - :"vector_store.file"
- status: :in_progress | :completed | :cancelled | :failed
  
  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.
  - :in_progress
  - :completed
  - :cancelled
  - :failed
- usage_bytes: Integer
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- vector_store_id: String
  
  The ID of the vector store that the File is attached to.
- attributes: Hash[Symbol, String | Float | bool]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
  - String = String
  - Float = Float
  - UnionMember2 = bool
- chunking_strategy: FileChunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject
    - static: StaticFileChunkingStrategy
      - chunk_overlap_tokens: Integer
        
        The number of tokens that overlap between chunks. The default value is 400.
        
        Note that the overlap must not exceed half of max_chunk_size_tokens.
      - max_chunk_size_tokens: Integer
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - type: :static
      
      Always static.
      - :static
  - class OtherFileChunkingStrategyObject
    
    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.
    - type: :other
      
      Always other.
      - :other

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store_file = openai.vector_stores.files.retrieve("file-abc123", vector_store_id: "vs_abc123")

puts(vector_store_file)

Response

{
  "id": "id",
  "created_at": 0,
  "last_error": {
    "code": "server_error",
    "message": "message"
  },
  "object": "vector_store.file",
  "status": "in_progress",
  "usage_bytes": 0,
  "vector_store_id": "vector_store_id",
  "attributes": {
    "foo": "string"
  },
  "chunking_strategy": {
    "static": {
      "chunk_overlap_tokens": 0,
      "max_chunk_size_tokens": 100
    },
    "type": "static"
  }
}

Delete vector store file

vector_stores.files.delete(file_id, **kwargs) -> VectorStoreFileDeleted

delete /vector_stores/{vector_store_id}/files/{file_id}

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 endpoint.

Parameters

vector_store_id: String
file_id: String

Returns

class VectorStoreFileDeleted
- id: String
- deleted: bool
- object: :"vector_store.file.deleted"
  - :"vector_store.file.deleted"

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store_file_deleted = openai.vector_stores.files.delete("file_id", vector_store_id: "vector_store_id")

puts(vector_store_file_deleted)

Response

{
  "id": "id",
  "deleted": true,
  "object": "vector_store.file.deleted"
}

Retrieve vector store file content

vector_stores.files.content(file_id, **kwargs) -> Page<FileContentResponse>

get /vector_stores/{vector_store_id}/files/{file_id}/content

Retrieve the parsed contents of a vector store file.

Parameters

vector_store_id: String
file_id: String

Returns

class FileContentResponse
- text: String
  
  The text content
- type: String
  
  The content type (currently only "text")

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

page = openai.vector_stores.files.content("file-abc123", vector_store_id: "vs_abc123")

puts(page)

Response

{
  "data": [
    {
      "text": "text",
      "type": "type"
    }
  ],
  "has_more": true,
  "next_page": "next_page",
  "object": "vector_store.file_content.page"
}

Domain Types

Vector Store File

class VectorStoreFile

A list of files attached to a vector store.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- last_error: LastError{ code, message}
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - code: :server_error | :unsupported_file | :invalid_file
    
    One of server_error, unsupported_file, or invalid_file.
    - :server_error
    - :unsupported_file
    - :invalid_file
  - message: String
    
    A human-readable description of the error.
- object: :"vector_store.file"
  
  The object type, which is always vector_store.file.
  - :"vector_store.file"
- status: :in_progress | :completed | :cancelled | :failed
  
  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.
  - :in_progress
  - :completed
  - :cancelled
  - :failed
- usage_bytes: Integer
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- vector_store_id: String
  
  The ID of the vector store that the File is attached to.
- attributes: Hash[Symbol, String | Float | bool]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
  - String = String
  - Float = Float
  - UnionMember2 = bool
- chunking_strategy: FileChunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject
    - static: StaticFileChunkingStrategy
      - chunk_overlap_tokens: Integer
        
        The number of tokens that overlap between chunks. The default value is 400.
        
        Note that the overlap must not exceed half of max_chunk_size_tokens.
      - max_chunk_size_tokens: Integer
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - type: :static
      
      Always static.
      - :static
  - class OtherFileChunkingStrategyObject
    
    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.
    - type: :other
      
      Always other.
      - :other

Vector Store File Deleted

class VectorStoreFileDeleted
- id: String
- deleted: bool
- object: :"vector_store.file.deleted"
  - :"vector_store.file.deleted"

File Content Response

class FileContentResponse
- text: String
  
  The text content
- type: String
  
  The content type (currently only "text")

File Batches

Create vector store file batch

vector_stores.file_batches.create(vector_store_id, **kwargs) -> VectorStoreFileBatch

post /vector_stores/{vector_store_id}/file_batches

Create a vector store file batch.

Parameters

vector_store_id: String
attributes: Hash[Symbol, String | Float | bool]

Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
- String = String
- Float = Float
- UnionMember2 = bool
chunking_strategy: FileChunkingStrategyParam

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.
- class AutoFileChunkingStrategyParam
  
  The default strategy. This strategy currently uses a max_chunk_size_tokens of 800 and chunk_overlap_tokens of 400.
  - type: :auto
    
    Always auto.
    - :auto
- class StaticFileChunkingStrategyObjectParam
  
  Customize your own chunking strategy by setting chunk size and chunk overlap.
  - static: StaticFileChunkingStrategy
    - chunk_overlap_tokens: Integer
      
      The number of tokens that overlap between chunks. The default value is 400.
      
      Note that the overlap must not exceed half of max_chunk_size_tokens.
    - max_chunk_size_tokens: Integer
      
      The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
  - type: :static
    
    Always static.
    - :static
file_ids: Array[String]

A list of File IDs that the vector store should use. Useful for tools like file_search that can access files. If attributes or chunking_strategy are provided, they will be applied to all files in the batch. The maximum batch size is 2000 files. This endpoint is recommended for multi-file ingestion and helps reduce per-vector-store write request pressure. Mutually exclusive with files.
files: Array[File{ file_id, attributes, chunking_strategy}]

A list of objects that each include a file_id plus optional attributes or chunking_strategy. Use this when you need to override metadata for specific files. The global attributes or chunking_strategy will be ignored and must be specified for each file. The maximum batch size is 2000 files. This endpoint is recommended for multi-file ingestion and helps reduce per-vector-store write request pressure. Mutually exclusive with file_ids.
- file_id: String
  
  A File 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 to minimize per-vector-store write requests.
- attributes: Hash[Symbol, String | Float | bool]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
  - String = String
  - Float = Float
  - UnionMember2 = bool
- chunking_strategy: FileChunkingStrategyParam
  
  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.

Returns

class VectorStoreFileBatch

A batch of files attached to a vector store.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- file_counts: FileCounts{ cancelled, completed, failed, 2 more}
  - cancelled: Integer
    
    The number of files that where cancelled.
  - completed: Integer
    
    The number of files that have been processed.
  - failed: Integer
    
    The number of files that have failed to process.
  - in_progress: Integer
    
    The number of files that are currently being processed.
  - total: Integer
    
    The total number of files.
- object: :"vector_store.files_batch"
  
  The object type, which is always vector_store.file_batch.
  - :"vector_store.files_batch"
- status: :in_progress | :completed | :cancelled | :failed
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - :in_progress
  - :completed
  - :cancelled
  - :failed
- vector_store_id: String
  
  The ID of the vector store that the File is attached to.

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store_file_batch = openai.vector_stores.file_batches.create("vs_abc123")

puts(vector_store_file_batch)

Response

{
  "id": "id",
  "created_at": 0,
  "file_counts": {
    "cancelled": 0,
    "completed": 0,
    "failed": 0,
    "in_progress": 0,
    "total": 0
  },
  "object": "vector_store.files_batch",
  "status": "in_progress",
  "vector_store_id": "vector_store_id"
}

Retrieve vector store file batch

vector_stores.file_batches.retrieve(batch_id, **kwargs) -> VectorStoreFileBatch

get /vector_stores/{vector_store_id}/file_batches/{batch_id}

Retrieves a vector store file batch.

Parameters

vector_store_id: String
batch_id: String

Returns

class VectorStoreFileBatch

A batch of files attached to a vector store.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- file_counts: FileCounts{ cancelled, completed, failed, 2 more}
  - cancelled: Integer
    
    The number of files that where cancelled.
  - completed: Integer
    
    The number of files that have been processed.
  - failed: Integer
    
    The number of files that have failed to process.
  - in_progress: Integer
    
    The number of files that are currently being processed.
  - total: Integer
    
    The total number of files.
- object: :"vector_store.files_batch"
  
  The object type, which is always vector_store.file_batch.
  - :"vector_store.files_batch"
- status: :in_progress | :completed | :cancelled | :failed
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - :in_progress
  - :completed
  - :cancelled
  - :failed
- vector_store_id: String
  
  The ID of the vector store that the File is attached to.

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store_file_batch = openai.vector_stores.file_batches.retrieve("vsfb_abc123", vector_store_id: "vs_abc123")

puts(vector_store_file_batch)

Response

{
  "id": "id",
  "created_at": 0,
  "file_counts": {
    "cancelled": 0,
    "completed": 0,
    "failed": 0,
    "in_progress": 0,
    "total": 0
  },
  "object": "vector_store.files_batch",
  "status": "in_progress",
  "vector_store_id": "vector_store_id"
}

Cancel vector store file batch

vector_stores.file_batches.cancel(batch_id, **kwargs) -> VectorStoreFileBatch

post /vector_stores/{vector_store_id}/file_batches/{batch_id}/cancel

Cancel a vector store file batch. This attempts to cancel the processing of files in this batch as soon as possible.

Parameters

vector_store_id: String
batch_id: String

Returns

class VectorStoreFileBatch

A batch of files attached to a vector store.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- file_counts: FileCounts{ cancelled, completed, failed, 2 more}
  - cancelled: Integer
    
    The number of files that where cancelled.
  - completed: Integer
    
    The number of files that have been processed.
  - failed: Integer
    
    The number of files that have failed to process.
  - in_progress: Integer
    
    The number of files that are currently being processed.
  - total: Integer
    
    The total number of files.
- object: :"vector_store.files_batch"
  
  The object type, which is always vector_store.file_batch.
  - :"vector_store.files_batch"
- status: :in_progress | :completed | :cancelled | :failed
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - :in_progress
  - :completed
  - :cancelled
  - :failed
- vector_store_id: String
  
  The ID of the vector store that the File is attached to.

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

vector_store_file_batch = openai.vector_stores.file_batches.cancel("batch_id", vector_store_id: "vector_store_id")

puts(vector_store_file_batch)

Response

{
  "id": "id",
  "created_at": 0,
  "file_counts": {
    "cancelled": 0,
    "completed": 0,
    "failed": 0,
    "in_progress": 0,
    "total": 0
  },
  "object": "vector_store.files_batch",
  "status": "in_progress",
  "vector_store_id": "vector_store_id"
}

List vector store files in a batch

vector_stores.file_batches.list_files(batch_id, **kwargs) -> CursorPage<VectorStoreFile>

get /vector_stores/{vector_store_id}/file_batches/{batch_id}/files

Returns a list of vector store files in a batch.

Parameters

vector_store_id: String
batch_id: String
after: String

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.
before: String

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.
filter: :in_progress | :completed | :failed | :cancelled

Filter by file status. One of in_progress, completed, failed, cancelled.
- :in_progress
- :completed
- :failed
- :cancelled
limit: Integer

A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
order: :asc | :desc

Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
- :asc
- :desc

Returns

class VectorStoreFile

A list of files attached to a vector store.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- last_error: LastError{ code, message}
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - code: :server_error | :unsupported_file | :invalid_file
    
    One of server_error, unsupported_file, or invalid_file.
    - :server_error
    - :unsupported_file
    - :invalid_file
  - message: String
    
    A human-readable description of the error.
- object: :"vector_store.file"
  
  The object type, which is always vector_store.file.
  - :"vector_store.file"
- status: :in_progress | :completed | :cancelled | :failed
  
  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.
  - :in_progress
  - :completed
  - :cancelled
  - :failed
- usage_bytes: Integer
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- vector_store_id: String
  
  The ID of the vector store that the File is attached to.
- attributes: Hash[Symbol, String | Float | bool]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters, booleans, or numbers.
  - String = String
  - Float = Float
  - UnionMember2 = bool
- chunking_strategy: FileChunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject
    - static: StaticFileChunkingStrategy
      - chunk_overlap_tokens: Integer
        
        The number of tokens that overlap between chunks. The default value is 400.
        
        Note that the overlap must not exceed half of max_chunk_size_tokens.
      - max_chunk_size_tokens: Integer
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - type: :static
      
      Always static.
      - :static
  - class OtherFileChunkingStrategyObject
    
    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.
    - type: :other
      
      Always other.
      - :other

Example

require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

page = openai.vector_stores.file_batches.list_files("batch_id", vector_store_id: "vector_store_id")

puts(page)

Response

{
  "data": [
    {
      "id": "id",
      "created_at": 0,
      "last_error": {
        "code": "server_error",
        "message": "message"
      },
      "object": "vector_store.file",
      "status": "in_progress",
      "usage_bytes": 0,
      "vector_store_id": "vector_store_id",
      "attributes": {
        "foo": "string"
      },
      "chunking_strategy": {
        "static": {
          "chunk_overlap_tokens": 0,
          "max_chunk_size_tokens": 100
        },
        "type": "static"
      }
    }
  ],
  "first_id": "file-abc123",
  "has_more": false,
  "last_id": "file-abc456",
  "object": "list"
}

Domain Types

Vector Store File Batch

class VectorStoreFileBatch

A batch of files attached to a vector store.
- id: String
  
  The identifier, which can be referenced in API endpoints.
- created_at: Integer
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- file_counts: FileCounts{ cancelled, completed, failed, 2 more}
  - cancelled: Integer
    
    The number of files that where cancelled.
  - completed: Integer
    
    The number of files that have been processed.
  - failed: Integer
    
    The number of files that have failed to process.
  - in_progress: Integer
    
    The number of files that are currently being processed.
  - total: Integer
    
    The total number of files.
- object: :"vector_store.files_batch"
  
  The object type, which is always vector_store.file_batch.
  - :"vector_store.files_batch"
- status: :in_progress | :completed | :cancelled | :failed
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - :in_progress
  - :completed
  - :cancelled
  - :failed
- vector_store_id: String
  
  The ID of the vector store that the File is attached to.

ruby/resources/vector_stores/index.md +431 −35

6 6

7**get** `/vector_stores`7**get** `/vector_stores`

8 8

~~9List vector stores~~9Returns a list of vector stores.

10 10

11### Parameters11### Parameters

12 12

176 176

177**post** `/vector_stores`177**post** `/vector_stores`

178 178

179Create vector store179Create a vector store.

180 180

181### Parameters181### Parameters

182 182

183- `chunking_strategy: untyped`183- `chunking_strategy: FileChunkingStrategyParam`

184

185 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.

186

187 - `class AutoFileChunkingStrategyParam`

188

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

190

191 - `type: :auto`

192

193 Always `auto`.

194

195 - `:auto`

196

197 - `class StaticFileChunkingStrategyObjectParam`

198

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

200

201 - `static: StaticFileChunkingStrategy`

202

203 - `chunk_overlap_tokens: Integer`

204

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

206

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

208

209 - `max_chunk_size_tokens: Integer`

210

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

212

213 - `type: :static`

214

215 Always `static`.

216

217 - `:static`

184 218

185- `description: String`219- `description: String`

186 220

355 389

356**get** `/vector_stores/{vector_store_id}`390**get** `/vector_stores/{vector_store_id}`

357 391

358Retrieve vector store392Retrieves a vector store.

359 393

360### Parameters394### Parameters

361 395

499 533

500**post** `/vector_stores/{vector_store_id}`534**post** `/vector_stores/{vector_store_id}`

501 535

502Modify vector store536Modifies a vector store.

503 537

504### Parameters538### Parameters

505 539

670 704

671**delete** `/vector_stores/{vector_store_id}`705**delete** `/vector_stores/{vector_store_id}`

672 706

673Delete vector store707Delete a vector store.

674 708

675### Parameters709### Parameters

676 710

716 750

717**post** `/vector_stores/{vector_store_id}/search`751**post** `/vector_stores/{vector_store_id}/search`

718 752

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

720 754

721### Parameters755### Parameters

722 756

771 805

772 - `:nin`806 - `:nin`

773 807

775 809

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

777 811

781 815

782 - `UnionMember2 = bool`816 - `UnionMember2 = bool`

783 817

784 - `UnionMember3 = Array[untyped]`818 - `UnionMember3 = Array[String | Float]`

819

820 - `String = String`

821

822 - `Float = Float`

785 823

786 - `class CompoundFilter`824 - `class CompoundFilter`

787 825

930 968

931### File Chunking Strategy969### File Chunking Strategy

932 970

933- `FileChunkingStrategy = untyped`971- `FileChunkingStrategy = StaticFileChunkingStrategyObject | OtherFileChunkingStrategyObject`

972

973 The strategy used to chunk the file.

974

975 - `class StaticFileChunkingStrategyObject`

976

977 - `static: StaticFileChunkingStrategy`

978

979 - `chunk_overlap_tokens: Integer`

980

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

982

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

984

985 - `max_chunk_size_tokens: Integer`

986

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

988

989 - `type: :static`

990

991 Always `static`.

992

993 - `:static`

994

995 - `class OtherFileChunkingStrategyObject`

996

997 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.

998

999 - `type: :other`

1000

1001 Always `other`.

1002

1003 - `:other`

934 1004

935### File Chunking Strategy Param1005### File Chunking Strategy Param

936 1006

937- `FileChunkingStrategyParam = untyped`1007- `FileChunkingStrategyParam = AutoFileChunkingStrategyParam | StaticFileChunkingStrategyObjectParam`

1008

1009 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.

1010

1011 - `class AutoFileChunkingStrategyParam`

1012

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

1014

1015 - `type: :auto`

1016

1017 Always `auto`.

1018

1019 - `:auto`

1020

1021 - `class StaticFileChunkingStrategyObjectParam`

1022

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

1024

1025 - `static: StaticFileChunkingStrategy`

1026

1027 - `chunk_overlap_tokens: Integer`

1028

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

1030

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

1032

1033 - `max_chunk_size_tokens: Integer`

1034

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

1036

1037 - `type: :static`

1038

1039 Always `static`.

1040

1041 - `:static`

938 1042

939### Other File Chunking Strategy Object1043### Other File Chunking Strategy Object

940 1044

1163 1267

1164**get** `/vector_stores/{vector_store_id}/files`1268**get** `/vector_stores/{vector_store_id}/files`

1165 1269

1166List vector store files1270Returns a list of vector store files.

1167 1271

1168### Parameters1272### Parameters

1169 1273

1273 1377

1274 - `UnionMember2 = bool`1378 - `UnionMember2 = bool`

1275 1379

1276 - `chunking_strategy: untyped`1380 - `chunking_strategy: FileChunkingStrategy`

1381

1382 The strategy used to chunk the file.

1383

1384 - `class StaticFileChunkingStrategyObject`

1385

1386 - `static: StaticFileChunkingStrategy`

1387

1388 - `chunk_overlap_tokens: Integer`

1389

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

1391

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

1393

1394 - `max_chunk_size_tokens: Integer`

1395

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

1397

1398 - `type: :static`

1399

1400 Always `static`.

1401

1402 - `:static`

1403

1404 - `class OtherFileChunkingStrategyObject`

1405

1406 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.

1407

1408 - `type: :other`

1409

1410 Always `other`.

1411

1412 - `:other`

1277 1413

1278### Example1414### Example

1279 1415

1306 "attributes": {1442 "attributes": {

1307 "foo": "string"1443 "foo": "string"

1308 },1444 },

1309 "chunking_strategy": {}1445 "chunking_strategy": {

1446 "static": {

1447 "chunk_overlap_tokens": 0,

1448 "max_chunk_size_tokens": 100

1449 },

1450 "type": "static"

1451 }

1310 }1452 }

1311 ],1453 ],

1312 "first_id": "file-abc123",1454 "first_id": "file-abc123",

1322 1464

1323**post** `/vector_stores/{vector_store_id}/files`1465**post** `/vector_stores/{vector_store_id}/files`

1324 1466

1325Create vector store file1467Create 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).

1326 1468

1327### Parameters1469### Parameters

1328 1470

1346 1488

1347 - `UnionMember2 = bool`1489 - `UnionMember2 = bool`

1348 1490

1349- `chunking_strategy: untyped`1491- `chunking_strategy: FileChunkingStrategyParam`

1492

1493 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.

1494

1495 - `class AutoFileChunkingStrategyParam`

1496

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

1498

1499 - `type: :auto`

1500

1501 Always `auto`.

1502

1503 - `:auto`

1504

1505 - `class StaticFileChunkingStrategyObjectParam`

1506

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

1508

1509 - `static: StaticFileChunkingStrategy`

1510

1511 - `chunk_overlap_tokens: Integer`

1512

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

1514

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

1516

1517 - `max_chunk_size_tokens: Integer`

1518

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

1520

1521 - `type: :static`

1522

1523 Always `static`.

1524

1525 - `:static`

1350 1526

1351### Returns1527### Returns

1352 1528

1420 1596

1421 - `UnionMember2 = bool`1597 - `UnionMember2 = bool`

1422 1598

1423 - `chunking_strategy: untyped`1599 - `chunking_strategy: FileChunkingStrategy`

1600

1601 The strategy used to chunk the file.

1602

1603 - `class StaticFileChunkingStrategyObject`

1604

1605 - `static: StaticFileChunkingStrategy`

1606

1607 - `chunk_overlap_tokens: Integer`

1608

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

1610

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

1612

1613 - `max_chunk_size_tokens: Integer`

1614

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

1616

1617 - `type: :static`

1618

1619 Always `static`.

1620

1621 - `:static`

1622

1623 - `class OtherFileChunkingStrategyObject`

1624

1625 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.

1626

1627 - `type: :other`

1628

1629 Always `other`.

1630

1631 - `:other`

1424 1632

1425### Example1633### Example

1426 1634

1451 "attributes": {1659 "attributes": {

1452 "foo": "string"1660 "foo": "string"

1453 },1661 },

1454 "chunking_strategy": {}1662 "chunking_strategy": {

1663 "static": {

1664 "chunk_overlap_tokens": 0,

1665 "max_chunk_size_tokens": 100

1666 },

1667 "type": "static"

1668 }

1455}1669}

1456```1670```

1457 1671

1461 1675

1462**post** `/vector_stores/{vector_store_id}/files/{file_id}`1676**post** `/vector_stores/{vector_store_id}/files/{file_id}`

1463 1677

1464Update vector store file attributes1678Update attributes on a vector store file.

1465 1679

1466### Parameters1680### Parameters

1467 1681

1555 1769

1556 - `UnionMember2 = bool`1770 - `UnionMember2 = bool`

1557 1771

1558 - `chunking_strategy: untyped`1772 - `chunking_strategy: FileChunkingStrategy`

1773

1774 The strategy used to chunk the file.

1775

1776 - `class StaticFileChunkingStrategyObject`

1777

1778 - `static: StaticFileChunkingStrategy`

1779

1780 - `chunk_overlap_tokens: Integer`

1781

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

1783

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

1785

1786 - `max_chunk_size_tokens: Integer`

1787

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

1789

1790 - `type: :static`

1791

1792 Always `static`.

1793

1794 - `:static`

1795

1796 - `class OtherFileChunkingStrategyObject`

1797

1798 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.

1799

1800 - `type: :other`

1801

1802 Always `other`.

1803

1804 - `:other`

1559 1805

1560### Example1806### Example

1561 1807

1590 "attributes": {1836 "attributes": {

1591 "foo": "string"1837 "foo": "string"

1592 },1838 },

1593 "chunking_strategy": {}1839 "chunking_strategy": {

1840 "static": {

1841 "chunk_overlap_tokens": 0,

1842 "max_chunk_size_tokens": 100

1843 },

1844 "type": "static"

1845 }

1594}1846}

1595```1847```

1596 1848

1600 1852

1601**get** `/vector_stores/{vector_store_id}/files/{file_id}`1853**get** `/vector_stores/{vector_store_id}/files/{file_id}`

1602 1854

1603Retrieve vector store file1855Retrieves a vector store file.

1604 1856

1605### Parameters1857### Parameters

1606 1858

1680 1932

1681 - `UnionMember2 = bool`1933 - `UnionMember2 = bool`

1682 1934

1683 - `chunking_strategy: untyped`1935 - `chunking_strategy: FileChunkingStrategy`

1936

1937 The strategy used to chunk the file.

1938

1939 - `class StaticFileChunkingStrategyObject`

1940

1941 - `static: StaticFileChunkingStrategy`

1942

1943 - `chunk_overlap_tokens: Integer`

1944

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

1946

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

1948

1949 - `max_chunk_size_tokens: Integer`

1950

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

1952

1953 - `type: :static`

1954

1955 Always `static`.

1956

1957 - `:static`

1958

1959 - `class OtherFileChunkingStrategyObject`

1960

1961 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.

1962

1963 - `type: :other`

1964

1965 Always `other`.

1966

1967 - `:other`

1684 1968

1685### Example1969### Example

1686 1970

1711 "attributes": {1995 "attributes": {

1712 "foo": "string"1996 "foo": "string"

1713 },1997 },

1714 "chunking_strategy": {}1998 "chunking_strategy": {

1999 "static": {

2000 "chunk_overlap_tokens": 0,

2001 "max_chunk_size_tokens": 100

2002 },

2003 "type": "static"

2004 }

1715}2005}

1716```2006```

1717 2007

1721 2011

1722**delete** `/vector_stores/{vector_store_id}/files/{file_id}`2012**delete** `/vector_stores/{vector_store_id}/files/{file_id}`

1723 2013

1724Delete vector store file2014Delete 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.

1725 2015

1726### Parameters2016### Parameters

1727 2017

1769 2059

1770**get** `/vector_stores/{vector_store_id}/files/{file_id}/content`2060**get** `/vector_stores/{vector_store_id}/files/{file_id}/content`

1771 2061

1772Retrieve vector store file content2062Retrieve the parsed contents of a vector store file.

1773 2063

1774### Parameters2064### Parameters

1775 2065

1891 2181

1892 - `UnionMember2 = bool`2182 - `UnionMember2 = bool`

1893 2183

1894 - `chunking_strategy: untyped`2184 - `chunking_strategy: FileChunkingStrategy`

2185

2186 The strategy used to chunk the file.

2187

2188 - `class StaticFileChunkingStrategyObject`

2189

2190 - `static: StaticFileChunkingStrategy`

2191

2192 - `chunk_overlap_tokens: Integer`

2193

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

2195

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

2197

2198 - `max_chunk_size_tokens: Integer`

2199

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

2201

2202 - `type: :static`

2203

2204 Always `static`.

2205

2206 - `:static`

2207

2208 - `class OtherFileChunkingStrategyObject`

2209

2210 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.

2211

2212 - `type: :other`

2213

2214 Always `other`.

2215

2216 - `:other`

1895 2217

1896### Vector Store File Deleted2218### Vector Store File Deleted

1897 2219

1925 2247

1926**post** `/vector_stores/{vector_store_id}/file_batches`2248**post** `/vector_stores/{vector_store_id}/file_batches`

1927 2249

1928Create vector store file batch2250Create a vector store file batch.

1929 2251

1930### Parameters2252### Parameters

1931 2253

1945 2267

1946 - `UnionMember2 = bool`2268 - `UnionMember2 = bool`

1947 2269

1948- `chunking_strategy: untyped`2270- `chunking_strategy: FileChunkingStrategyParam`

2271

2272 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.

2273

2274 - `class AutoFileChunkingStrategyParam`

2275

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

2277

2278 - `type: :auto`

2279

2280 Always `auto`.

2281

2282 - `:auto`

2283

2284 - `class StaticFileChunkingStrategyObjectParam`

2285

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

2287

2288 - `static: StaticFileChunkingStrategy`

2289

2290 - `chunk_overlap_tokens: Integer`

2291

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

2293

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

2295

2296 - `max_chunk_size_tokens: Integer`

2297

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

2299

2300 - `type: :static`

2301

2302 Always `static`.

2303

2304 - `:static`

1949 2305

1950- `file_ids: Array[String]`2306- `file_ids: Array[String]`

1951 2307

1973 2329

1974 - `UnionMember2 = bool`2330 - `UnionMember2 = bool`

1975 2331

1976 - `chunking_strategy: untyped`2332 - `chunking_strategy: FileChunkingStrategyParam`

2333

2334 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.

1977 2335

1978### Returns2336### Returns

1979 2337

2070 2428

2071**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}`2429**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}`

2072 2430

2073Retrieve vector store file batch2431Retrieves a vector store file batch.

2074 2432

2075### Parameters2433### Parameters

2076 2434

2173 2531

2174**post** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/cancel`2532**post** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/cancel`

2175 2533

2176Cancel vector store file batch2534Cancel a vector store file batch. This attempts to cancel the processing of files in this batch as soon as possible.

2177 2535

2178### Parameters2536### Parameters

2179 2537

2276 2634

2277**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/files`2635**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/files`

2278 2636

2279List vector store files in a batch2637Returns a list of vector store files in a batch.

2280 2638

2281### Parameters2639### Parameters

2282 2640

2388 2746

2389 - `UnionMember2 = bool`2747 - `UnionMember2 = bool`

2390 2748

2391 - `chunking_strategy: untyped`2749 - `chunking_strategy: FileChunkingStrategy`

2750

2751 The strategy used to chunk the file.

2752

2753 - `class StaticFileChunkingStrategyObject`

2754

2755 - `static: StaticFileChunkingStrategy`

2756

2757 - `chunk_overlap_tokens: Integer`

2758

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

2760

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

2762

2763 - `max_chunk_size_tokens: Integer`

2764

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

2766

2767 - `type: :static`

2768

2769 Always `static`.

2770

2771 - `:static`

2772

2773 - `class OtherFileChunkingStrategyObject`

2774

2775 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.

2776

2777 - `type: :other`

2778

2779 Always `other`.

2780

2781 - `:other`

2392 2782

2393### Example2783### Example

2394 2784

2421 "attributes": {2811 "attributes": {

2422 "foo": "string"2812 "foo": "string"

2423 },2813 },

2424 "chunking_strategy": {}2814 "chunking_strategy": {

2815 "static": {

2816 "chunk_overlap_tokens": 0,

2817 "max_chunk_size_tokens": 100

2818 },

2819 "type": "static"

2820 }

2425 }2821 }

2426 ],2822 ],

2427 "first_id": "file-abc123",2823 "first_id": "file-abc123",

ruby/resources/vector_stores/index.md 2026-07-10 23:02 UTC to 2026-07-12 06:58 UTC

Vector Stores

List vector stores

Parameters

Returns

Example

Response

Create vector store

Parameters

Returns

Example

Response

Retrieve vector store

Parameters

Returns

Example

Response

Modify vector store

Parameters

Returns

Example

Response

Delete vector store

Parameters

Returns

Example

Response

Search vector store

Parameters

Returns

Example

Response

Domain Types

Auto File Chunking Strategy Param

File Chunking Strategy

File Chunking Strategy Param

Other File Chunking Strategy Object

Static File Chunking Strategy

Static File Chunking Strategy Object

Static File Chunking Strategy Object Param

Vector Store

Vector Store Deleted

Vector Store Search Response

Files

List vector store files

Parameters

Returns

Example

Response

Create vector store file

Parameters

Returns

Example

Response

Update vector store file attributes

Parameters

Returns

Example

Response

Retrieve vector store file

Parameters

Returns

Example

Response

Delete vector store file

Parameters

Returns

Example

Response

Retrieve vector store file content

Parameters

Returns

Example

Response

Domain Types

Vector Store File

Vector Store File Deleted

File Content Response

File Batches

Create vector store file batch