Vector Stores

List vector stores

VectorStoreListPage vectorStores().list(VectorStoreListParamsparams = VectorStoreListParams.none(), RequestOptionsrequestOptions = RequestOptions.none())

get /vector_stores

Returns a list of vector stores.

Parameters

VectorStoreListParams params
- Optional<String> after
  
  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.
- Optional<String> before
  
  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.
- Optional<Long> limit
  
  A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
- Optional<Order> order
  
  Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
  - ASC("asc")
  - DESC("desc")

Returns

class VectorStore:

A vector store is a collection of processed files can be used by the file_search tool.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store was created.
- FileCounts fileCounts
  - long cancelled
    
    The number of files that were cancelled.
  - long completed
    
    The number of files that have been successfully processed.
  - long failed
    
    The number of files that have failed to process.
  - long inProgress
    
    The number of files that are currently being processed.
  - long total
    
    The total number of files.
- Optional<Long> lastActiveAt
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- Optional<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.
- String name
  
  The name of the vector store.
- JsonValue; object_ "vector_store"constant
  
  The object type, which is always vector_store.
  - VECTOR_STORE("vector_store")
- Status status
  
  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("expired")
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
- long usageBytes
  
  The total number of bytes used by the files in the vector store.
- Optional<ExpiresAfter> expiresAfter
  
  The expiration policy for a vector store.
  - JsonValue; anchor "last_active_at"constant
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - LAST_ACTIVE_AT("last_active_at")
  - long days
    
    The number of days after the anchor time that the vector store will expire.
- Optional<Long> expiresAt
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.VectorStoreListPage;
import com.openai.models.vectorstores.VectorStoreListParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        VectorStoreListPage page = client.vectorStores().list();
    }
}

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

VectorStore vectorStores().create(VectorStoreCreateParamsparams = VectorStoreCreateParams.none(), RequestOptionsrequestOptions = RequestOptions.none())

post /vector_stores

Create a vector store.

Parameters

VectorStoreCreateParams params
- Optional<FileChunkingStrategyParam> chunkingStrategy
  
  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.
- Optional<String> description
  
  A description for the vector store. Can be used to describe the vector store's purpose.
- Optional<ExpiresAfter> expiresAfter
  
  The expiration policy for a vector store.
  - JsonValue; anchor "last_active_at"constant
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - LAST_ACTIVE_AT("last_active_at")
  - long days
    
    The number of days after the anchor time that the vector store will expire.
- Optional<List<String>> fileIds
  
  A list of File IDs that the vector store should use. Useful for tools like file_search that can access files.
- Optional<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.
- Optional<String> name
  
  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.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store was created.
- FileCounts fileCounts
  - long cancelled
    
    The number of files that were cancelled.
  - long completed
    
    The number of files that have been successfully processed.
  - long failed
    
    The number of files that have failed to process.
  - long inProgress
    
    The number of files that are currently being processed.
  - long total
    
    The total number of files.
- Optional<Long> lastActiveAt
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- Optional<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.
- String name
  
  The name of the vector store.
- JsonValue; object_ "vector_store"constant
  
  The object type, which is always vector_store.
  - VECTOR_STORE("vector_store")
- Status status
  
  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("expired")
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
- long usageBytes
  
  The total number of bytes used by the files in the vector store.
- Optional<ExpiresAfter> expiresAfter
  
  The expiration policy for a vector store.
  - JsonValue; anchor "last_active_at"constant
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - LAST_ACTIVE_AT("last_active_at")
  - long days
    
    The number of days after the anchor time that the vector store will expire.
- Optional<Long> expiresAt
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.VectorStore;
import com.openai.models.vectorstores.VectorStoreCreateParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        VectorStore vectorStore = client.vectorStores().create();
    }
}

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

VectorStore vectorStores().retrieve(VectorStoreRetrieveParamsparams = VectorStoreRetrieveParams.none(), RequestOptionsrequestOptions = RequestOptions.none())

get /vector_stores/{vector_store_id}

Retrieves a vector store.

Parameters

VectorStoreRetrieveParams params
- Optional<String> vectorStoreId

Returns

class VectorStore:

A vector store is a collection of processed files can be used by the file_search tool.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store was created.
- FileCounts fileCounts
  - long cancelled
    
    The number of files that were cancelled.
  - long completed
    
    The number of files that have been successfully processed.
  - long failed
    
    The number of files that have failed to process.
  - long inProgress
    
    The number of files that are currently being processed.
  - long total
    
    The total number of files.
- Optional<Long> lastActiveAt
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- Optional<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.
- String name
  
  The name of the vector store.
- JsonValue; object_ "vector_store"constant
  
  The object type, which is always vector_store.
  - VECTOR_STORE("vector_store")
- Status status
  
  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("expired")
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
- long usageBytes
  
  The total number of bytes used by the files in the vector store.
- Optional<ExpiresAfter> expiresAfter
  
  The expiration policy for a vector store.
  - JsonValue; anchor "last_active_at"constant
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - LAST_ACTIVE_AT("last_active_at")
  - long days
    
    The number of days after the anchor time that the vector store will expire.
- Optional<Long> expiresAt
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.VectorStore;
import com.openai.models.vectorstores.VectorStoreRetrieveParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        VectorStore vectorStore = client.vectorStores().retrieve("vector_store_id");
    }
}

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

VectorStore vectorStores().update(VectorStoreUpdateParamsparams = VectorStoreUpdateParams.none(), RequestOptionsrequestOptions = RequestOptions.none())

post /vector_stores/{vector_store_id}

Modifies a vector store.

Parameters

VectorStoreUpdateParams params
- Optional<String> vectorStoreId
- Optional<ExpiresAfter> expiresAfter
  
  The expiration policy for a vector store.
  - JsonValue; anchor "last_active_at"constant
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - LAST_ACTIVE_AT("last_active_at")
  - long days
    
    The number of days after the anchor time that the vector store will expire.
- Optional<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.
- Optional<String> name
  
  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.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store was created.
- FileCounts fileCounts
  - long cancelled
    
    The number of files that were cancelled.
  - long completed
    
    The number of files that have been successfully processed.
  - long failed
    
    The number of files that have failed to process.
  - long inProgress
    
    The number of files that are currently being processed.
  - long total
    
    The total number of files.
- Optional<Long> lastActiveAt
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- Optional<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.
- String name
  
  The name of the vector store.
- JsonValue; object_ "vector_store"constant
  
  The object type, which is always vector_store.
  - VECTOR_STORE("vector_store")
- Status status
  
  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("expired")
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
- long usageBytes
  
  The total number of bytes used by the files in the vector store.
- Optional<ExpiresAfter> expiresAfter
  
  The expiration policy for a vector store.
  - JsonValue; anchor "last_active_at"constant
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - LAST_ACTIVE_AT("last_active_at")
  - long days
    
    The number of days after the anchor time that the vector store will expire.
- Optional<Long> expiresAt
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.VectorStore;
import com.openai.models.vectorstores.VectorStoreUpdateParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        VectorStore vectorStore = client.vectorStores().update("vector_store_id");
    }
}

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

VectorStoreDeleted vectorStores().delete(VectorStoreDeleteParamsparams = VectorStoreDeleteParams.none(), RequestOptionsrequestOptions = RequestOptions.none())

delete /vector_stores/{vector_store_id}

Delete a vector store.

Parameters

VectorStoreDeleteParams params
- Optional<String> vectorStoreId

Returns

class VectorStoreDeleted:
- String id
- boolean deleted
- JsonValue; object_ "vector_store.deleted"constant
  - VECTOR_STORE_DELETED("vector_store.deleted")

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.VectorStoreDeleteParams;
import com.openai.models.vectorstores.VectorStoreDeleted;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        VectorStoreDeleted vectorStoreDeleted = client.vectorStores().delete("vector_store_id");
    }
}

Response

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

Search vector store

VectorStoreSearchPage vectorStores().search(VectorStoreSearchParamsparams, RequestOptionsrequestOptions = RequestOptions.none())

post /vector_stores/{vector_store_id}/search

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

Parameters

VectorStoreSearchParams params
- Optional<String> vectorStoreId
- Query query
  
  A query string for a search
  - String
  - List<String>
- Optional<Filters> filters
  
  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.
    - String key
      
      The key to compare against the value.
    - Type type
      
      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("eq")
      - NE("ne")
      - GT("gt")
      - GTE("gte")
      - LT("lt")
      - LTE("lte")
      - IN("in")
      - NIN("nin")
    - Value value
      
      The value to compare against the attribute key; supports string, number, or boolean types.
      - String
      - double
      - boolean
      - List<ComparisonFilterValueItem>
        
        String
        
        double
  - class CompoundFilter:
    
    Combine multiple filters using and or or.
    - List<Filter> filters
      
      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.
      - JsonValue
    - Type type
      
      Type of operation: and or or.
      - AND("and")
      - OR("or")
- Optional<Long> maxNumResults
  
  The maximum number of results to return. This number should be between 1 and 50 inclusive.
- Optional<RankingOptions> rankingOptions
  
  Ranking options for search.
  - Optional<Ranker> ranker
    
    Enable re-ranking; set to none to disable, which can help reduce latency.
    - NONE("none")
    - AUTO("auto")
    - DEFAULT_2024_11_15("default-2024-11-15")
  - Optional<Double> scoreThreshold
- Optional<Boolean> rewriteQuery
  
  Whether to rewrite the natural language query for vector search.

Returns

class VectorStoreSearchResponse:
- Optional<Attributes> attributes
  
  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
  - double
  - boolean
- List<Content> content
  
  Content chunks from the file.
  - String text
    
    The text content returned from search.
  - Type type
    
    The type of content.
    - TEXT("text")
- String fileId
  
  The ID of the vector store file.
- String filename
  
  The name of the vector store file.
- double score
  
  The similarity score for the result.

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.VectorStoreSearchPage;
import com.openai.models.vectorstores.VectorStoreSearchParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        VectorStoreSearchParams params = VectorStoreSearchParams.builder()
            .vectorStoreId("vs_abc123")
            .query("string")
            .build();
        VectorStoreSearchPage page = client.vectorStores().search(params);
    }
}

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.
- JsonValue; type "auto"constant
  
  Always auto.
  - AUTO("auto")

File Chunking Strategy

class FileChunkingStrategy: A class that can be one of several variants.union

The strategy used to chunk the file.
- class StaticFileChunkingStrategyObject:
  - StaticFileChunkingStrategy static_
    - long chunkOverlapTokens
      
      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.
    - long maxChunkSizeTokens
      
      The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
  - JsonValue; type "static"constant
    
    Always static.
    - 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.
  - JsonValue; type "other"constant
    
    Always other.
    - OTHER("other")

File Chunking Strategy Param

class FileChunkingStrategyParam: A class that can be one of several variants.union

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.
  - JsonValue; type "auto"constant
    
    Always auto.
    - AUTO("auto")
- class StaticFileChunkingStrategyObjectParam:
  
  Customize your own chunking strategy by setting chunk size and chunk overlap.
  - StaticFileChunkingStrategy static_
    - long chunkOverlapTokens
      
      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.
    - long maxChunkSizeTokens
      
      The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
  - JsonValue; type "static"constant
    
    Always static.
    - 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.
- JsonValue; type "other"constant
  
  Always other.
  - OTHER("other")

Static File Chunking Strategy

class StaticFileChunkingStrategy:
- long chunkOverlapTokens
  
  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.
- long maxChunkSizeTokens
  
  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:
- StaticFileChunkingStrategy static_
  - long chunkOverlapTokens
    
    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.
  - long maxChunkSizeTokens
    
    The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
- JsonValue; type "static"constant
  
  Always static.
  - STATIC("static")

Static File Chunking Strategy Object Param

class StaticFileChunkingStrategyObjectParam:

Customize your own chunking strategy by setting chunk size and chunk overlap.
- StaticFileChunkingStrategy static_
  - long chunkOverlapTokens
    
    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.
  - long maxChunkSizeTokens
    
    The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
- JsonValue; type "static"constant
  
  Always static.
  - STATIC("static")

Vector Store

class VectorStore:

A vector store is a collection of processed files can be used by the file_search tool.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store was created.
- FileCounts fileCounts
  - long cancelled
    
    The number of files that were cancelled.
  - long completed
    
    The number of files that have been successfully processed.
  - long failed
    
    The number of files that have failed to process.
  - long inProgress
    
    The number of files that are currently being processed.
  - long total
    
    The total number of files.
- Optional<Long> lastActiveAt
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- Optional<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.
- String name
  
  The name of the vector store.
- JsonValue; object_ "vector_store"constant
  
  The object type, which is always vector_store.
  - VECTOR_STORE("vector_store")
- Status status
  
  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("expired")
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
- long usageBytes
  
  The total number of bytes used by the files in the vector store.
- Optional<ExpiresAfter> expiresAfter
  
  The expiration policy for a vector store.
  - JsonValue; anchor "last_active_at"constant
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - LAST_ACTIVE_AT("last_active_at")
  - long days
    
    The number of days after the anchor time that the vector store will expire.
- Optional<Long> expiresAt
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Vector Store Deleted

class VectorStoreDeleted:
- String id
- boolean deleted
- JsonValue; object_ "vector_store.deleted"constant
  - VECTOR_STORE_DELETED("vector_store.deleted")

Files

List vector store files

FileListPage vectorStores().files().list(FileListParamsparams = FileListParams.none(), RequestOptionsrequestOptions = RequestOptions.none())

get /vector_stores/{vector_store_id}/files

Returns a list of vector store files.

Parameters

FileListParams params
- Optional<String> vectorStoreId
- Optional<String> after
  
  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.
- Optional<String> before
  
  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.
- Optional<Filter> filter
  
  Filter by file status. One of in_progress, completed, failed, cancelled.
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
  - FAILED("failed")
  - CANCELLED("cancelled")
- Optional<Long> limit
  
  A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
- Optional<Order> order
  
  Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
  - ASC("asc")
  - DESC("desc")

Returns

class VectorStoreFile:

A list of files attached to a vector store.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- Optional<LastError> lastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code code
    
    One of server_error, unsupported_file, or invalid_file.
    - SERVER_ERROR("server_error")
    - UNSUPPORTED_FILE("unsupported_file")
    - INVALID_FILE("invalid_file")
  - String message
    
    A human-readable description of the error.
- JsonValue; object_ "vector_store.file"constant
  
  The object type, which is always vector_store.file.
  - VECTOR_STORE_FILE("vector_store.file")
- Status status
  
  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("in_progress")
  - COMPLETED("completed")
  - CANCELLED("cancelled")
  - FAILED("failed")
- long usageBytes
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- String vectorStoreId
  
  The ID of the vector store that the File is attached to.
- Optional<Attributes> attributes
  
  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
  - double
  - boolean
- Optional<FileChunkingStrategy> chunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject:
    - StaticFileChunkingStrategy static_
      - long chunkOverlapTokens
        
        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.
      - long maxChunkSizeTokens
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - JsonValue; type "static"constant
      
      Always static.
      - 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.
    - JsonValue; type "other"constant
      
      Always other.
      - OTHER("other")

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.files.FileListPage;
import com.openai.models.vectorstores.files.FileListParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        FileListPage page = client.vectorStores().files().list("vector_store_id");
    }
}

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

VectorStoreFile vectorStores().files().create(FileCreateParamsparams, RequestOptionsrequestOptions = RequestOptions.none())

post /vector_stores/{vector_store_id}/files

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

Parameters

FileCreateParams params
- Optional<String> vectorStoreId
- String fileId
  
  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.
- Optional<Attributes> attributes
  
  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
  - double
  - boolean
- Optional<FileChunkingStrategyParam> chunkingStrategy
  
  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 VectorStoreFile:

A list of files attached to a vector store.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- Optional<LastError> lastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code code
    
    One of server_error, unsupported_file, or invalid_file.
    - SERVER_ERROR("server_error")
    - UNSUPPORTED_FILE("unsupported_file")
    - INVALID_FILE("invalid_file")
  - String message
    
    A human-readable description of the error.
- JsonValue; object_ "vector_store.file"constant
  
  The object type, which is always vector_store.file.
  - VECTOR_STORE_FILE("vector_store.file")
- Status status
  
  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("in_progress")
  - COMPLETED("completed")
  - CANCELLED("cancelled")
  - FAILED("failed")
- long usageBytes
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- String vectorStoreId
  
  The ID of the vector store that the File is attached to.
- Optional<Attributes> attributes
  
  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
  - double
  - boolean
- Optional<FileChunkingStrategy> chunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject:
    - StaticFileChunkingStrategy static_
      - long chunkOverlapTokens
        
        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.
      - long maxChunkSizeTokens
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - JsonValue; type "static"constant
      
      Always static.
      - 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.
    - JsonValue; type "other"constant
      
      Always other.
      - OTHER("other")

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.files.FileCreateParams;
import com.openai.models.vectorstores.files.VectorStoreFile;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        FileCreateParams params = FileCreateParams.builder()
            .vectorStoreId("vs_abc123")
            .fileId("file_id")
            .build();
        VectorStoreFile vectorStoreFile = client.vectorStores().files().create(params);
    }
}

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

VectorStoreFile vectorStores().files().update(FileUpdateParamsparams, RequestOptionsrequestOptions = RequestOptions.none())

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

Update attributes on a vector store file.

Parameters

FileUpdateParams params
- String vectorStoreId
- Optional<String> fileId
- Optional<Attributes> attributes
  
  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
  - double
  - boolean

Returns

class VectorStoreFile:

A list of files attached to a vector store.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- Optional<LastError> lastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code code
    
    One of server_error, unsupported_file, or invalid_file.
    - SERVER_ERROR("server_error")
    - UNSUPPORTED_FILE("unsupported_file")
    - INVALID_FILE("invalid_file")
  - String message
    
    A human-readable description of the error.
- JsonValue; object_ "vector_store.file"constant
  
  The object type, which is always vector_store.file.
  - VECTOR_STORE_FILE("vector_store.file")
- Status status
  
  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("in_progress")
  - COMPLETED("completed")
  - CANCELLED("cancelled")
  - FAILED("failed")
- long usageBytes
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- String vectorStoreId
  
  The ID of the vector store that the File is attached to.
- Optional<Attributes> attributes
  
  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
  - double
  - boolean
- Optional<FileChunkingStrategy> chunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject:
    - StaticFileChunkingStrategy static_
      - long chunkOverlapTokens
        
        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.
      - long maxChunkSizeTokens
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - JsonValue; type "static"constant
      
      Always static.
      - 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.
    - JsonValue; type "other"constant
      
      Always other.
      - OTHER("other")

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.vectorstores.files.FileUpdateParams;
import com.openai.models.vectorstores.files.VectorStoreFile;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        FileUpdateParams params = FileUpdateParams.builder()
            .vectorStoreId("vs_abc123")
            .fileId("file-abc123")
            .attributes(FileUpdateParams.Attributes.builder()
                .putAdditionalProperty("foo", JsonValue.from("string"))
                .build())
            .build();
        VectorStoreFile vectorStoreFile = client.vectorStores().files().update(params);
    }
}

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

VectorStoreFile vectorStores().files().retrieve(FileRetrieveParamsparams, RequestOptionsrequestOptions = RequestOptions.none())

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

Retrieves a vector store file.

Parameters

FileRetrieveParams params
- String vectorStoreId
- Optional<String> fileId

Returns

class VectorStoreFile:

A list of files attached to a vector store.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- Optional<LastError> lastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code code
    
    One of server_error, unsupported_file, or invalid_file.
    - SERVER_ERROR("server_error")
    - UNSUPPORTED_FILE("unsupported_file")
    - INVALID_FILE("invalid_file")
  - String message
    
    A human-readable description of the error.
- JsonValue; object_ "vector_store.file"constant
  
  The object type, which is always vector_store.file.
  - VECTOR_STORE_FILE("vector_store.file")
- Status status
  
  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("in_progress")
  - COMPLETED("completed")
  - CANCELLED("cancelled")
  - FAILED("failed")
- long usageBytes
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- String vectorStoreId
  
  The ID of the vector store that the File is attached to.
- Optional<Attributes> attributes
  
  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
  - double
  - boolean
- Optional<FileChunkingStrategy> chunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject:
    - StaticFileChunkingStrategy static_
      - long chunkOverlapTokens
        
        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.
      - long maxChunkSizeTokens
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - JsonValue; type "static"constant
      
      Always static.
      - 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.
    - JsonValue; type "other"constant
      
      Always other.
      - OTHER("other")

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.files.FileRetrieveParams;
import com.openai.models.vectorstores.files.VectorStoreFile;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        FileRetrieveParams params = FileRetrieveParams.builder()
            .vectorStoreId("vs_abc123")
            .fileId("file-abc123")
            .build();
        VectorStoreFile vectorStoreFile = client.vectorStores().files().retrieve(params);
    }
}

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

VectorStoreFileDeleted vectorStores().files().delete(FileDeleteParamsparams, RequestOptionsrequestOptions = RequestOptions.none())

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

FileDeleteParams params
- String vectorStoreId
- Optional<String> fileId

Returns

class VectorStoreFileDeleted:
- String id
- boolean deleted
- JsonValue; object_ "vector_store.file.deleted"constant
  - VECTOR_STORE_FILE_DELETED("vector_store.file.deleted")

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.files.FileDeleteParams;
import com.openai.models.vectorstores.files.VectorStoreFileDeleted;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        FileDeleteParams params = FileDeleteParams.builder()
            .vectorStoreId("vector_store_id")
            .fileId("file_id")
            .build();
        VectorStoreFileDeleted vectorStoreFileDeleted = client.vectorStores().files().delete(params);
    }
}

Response

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

Retrieve vector store file content

FileContentPage vectorStores().files().content(FileContentParamsparams, RequestOptionsrequestOptions = RequestOptions.none())

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

Retrieve the parsed contents of a vector store file.

Parameters

FileContentParams params
- String vectorStoreId
- Optional<String> fileId

Returns

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

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.files.FileContentPage;
import com.openai.models.vectorstores.files.FileContentParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        FileContentParams params = FileContentParams.builder()
            .vectorStoreId("vs_abc123")
            .fileId("file-abc123")
            .build();
        FileContentPage page = client.vectorStores().files().content(params);
    }
}

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.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- Optional<LastError> lastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code code
    
    One of server_error, unsupported_file, or invalid_file.
    - SERVER_ERROR("server_error")
    - UNSUPPORTED_FILE("unsupported_file")
    - INVALID_FILE("invalid_file")
  - String message
    
    A human-readable description of the error.
- JsonValue; object_ "vector_store.file"constant
  
  The object type, which is always vector_store.file.
  - VECTOR_STORE_FILE("vector_store.file")
- Status status
  
  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("in_progress")
  - COMPLETED("completed")
  - CANCELLED("cancelled")
  - FAILED("failed")
- long usageBytes
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- String vectorStoreId
  
  The ID of the vector store that the File is attached to.
- Optional<Attributes> attributes
  
  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
  - double
  - boolean
- Optional<FileChunkingStrategy> chunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject:
    - StaticFileChunkingStrategy static_
      - long chunkOverlapTokens
        
        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.
      - long maxChunkSizeTokens
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - JsonValue; type "static"constant
      
      Always static.
      - 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.
    - JsonValue; type "other"constant
      
      Always other.
      - OTHER("other")

Vector Store File Deleted

class VectorStoreFileDeleted:
- String id
- boolean deleted
- JsonValue; object_ "vector_store.file.deleted"constant
  - VECTOR_STORE_FILE_DELETED("vector_store.file.deleted")

File Batches

Create vector store file batch

VectorStoreFileBatch vectorStores().fileBatches().create(FileBatchCreateParamsparams = FileBatchCreateParams.none(), RequestOptionsrequestOptions = RequestOptions.none())

post /vector_stores/{vector_store_id}/file_batches

Create a vector store file batch.

Parameters

FileBatchCreateParams params
- Optional<String> vectorStoreId
- Optional<Attributes> attributes
  
  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
  - double
  - boolean
- Optional<FileChunkingStrategyParam> chunkingStrategy
  
  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.
- Optional<List<String>> fileIds
  
  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.
- Optional<List<File>> files
  
  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.
  - String fileId
    
    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.
  - Optional<Attributes> attributes
    
    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
    - double
    - boolean
  - Optional<FileChunkingStrategyParam> chunkingStrategy
    
    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.
      - JsonValue; type "auto"constant
        
        Always auto.
        
        AUTO("auto")
    - class StaticFileChunkingStrategyObjectParam:
      
      Customize your own chunking strategy by setting chunk size and chunk overlap.
      - StaticFileChunkingStrategy static_
        
        long chunkOverlapTokens
        
        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.
        
        long maxChunkSizeTokens
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
      - JsonValue; type "static"constant
        
        Always static.
        
        STATIC("static")

Returns

class VectorStoreFileBatch:

A batch of files attached to a vector store.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- FileCounts fileCounts
  - long cancelled
    
    The number of files that where cancelled.
  - long completed
    
    The number of files that have been processed.
  - long failed
    
    The number of files that have failed to process.
  - long inProgress
    
    The number of files that are currently being processed.
  - long total
    
    The total number of files.
- JsonValue; object_ "vector_store.files_batch"constant
  
  The object type, which is always vector_store.file_batch.
  - VECTOR_STORE_FILES_BATCH("vector_store.files_batch")
- Status status
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
  - CANCELLED("cancelled")
  - FAILED("failed")
- String vectorStoreId
  
  The ID of the vector store that the File is attached to.

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.filebatches.FileBatchCreateParams;
import com.openai.models.vectorstores.filebatches.VectorStoreFileBatch;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        VectorStoreFileBatch vectorStoreFileBatch = client.vectorStores().fileBatches().create("vs_abc123");
    }
}

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

VectorStoreFileBatch vectorStores().fileBatches().retrieve(FileBatchRetrieveParamsparams, RequestOptionsrequestOptions = RequestOptions.none())

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

Retrieves a vector store file batch.

Parameters

FileBatchRetrieveParams params
- String vectorStoreId
- Optional<String> batchId

Returns

class VectorStoreFileBatch:

A batch of files attached to a vector store.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- FileCounts fileCounts
  - long cancelled
    
    The number of files that where cancelled.
  - long completed
    
    The number of files that have been processed.
  - long failed
    
    The number of files that have failed to process.
  - long inProgress
    
    The number of files that are currently being processed.
  - long total
    
    The total number of files.
- JsonValue; object_ "vector_store.files_batch"constant
  
  The object type, which is always vector_store.file_batch.
  - VECTOR_STORE_FILES_BATCH("vector_store.files_batch")
- Status status
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
  - CANCELLED("cancelled")
  - FAILED("failed")
- String vectorStoreId
  
  The ID of the vector store that the File is attached to.

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.filebatches.FileBatchRetrieveParams;
import com.openai.models.vectorstores.filebatches.VectorStoreFileBatch;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        FileBatchRetrieveParams params = FileBatchRetrieveParams.builder()
            .vectorStoreId("vs_abc123")
            .batchId("vsfb_abc123")
            .build();
        VectorStoreFileBatch vectorStoreFileBatch = client.vectorStores().fileBatches().retrieve(params);
    }
}

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

VectorStoreFileBatch vectorStores().fileBatches().cancel(FileBatchCancelParamsparams, RequestOptionsrequestOptions = RequestOptions.none())

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

FileBatchCancelParams params
- String vectorStoreId
- Optional<String> batchId

Returns

class VectorStoreFileBatch:

A batch of files attached to a vector store.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- FileCounts fileCounts
  - long cancelled
    
    The number of files that where cancelled.
  - long completed
    
    The number of files that have been processed.
  - long failed
    
    The number of files that have failed to process.
  - long inProgress
    
    The number of files that are currently being processed.
  - long total
    
    The total number of files.
- JsonValue; object_ "vector_store.files_batch"constant
  
  The object type, which is always vector_store.file_batch.
  - VECTOR_STORE_FILES_BATCH("vector_store.files_batch")
- Status status
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
  - CANCELLED("cancelled")
  - FAILED("failed")
- String vectorStoreId
  
  The ID of the vector store that the File is attached to.

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.filebatches.FileBatchCancelParams;
import com.openai.models.vectorstores.filebatches.VectorStoreFileBatch;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        FileBatchCancelParams params = FileBatchCancelParams.builder()
            .vectorStoreId("vector_store_id")
            .batchId("batch_id")
            .build();
        VectorStoreFileBatch vectorStoreFileBatch = client.vectorStores().fileBatches().cancel(params);
    }
}

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

FileBatchListFilesPage vectorStores().fileBatches().listFiles(FileBatchListFilesParamsparams, RequestOptionsrequestOptions = RequestOptions.none())

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

Returns a list of vector store files in a batch.

Parameters

FileBatchListFilesParams params
- String vectorStoreId
- Optional<String> batchId
- Optional<String> after
  
  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.
- Optional<String> before
  
  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.
- Optional<Filter> filter
  
  Filter by file status. One of in_progress, completed, failed, cancelled.
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
  - FAILED("failed")
  - CANCELLED("cancelled")
- Optional<Long> limit
  
  A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
- Optional<Order> order
  
  Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
  - ASC("asc")
  - DESC("desc")

Returns

class VectorStoreFile:

A list of files attached to a vector store.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- Optional<LastError> lastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code code
    
    One of server_error, unsupported_file, or invalid_file.
    - SERVER_ERROR("server_error")
    - UNSUPPORTED_FILE("unsupported_file")
    - INVALID_FILE("invalid_file")
  - String message
    
    A human-readable description of the error.
- JsonValue; object_ "vector_store.file"constant
  
  The object type, which is always vector_store.file.
  - VECTOR_STORE_FILE("vector_store.file")
- Status status
  
  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("in_progress")
  - COMPLETED("completed")
  - CANCELLED("cancelled")
  - FAILED("failed")
- long usageBytes
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- String vectorStoreId
  
  The ID of the vector store that the File is attached to.
- Optional<Attributes> attributes
  
  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
  - double
  - boolean
- Optional<FileChunkingStrategy> chunkingStrategy
  
  The strategy used to chunk the file.
  - class StaticFileChunkingStrategyObject:
    - StaticFileChunkingStrategy static_
      - long chunkOverlapTokens
        
        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.
      - long maxChunkSizeTokens
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - JsonValue; type "static"constant
      
      Always static.
      - 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.
    - JsonValue; type "other"constant
      
      Always other.
      - OTHER("other")

Example

package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.vectorstores.filebatches.FileBatchListFilesPage;
import com.openai.models.vectorstores.filebatches.FileBatchListFilesParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        FileBatchListFilesParams params = FileBatchListFilesParams.builder()
            .vectorStoreId("vector_store_id")
            .batchId("batch_id")
            .build();
        FileBatchListFilesPage page = client.vectorStores().fileBatches().listFiles(params);
    }
}

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.
- String id
  
  The identifier, which can be referenced in API endpoints.
- long createdAt
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- FileCounts fileCounts
  - long cancelled
    
    The number of files that where cancelled.
  - long completed
    
    The number of files that have been processed.
  - long failed
    
    The number of files that have failed to process.
  - long inProgress
    
    The number of files that are currently being processed.
  - long total
    
    The total number of files.
- JsonValue; object_ "vector_store.files_batch"constant
  
  The object type, which is always vector_store.file_batch.
  - VECTOR_STORE_FILES_BATCH("vector_store.files_batch")
- Status status
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - IN_PROGRESS("in_progress")
  - COMPLETED("completed")
  - CANCELLED("cancelled")
  - FAILED("failed")
- String vectorStoreId
  
  The ID of the vector store that the File is attached to.

java/resources/vector_stores/index.md +366 −34

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

187 187

188**post** `/vector_stores`188**post** `/vector_stores`

189 189

190Create vector store190Create a vector store.

191 191

192### Parameters192### Parameters

193 193

194- `VectorStoreCreateParams params`194- `VectorStoreCreateParams params`

195 195

196 - `Optional<JsonValue> chunkingStrategy`196 - `Optional<FileChunkingStrategyParam> chunkingStrategy`

197

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

197 199

198 - `Optional<String> description`200 - `Optional<String> description`

199 201

377 379

378**get** `/vector_stores/{vector_store_id}`380**get** `/vector_stores/{vector_store_id}`

379 381

380Retrieve vector store382Retrieves a vector store.

381 383

382### Parameters384### Parameters

383 385

532 534

533**post** `/vector_stores/{vector_store_id}`535**post** `/vector_stores/{vector_store_id}`

534 536

535Modify vector store537Modifies a vector store.

536 538

537### Parameters539### Parameters

538 540

714 716

715**delete** `/vector_stores/{vector_store_id}`717**delete** `/vector_stores/{vector_store_id}`

716 718

717Delete vector store719Delete a vector store.

718 720

719### Parameters721### Parameters

720 722

771 773

772**post** `/vector_stores/{vector_store_id}/search`774**post** `/vector_stores/{vector_store_id}/search`

773 775

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

775 777

776### Parameters778### Parameters

777 779

838 840

839 - `boolean`841 - `boolean`

840 842

841 - `List<JsonValue>`843 - `List<ComparisonFilterValueItem>`

844

845 - `String`

846

847 - `double`

842 848

843 - `class CompoundFilter:`849 - `class CompoundFilter:`

844 850

1000 1006

1001### File Chunking Strategy1007### File Chunking Strategy

1002 1008

1003- `class FileChunkingStrategy:`1009- `class FileChunkingStrategy: A class that can be one of several variants.union`

1010

1011 The strategy used to chunk the file.

1012

1013 - `class StaticFileChunkingStrategyObject:`

1014

1015 - `StaticFileChunkingStrategy static_`

1016

1017 - `long chunkOverlapTokens`

1018

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

1020

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

1022

1023 - `long maxChunkSizeTokens`

1024

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

1026

1027 - `JsonValue; type "static"constant`

1028

1029 Always `static`.

1030

1031 - `STATIC("static")`

1032

1033 - `class OtherFileChunkingStrategyObject:`

1034

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

1036

1037 - `JsonValue; type "other"constant`

1038

1039 Always `other`.

1040

1041 - `OTHER("other")`

1004 1042

1005### File Chunking Strategy Param1043### File Chunking Strategy Param

1006 1044

1007- `class FileChunkingStrategyParam:`1045- `class FileChunkingStrategyParam: A class that can be one of several variants.union`

1046

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

1048

1049 - `class AutoFileChunkingStrategyParam:`

1050

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

1052

1053 - `JsonValue; type "auto"constant`

1054

1055 Always `auto`.

1056

1057 - `AUTO("auto")`

1058

1059 - `class StaticFileChunkingStrategyObjectParam:`

1060

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

1062

1063 - `StaticFileChunkingStrategy static_`

1064

1065 - `long chunkOverlapTokens`

1066

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

1068

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

1070

1071 - `long maxChunkSizeTokens`

1072

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

1074

1075 - `JsonValue; type "static"constant`

1076

1077 Always `static`.

1078

1079 - `STATIC("static")`

1008 1080

1009### Other File Chunking Strategy Object1081### Other File Chunking Strategy Object

1010 1082

1189 1261

1190**get** `/vector_stores/{vector_store_id}/files`1262**get** `/vector_stores/{vector_store_id}/files`

1191 1263

1192List vector store files1264Returns a list of vector store files.

1193 1265

1194### Parameters1266### Parameters

1195 1267

1301 1373

1302 - `boolean`1374 - `boolean`

1303 1375

1304 - `Optional<JsonValue> chunkingStrategy`1376 - `Optional<FileChunkingStrategy> chunkingStrategy`

1377

1378 The strategy used to chunk the file.

1379

1380 - `class StaticFileChunkingStrategyObject:`

1381

1382 - `StaticFileChunkingStrategy static_`

1383

1384 - `long chunkOverlapTokens`

1385

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

1387

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

1389

1390 - `long maxChunkSizeTokens`

1391

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

1393

1394 - `JsonValue; type "static"constant`

1395

1396 Always `static`.

1397

1398 - `STATIC("static")`

1399

1400 - `class OtherFileChunkingStrategyObject:`

1401

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

1403

1404 - `JsonValue; type "other"constant`

1405

1406 Always `other`.

1407

1408 - `OTHER("other")`

1305 1409

1306### Example1410### Example

1307 1411

1343 "attributes": {1447 "attributes": {

1344 "foo": "string"1448 "foo": "string"

1345 },1449 },

1346 "chunking_strategy": {}1450 "chunking_strategy": {

1451 "static": {

1452 "chunk_overlap_tokens": 0,

1453 "max_chunk_size_tokens": 100

1454 },

1455 "type": "static"

1456 }

1347 }1457 }

1348 ],1458 ],

1349 "first_id": "file-abc123",1459 "first_id": "file-abc123",

1359 1469

1360**post** `/vector_stores/{vector_store_id}/files`1470**post** `/vector_stores/{vector_store_id}/files`

1361 1471

1362Create vector store file1472Create 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).

1363 1473

1364### Parameters1474### Parameters

1365 1475

1385 1495

1386 - `boolean`1496 - `boolean`

1387 1497

1388 - `Optional<JsonValue> chunkingStrategy`1498 - `Optional<FileChunkingStrategyParam> chunkingStrategy`

1499

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

1389 1501

1390### Returns1502### Returns

1391 1503

1459 1571

1460 - `boolean`1572 - `boolean`

1461 1573

1462 - `Optional<JsonValue> chunkingStrategy`1574 - `Optional<FileChunkingStrategy> chunkingStrategy`

1575

1576 The strategy used to chunk the file.

1577

1578 - `class StaticFileChunkingStrategyObject:`

1579

1580 - `StaticFileChunkingStrategy static_`

1581

1582 - `long chunkOverlapTokens`

1583

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

1585

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

1587

1588 - `long maxChunkSizeTokens`

1589

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

1591

1592 - `JsonValue; type "static"constant`

1593

1594 Always `static`.

1595

1596 - `STATIC("static")`

1597

1598 - `class OtherFileChunkingStrategyObject:`

1599

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

1601

1602 - `JsonValue; type "other"constant`

1603

1604 Always `other`.

1605

1606 - `OTHER("other")`

1463 1607

1464### Example1608### Example

1465 1609

1503 "attributes": {1647 "attributes": {

1504 "foo": "string"1648 "foo": "string"

1505 },1649 },

1506 "chunking_strategy": {}1650 "chunking_strategy": {

1651 "static": {

1652 "chunk_overlap_tokens": 0,

1653 "max_chunk_size_tokens": 100

1654 },

1655 "type": "static"

1656 }

1507}1657}

1508```1658```

1509 1659

1513 1663

1514**post** `/vector_stores/{vector_store_id}/files/{file_id}`1664**post** `/vector_stores/{vector_store_id}/files/{file_id}`

1515 1665

1516Update vector store file attributes1666Update attributes on a vector store file.

1517 1667

1518### Parameters1668### Parameters

1519 1669

1609 1759

1610 - `boolean`1760 - `boolean`

1611 1761

1612 - `Optional<JsonValue> chunkingStrategy`1762 - `Optional<FileChunkingStrategy> chunkingStrategy`

1763

1764 The strategy used to chunk the file.

1765

1766 - `class StaticFileChunkingStrategyObject:`

1767

1768 - `StaticFileChunkingStrategy static_`

1769

1770 - `long chunkOverlapTokens`

1771

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

1773

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

1775

1776 - `long maxChunkSizeTokens`

1777

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

1779

1780 - `JsonValue; type "static"constant`

1781

1782 Always `static`.

1783

1784 - `STATIC("static")`

1785

1786 - `class OtherFileChunkingStrategyObject:`

1787

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

1789

1790 - `JsonValue; type "other"constant`

1791

1792 Always `other`.

1793

1794 - `OTHER("other")`

1613 1795

1614### Example1796### Example

1615 1797

1657 "attributes": {1839 "attributes": {

1658 "foo": "string"1840 "foo": "string"

1659 },1841 },

1660 "chunking_strategy": {}1842 "chunking_strategy": {

1843 "static": {

1844 "chunk_overlap_tokens": 0,

1845 "max_chunk_size_tokens": 100

1846 },

1847 "type": "static"

1848 }

1661}1849}

1662```1850```

1663 1851

1667 1855

1668**get** `/vector_stores/{vector_store_id}/files/{file_id}`1856**get** `/vector_stores/{vector_store_id}/files/{file_id}`

1669 1857

1670Retrieve vector store file1858Retrieves a vector store file.

1671 1859

1672### Parameters1860### Parameters

1673 1861

1749 1937

1750 - `boolean`1938 - `boolean`

1751 1939

1752 - `Optional<JsonValue> chunkingStrategy`1940 - `Optional<FileChunkingStrategy> chunkingStrategy`

1941

1942 The strategy used to chunk the file.

1943

1944 - `class StaticFileChunkingStrategyObject:`

1945

1946 - `StaticFileChunkingStrategy static_`

1947

1948 - `long chunkOverlapTokens`

1949

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

1951

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

1953

1954 - `long maxChunkSizeTokens`

1955

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

1957

1958 - `JsonValue; type "static"constant`

1959

1960 Always `static`.

1961

1962 - `STATIC("static")`

1963

1964 - `class OtherFileChunkingStrategyObject:`

1965

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

1967

1968 - `JsonValue; type "other"constant`

1969

1970 Always `other`.

1971

1972 - `OTHER("other")`

1753 1973

1754### Example1974### Example

1755 1975

1793 "attributes": {2013 "attributes": {

1794 "foo": "string"2014 "foo": "string"

1795 },2015 },

1796 "chunking_strategy": {}2016 "chunking_strategy": {

2017 "static": {

2018 "chunk_overlap_tokens": 0,

2019 "max_chunk_size_tokens": 100

2020 },

2021 "type": "static"

2022 }

1797}2023}

1798```2024```

1799 2025

1803 2029

1804**delete** `/vector_stores/{vector_store_id}/files/{file_id}`2030**delete** `/vector_stores/{vector_store_id}/files/{file_id}`

1805 2031

1806Delete vector store file2032Delete 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.

1807 2033

1808### Parameters2034### Parameters

1809 2035

1866 2092

1867**get** `/vector_stores/{vector_store_id}/files/{file_id}/content`2093**get** `/vector_stores/{vector_store_id}/files/{file_id}/content`

1868 2094

1869Retrieve vector store file content2095Retrieve the parsed contents of a vector store file.

1870 2096

1871### Parameters2097### Parameters

1872 2098

2003 2229

2004 - `boolean`2230 - `boolean`

2005 2231

2006 - `Optional<JsonValue> chunkingStrategy`2232 - `Optional<FileChunkingStrategy> chunkingStrategy`

2233

2234 The strategy used to chunk the file.

2235

2236 - `class StaticFileChunkingStrategyObject:`

2237

2238 - `StaticFileChunkingStrategy static_`

2239

2240 - `long chunkOverlapTokens`

2241

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

2243

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

2245

2246 - `long maxChunkSizeTokens`

2247

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

2249

2250 - `JsonValue; type "static"constant`

2251

2252 Always `static`.

2253

2254 - `STATIC("static")`

2255

2256 - `class OtherFileChunkingStrategyObject:`

2257

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

2259

2260 - `JsonValue; type "other"constant`

2261

2262 Always `other`.

2263

2264 - `OTHER("other")`

2007 2265

2008### Vector Store File Deleted2266### Vector Store File Deleted

2009 2267

2025 2283

2026**post** `/vector_stores/{vector_store_id}/file_batches`2284**post** `/vector_stores/{vector_store_id}/file_batches`

2027 2285

2028Create vector store file batch2286Create a vector store file batch.

2029 2287

2030### Parameters2288### Parameters

2031 2289

2047 2305

2048 - `boolean`2306 - `boolean`

2049 2307

2050 - `Optional<JsonValue> chunkingStrategy`2308 - `Optional<FileChunkingStrategyParam> chunkingStrategy`

2309

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

2051 2311

2052 - `Optional<List<String>> fileIds`2312 - `Optional<List<String>> fileIds`

2053 2313

2075 2335

2076 - `boolean`2336 - `boolean`

2077 2337

2078 - `Optional<JsonValue> chunkingStrategy`2338 - `Optional<FileChunkingStrategyParam> chunkingStrategy`

2339

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

2341

2342 - `class AutoFileChunkingStrategyParam:`

2343

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

2345

2346 - `JsonValue; type "auto"constant`

2347

2348 Always `auto`.

2349

2350 - `AUTO("auto")`

2351

2352 - `class StaticFileChunkingStrategyObjectParam:`

2353

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

2355

2356 - `StaticFileChunkingStrategy static_`

2357

2358 - `long chunkOverlapTokens`

2359

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

2361

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

2363

2364 - `long maxChunkSizeTokens`

2365

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

2367

2368 - `JsonValue; type "static"constant`

2369

2370 Always `static`.

2371

2372 - `STATIC("static")`

2079 2373

2080### Returns2374### Returns

2081 2375

2181 2475

2182**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}`2476**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}`

2183 2477

2184Retrieve vector store file batch2478Retrieves a vector store file batch.

2185 2479

2186### Parameters2480### Parameters

2187 2481

2299 2593

2300**post** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/cancel`2594**post** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/cancel`

2301 2595

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

2303 2597

2304### Parameters2598### Parameters

2305 2599

2417 2711

2418**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/files`2712**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/files`

2419 2713

2420List vector store files in a batch2714Returns a list of vector store files in a batch.

2421 2715

2422### Parameters2716### Parameters

2423 2717

2531 2825

2532 - `boolean`2826 - `boolean`

2533 2827

2534 - `Optional<JsonValue> chunkingStrategy`2828 - `Optional<FileChunkingStrategy> chunkingStrategy`

2829

2830 The strategy used to chunk the file.

2831

2832 - `class StaticFileChunkingStrategyObject:`

2833

2834 - `StaticFileChunkingStrategy static_`

2835

2836 - `long chunkOverlapTokens`

2837

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

2839

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

2841

2842 - `long maxChunkSizeTokens`

2843

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

2845

2846 - `JsonValue; type "static"constant`

2847

2848 Always `static`.

2849

2850 - `STATIC("static")`

2851

2852 - `class OtherFileChunkingStrategyObject:`

2853

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

2855

2856 - `JsonValue; type "other"constant`

2857

2858 Always `other`.

2859

2860 - `OTHER("other")`

2535 2861

2536### Example2862### Example

2537 2863

2577 "attributes": {2903 "attributes": {

2578 "foo": "string"2904 "foo": "string"

2579 },2905 },

2580 "chunking_strategy": {}2906 "chunking_strategy": {

2907 "static": {

2908 "chunk_overlap_tokens": 0,

2909 "max_chunk_size_tokens": 100

2910 },

2911 "type": "static"

2912 }

2581 }2913 }

2582 ],2914 ],

2583 "first_id": "file-abc123",2915 "first_id": "file-abc123",

java/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

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 Batches

Create vector store file batch

Parameters

Returns