Vector Stores

List vector stores

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

get /vector_stores

List 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 vector store

Parameters

VectorStoreCreateParams params
- Optional<JsonValue> chunkingStrategy
- 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}

Retrieve 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}

Modify 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 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 vector store

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<JsonValue>
  - 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:

File Chunking Strategy Param

class FileChunkingStrategyParam:

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

List 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<JsonValue> chunkingStrategy

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": {}
    }
  ],
  "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 vector store file

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<JsonValue> chunkingStrategy

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<JsonValue> chunkingStrategy

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": {}
}

Update vector store file attributes

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

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

Update vector store file attributes

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<JsonValue> chunkingStrategy

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": {}
}

Retrieve vector store file

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

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

Retrieve 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<JsonValue> chunkingStrategy

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": {}
}

Delete vector store file

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

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

Delete vector store file

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 vector store file content

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<JsonValue> chunkingStrategy

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 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<JsonValue> chunkingStrategy
- 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<JsonValue> chunkingStrategy

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}

Retrieve 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 vector store file batch

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

List 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<JsonValue> chunkingStrategy

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": {}
    }
  ],
  "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 +2648 −0 created

1# Vector Stores

3## List vector stores

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

7**get** `/vector_stores`

9List vector stores

11### Parameters

13- `VectorStoreListParams params`

15 - `Optional<String> after`

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

19 - `Optional<String> before`

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

23 - `Optional<Long> limit`

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

27 - `Optional<Order> order`

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

31 - `ASC("asc")`

33 - `DESC("desc")`

35### Returns

37- `class VectorStore:`

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

41 - `String id`

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

45 - `long createdAt`

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

49 - `FileCounts fileCounts`

51 - `long cancelled`

53 The number of files that were cancelled.

55 - `long completed`

57 The number of files that have been successfully processed.

59 - `long failed`

61 The number of files that have failed to process.

63 - `long inProgress`

65 The number of files that are currently being processed.

67 - `long total`

69 The total number of files.

71 - `Optional<Long> lastActiveAt`

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

75 - `Optional<Metadata> metadata`

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

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

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

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

82 with a maximum length of 512 characters.

84 - `String name`

86 The name of the vector store.

88 - `JsonValue; object_ "vector_store"constant`

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

92 - `VECTOR_STORE("vector_store")`

94 - `Status status`

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

98 - `EXPIRED("expired")`

100 - `IN_PROGRESS("in_progress")`

101

102 - `COMPLETED("completed")`

103

104 - `long usageBytes`

105

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

107

108 - `Optional<ExpiresAfter> expiresAfter`

109

110 The expiration policy for a vector store.

111

112 - `JsonValue; anchor "last_active_at"constant`

113

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

115

116 - `LAST_ACTIVE_AT("last_active_at")`

117

118 - `long days`

119

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

121

122 - `Optional<Long> expiresAt`

123

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

125

126### Example

127

128```java

129package com.openai.example;

130

131import com.openai.client.OpenAIClient;

132import com.openai.client.okhttp.OpenAIOkHttpClient;

133import com.openai.models.vectorstores.VectorStoreListPage;

134import com.openai.models.vectorstores.VectorStoreListParams;

135

136public final class Main {

137 private Main() {}

138

139 public static void main(String[] args) {

140 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

141

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

143 }

144}

145```

146

147#### Response

148

149```json

150{

151 "data": [

152 {

153 "id": "id",

154 "created_at": 0,

155 "file_counts": {

156 "cancelled": 0,

157 "completed": 0,

158 "failed": 0,

159 "in_progress": 0,

160 "total": 0

161 },

162 "last_active_at": 0,

163 "metadata": {

164 "foo": "string"

165 },

166 "name": "name",

167 "object": "vector_store",

168 "status": "expired",

169 "usage_bytes": 0,

170 "expires_after": {

171 "anchor": "last_active_at",

172 "days": 1

173 },

174 "expires_at": 0

175 }

176 ],

177 "first_id": "vs_abc123",

178 "has_more": false,

179 "last_id": "vs_abc456",

180 "object": "list"

181}

182```

183

184## Create vector store

185

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

187

188**post** `/vector_stores`

189

190Create vector store

191

192### Parameters

193

194- `VectorStoreCreateParams params`

195

196 - `Optional<JsonValue> chunkingStrategy`

197

198 - `Optional<String> description`

199

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

201

202 - `Optional<ExpiresAfter> expiresAfter`

203

204 The expiration policy for a vector store.

205

206 - `JsonValue; anchor "last_active_at"constant`

207

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

209

210 - `LAST_ACTIVE_AT("last_active_at")`

211

212 - `long days`

213

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

215

216 - `Optional<List<String>> fileIds`

217

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

219

220 - `Optional<Metadata> metadata`

221

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

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

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

225

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

227 with a maximum length of 512 characters.

228

229 - `Optional<String> name`

230

231 The name of the vector store.

232

233### Returns

234

235- `class VectorStore:`

236

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

238

239 - `String id`

240

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

242

243 - `long createdAt`

244

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

246

247 - `FileCounts fileCounts`

248

249 - `long cancelled`

250

251 The number of files that were cancelled.

252

253 - `long completed`

254

255 The number of files that have been successfully processed.

256

257 - `long failed`

258

259 The number of files that have failed to process.

260

261 - `long inProgress`

262

263 The number of files that are currently being processed.

264

265 - `long total`

266

267 The total number of files.

268

269 - `Optional<Long> lastActiveAt`

270

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

272

273 - `Optional<Metadata> metadata`

274

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

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

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

278

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

280 with a maximum length of 512 characters.

281

282 - `String name`

283

284 The name of the vector store.

285

286 - `JsonValue; object_ "vector_store"constant`

287

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

289

290 - `VECTOR_STORE("vector_store")`

291

292 - `Status status`

293

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

295

296 - `EXPIRED("expired")`

297

298 - `IN_PROGRESS("in_progress")`

299

300 - `COMPLETED("completed")`

301

302 - `long usageBytes`

303

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

305

306 - `Optional<ExpiresAfter> expiresAfter`

307

308 The expiration policy for a vector store.

309

310 - `JsonValue; anchor "last_active_at"constant`

311

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

313

314 - `LAST_ACTIVE_AT("last_active_at")`

315

316 - `long days`

317

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

319

320 - `Optional<Long> expiresAt`

321

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

323

324### Example

325

326```java

327package com.openai.example;

328

329import com.openai.client.OpenAIClient;

330import com.openai.client.okhttp.OpenAIOkHttpClient;

331import com.openai.models.vectorstores.VectorStore;

332import com.openai.models.vectorstores.VectorStoreCreateParams;

333

334public final class Main {

335 private Main() {}

336

337 public static void main(String[] args) {

338 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

339

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

341 }

342}

343```

344

345#### Response

346

347```json

348{

349 "id": "id",

350 "created_at": 0,

351 "file_counts": {

352 "cancelled": 0,

353 "completed": 0,

354 "failed": 0,

355 "in_progress": 0,

356 "total": 0

357 },

358 "last_active_at": 0,

359 "metadata": {

360 "foo": "string"

361 },

362 "name": "name",

363 "object": "vector_store",

364 "status": "expired",

365 "usage_bytes": 0,

366 "expires_after": {

367 "anchor": "last_active_at",

368 "days": 1

369 },

370 "expires_at": 0

371}

372```

373

374## Retrieve vector store

375

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

377

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

379

380Retrieve vector store

381

382### Parameters

383

384- `VectorStoreRetrieveParams params`

385

386 - `Optional<String> vectorStoreId`

387

388### Returns

389

390- `class VectorStore:`

391

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

393

394 - `String id`

395

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

397

398 - `long createdAt`

399

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

401

402 - `FileCounts fileCounts`

403

404 - `long cancelled`

405

406 The number of files that were cancelled.

407

408 - `long completed`

409

410 The number of files that have been successfully processed.

411

412 - `long failed`

413

414 The number of files that have failed to process.

415

416 - `long inProgress`

417

418 The number of files that are currently being processed.

419

420 - `long total`

421

422 The total number of files.

423

424 - `Optional<Long> lastActiveAt`

425

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

427

428 - `Optional<Metadata> metadata`

429

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

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

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

433

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

435 with a maximum length of 512 characters.

436

437 - `String name`

438

439 The name of the vector store.

440

441 - `JsonValue; object_ "vector_store"constant`

442

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

444

445 - `VECTOR_STORE("vector_store")`

446

447 - `Status status`

448

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

450

451 - `EXPIRED("expired")`

452

453 - `IN_PROGRESS("in_progress")`

454

455 - `COMPLETED("completed")`

456

457 - `long usageBytes`

458

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

460

461 - `Optional<ExpiresAfter> expiresAfter`

462

463 The expiration policy for a vector store.

464

465 - `JsonValue; anchor "last_active_at"constant`

466

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

468

469 - `LAST_ACTIVE_AT("last_active_at")`

470

471 - `long days`

472

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

474

475 - `Optional<Long> expiresAt`

476

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

478

479### Example

480

481```java

482package com.openai.example;

483

484import com.openai.client.OpenAIClient;

485import com.openai.client.okhttp.OpenAIOkHttpClient;

486import com.openai.models.vectorstores.VectorStore;

487import com.openai.models.vectorstores.VectorStoreRetrieveParams;

488

489public final class Main {

490 private Main() {}

491

492 public static void main(String[] args) {

493 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

494

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

496 }

497}

498```

499

500#### Response

501

502```json

503{

504 "id": "id",

505 "created_at": 0,

506 "file_counts": {

507 "cancelled": 0,

508 "completed": 0,

509 "failed": 0,

510 "in_progress": 0,

511 "total": 0

512 },

513 "last_active_at": 0,

514 "metadata": {

515 "foo": "string"

516 },

517 "name": "name",

518 "object": "vector_store",

519 "status": "expired",

520 "usage_bytes": 0,

521 "expires_after": {

522 "anchor": "last_active_at",

523 "days": 1

524 },

525 "expires_at": 0

526}

527```

528

529## Modify vector store

530

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

532

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

534

535Modify vector store

536

537### Parameters

538

539- `VectorStoreUpdateParams params`

540

541 - `Optional<String> vectorStoreId`

542

543 - `Optional<ExpiresAfter> expiresAfter`

544

545 The expiration policy for a vector store.

546

547 - `JsonValue; anchor "last_active_at"constant`

548

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

550

551 - `LAST_ACTIVE_AT("last_active_at")`

552

553 - `long days`

554

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

556

557 - `Optional<Metadata> metadata`

558

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

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

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

562

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

564 with a maximum length of 512 characters.

565

566 - `Optional<String> name`

567

568 The name of the vector store.

569

570### Returns

571

572- `class VectorStore:`

573

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

575

576 - `String id`

577

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

579

580 - `long createdAt`

581

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

583

584 - `FileCounts fileCounts`

585

586 - `long cancelled`

587

588 The number of files that were cancelled.

589

590 - `long completed`

591

592 The number of files that have been successfully processed.

593

594 - `long failed`

595

596 The number of files that have failed to process.

597

598 - `long inProgress`

599

600 The number of files that are currently being processed.

601

602 - `long total`

603

604 The total number of files.

605

606 - `Optional<Long> lastActiveAt`

607

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

609

610 - `Optional<Metadata> metadata`

611

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

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

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

615

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

617 with a maximum length of 512 characters.

618

619 - `String name`

620

621 The name of the vector store.

622

623 - `JsonValue; object_ "vector_store"constant`

624

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

626

627 - `VECTOR_STORE("vector_store")`

628

629 - `Status status`

630

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

632

633 - `EXPIRED("expired")`

634

635 - `IN_PROGRESS("in_progress")`

636

637 - `COMPLETED("completed")`

638

639 - `long usageBytes`

640

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

642

643 - `Optional<ExpiresAfter> expiresAfter`

644

645 The expiration policy for a vector store.

646

647 - `JsonValue; anchor "last_active_at"constant`

648

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

650

651 - `LAST_ACTIVE_AT("last_active_at")`

652

653 - `long days`

654

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

656

657 - `Optional<Long> expiresAt`

658

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

660

661### Example

662

663```java

664package com.openai.example;

665

666import com.openai.client.OpenAIClient;

667import com.openai.client.okhttp.OpenAIOkHttpClient;

668import com.openai.models.vectorstores.VectorStore;

669import com.openai.models.vectorstores.VectorStoreUpdateParams;

670

671public final class Main {

672 private Main() {}

673

674 public static void main(String[] args) {

675 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

676

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

678 }

679}

680```

681

682#### Response

683

684```json

685{

686 "id": "id",

687 "created_at": 0,

688 "file_counts": {

689 "cancelled": 0,

690 "completed": 0,

691 "failed": 0,

692 "in_progress": 0,

693 "total": 0

694 },

695 "last_active_at": 0,

696 "metadata": {

697 "foo": "string"

698 },

699 "name": "name",

700 "object": "vector_store",

701 "status": "expired",

702 "usage_bytes": 0,

703 "expires_after": {

704 "anchor": "last_active_at",

705 "days": 1

706 },

707 "expires_at": 0

708}

709```

710

711## Delete vector store

712

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

714

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

716

717Delete vector store

718

719### Parameters

720

721- `VectorStoreDeleteParams params`

722

723 - `Optional<String> vectorStoreId`

724

725### Returns

726

727- `class VectorStoreDeleted:`

728

729 - `String id`

730

731 - `boolean deleted`

732

733 - `JsonValue; object_ "vector_store.deleted"constant`

734

735 - `VECTOR_STORE_DELETED("vector_store.deleted")`

736

737### Example

738

739```java

740package com.openai.example;

741

742import com.openai.client.OpenAIClient;

743import com.openai.client.okhttp.OpenAIOkHttpClient;

744import com.openai.models.vectorstores.VectorStoreDeleteParams;

745import com.openai.models.vectorstores.VectorStoreDeleted;

746

747public final class Main {

748 private Main() {}

749

750 public static void main(String[] args) {

751 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

752

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

754 }

755}

756```

757

758#### Response

759

760```json

761{

762 "id": "id",

763 "deleted": true,

764 "object": "vector_store.deleted"

765}

766```

767

768## Search vector store

769

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

771

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

773

774Search vector store

775

776### Parameters

777

778- `VectorStoreSearchParams params`

779

780 - `Optional<String> vectorStoreId`

781

782 - `Query query`

783

784 A query string for a search

785

786 - `String`

787

788 - `List<String>`

789

790 - `Optional<Filters> filters`

791

792 A filter to apply based on file attributes.

793

794 - `class ComparisonFilter:`

795

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

797

798 - `String key`

799

800 The key to compare against the value.

801

802 - `Type type`

803

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

805

806 - `eq`: equals

807 - `ne`: not equal

808 - `gt`: greater than

809 - `gte`: greater than or equal

810 - `lt`: less than

811 - `lte`: less than or equal

812 - `in`: in

813 - `nin`: not in

814

815 - `EQ("eq")`

816

817 - `NE("ne")`

818

819 - `GT("gt")`

820

821 - `GTE("gte")`

822

823 - `LT("lt")`

824

825 - `LTE("lte")`

826

827 - `IN("in")`

828

829 - `NIN("nin")`

830

831 - `Value value`

832

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

834

835 - `String`

836

837 - `double`

838

839 - `boolean`

840

841 - `List<JsonValue>`

842

843 - `class CompoundFilter:`

844

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

846

847 - `List<Filter> filters`

848

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

850

851 - `class ComparisonFilter:`

852

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

854

855 - `JsonValue`

856

857 - `Type type`

858

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

860

861 - `AND("and")`

862

863 - `OR("or")`

864

865 - `Optional<Long> maxNumResults`

866

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

868

869 - `Optional<RankingOptions> rankingOptions`

870

871 Ranking options for search.

872

873 - `Optional<Ranker> ranker`

874

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

876

877 - `NONE("none")`

878

879 - `AUTO("auto")`

880

881 - `DEFAULT_2024_11_15("default-2024-11-15")`

882

883 - `Optional<Double> scoreThreshold`

884

885 - `Optional<Boolean> rewriteQuery`

886

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

888

889### Returns

890

891- `class VectorStoreSearchResponse:`

892

893 - `Optional<Attributes> attributes`

894

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

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

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

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

899 length of 512 characters, booleans, or numbers.

900

901 - `String`

902

903 - `double`

904

905 - `boolean`

906

907 - `List<Content> content`

908

909 Content chunks from the file.

910

911 - `String text`

912

913 The text content returned from search.

914

915 - `Type type`

916

917 The type of content.

918

919 - `TEXT("text")`

920

921 - `String fileId`

922

923 The ID of the vector store file.

924

925 - `String filename`

926

927 The name of the vector store file.

928

929 - `double score`

930

931 The similarity score for the result.

932

933### Example

934

935```java

936package com.openai.example;

937

938import com.openai.client.OpenAIClient;

939import com.openai.client.okhttp.OpenAIOkHttpClient;

940import com.openai.models.vectorstores.VectorStoreSearchPage;

941import com.openai.models.vectorstores.VectorStoreSearchParams;

942

943public final class Main {

944 private Main() {}

945

946 public static void main(String[] args) {

947 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

948

949 VectorStoreSearchParams params = VectorStoreSearchParams.builder()

950 .vectorStoreId("vs_abc123")

951 .query("string")

952 .build();

953 VectorStoreSearchPage page = client.vectorStores().search(params);

954 }

955}

956```

957

958#### Response

959

960```json

961{

962 "data": [

963 {

964 "attributes": {

965 "foo": "string"

966 },

967 "content": [

968 {

969 "text": "text",

970 "type": "text"

971 }

972 ],

973 "file_id": "file_id",

974 "filename": "filename",

975 "score": 0

976 }

977 ],

978 "has_more": true,

979 "next_page": "next_page",

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

981 "search_query": [

982 "string"

983 ]

984}

985```

986

987## Domain Types

988

989### Auto File Chunking Strategy Param

990

991- `class AutoFileChunkingStrategyParam:`

992

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

994

995 - `JsonValue; type "auto"constant`

996

997 Always `auto`.

998

999 - `AUTO("auto")`

1000

1001### File Chunking Strategy

1002

1003- `class FileChunkingStrategy:`

1004

1005### File Chunking Strategy Param

1006

1007- `class FileChunkingStrategyParam:`

1008

1009### Other File Chunking Strategy Object

1010

1011- `class OtherFileChunkingStrategyObject:`

1012

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

1014

1015 - `JsonValue; type "other"constant`

1016

1017 Always `other`.

1018

1019 - `OTHER("other")`

1020

1021### Static File Chunking Strategy

1022

1023- `class StaticFileChunkingStrategy:`

1024

1025 - `long chunkOverlapTokens`

1026

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

1028

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

1030

1031 - `long maxChunkSizeTokens`

1032

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

1034

1035### Static File Chunking Strategy Object

1036

1037- `class StaticFileChunkingStrategyObject:`

1038

1039 - `StaticFileChunkingStrategy static_`

1040

1041 - `long chunkOverlapTokens`

1042

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

1044

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

1046

1047 - `long maxChunkSizeTokens`

1048

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

1050

1051 - `JsonValue; type "static"constant`

1052

1053 Always `static`.

1054

1055 - `STATIC("static")`

1056

1057### Static File Chunking Strategy Object Param

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")`

1080

1081### Vector Store

1082

1083- `class VectorStore:`

1084

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

1086

1087 - `String id`

1088

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

1090

1091 - `long createdAt`

1092

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

1094

1095 - `FileCounts fileCounts`

1096

1097 - `long cancelled`

1098

1099 The number of files that were cancelled.

1100

1101 - `long completed`

1102

1103 The number of files that have been successfully processed.

1104

1105 - `long failed`

1106

1107 The number of files that have failed to process.

1108

1109 - `long inProgress`

1110

1111 The number of files that are currently being processed.

1112

1113 - `long total`

1114

1115 The total number of files.

1116

1117 - `Optional<Long> lastActiveAt`

1118

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

1120

1121 - `Optional<Metadata> metadata`

1122

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

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

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

1126

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

1128 with a maximum length of 512 characters.

1129

1130 - `String name`

1131

1132 The name of the vector store.

1133

1134 - `JsonValue; object_ "vector_store"constant`

1135

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

1137

1138 - `VECTOR_STORE("vector_store")`

1139

1140 - `Status status`

1141

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

1143

1144 - `EXPIRED("expired")`

1145

1146 - `IN_PROGRESS("in_progress")`

1147

1148 - `COMPLETED("completed")`

1149

1150 - `long usageBytes`

1151

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

1153

1154 - `Optional<ExpiresAfter> expiresAfter`

1155

1156 The expiration policy for a vector store.

1157

1158 - `JsonValue; anchor "last_active_at"constant`

1159

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

1161

1162 - `LAST_ACTIVE_AT("last_active_at")`

1163

1164 - `long days`

1165

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

1167

1168 - `Optional<Long> expiresAt`

1169

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

1171

1172### Vector Store Deleted

1173

1174- `class VectorStoreDeleted:`

1175

1176 - `String id`

1177

1178 - `boolean deleted`

1179

1180 - `JsonValue; object_ "vector_store.deleted"constant`

1181

1182 - `VECTOR_STORE_DELETED("vector_store.deleted")`

1183

1184# Files

1185

1186## List vector store files

1187

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

1189

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

1191

1192List vector store files

1193

1194### Parameters

1195

1196- `FileListParams params`

1197

1198 - `Optional<String> vectorStoreId`

1199

1200 - `Optional<String> after`

1201

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

1203

1204 - `Optional<String> before`

1205

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

1207

1208 - `Optional<Filter> filter`

1209

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

1211

1212 - `IN_PROGRESS("in_progress")`

1213

1214 - `COMPLETED("completed")`

1215

1216 - `FAILED("failed")`

1217

1218 - `CANCELLED("cancelled")`

1219

1220 - `Optional<Long> limit`

1221

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

1223

1224 - `Optional<Order> order`

1225

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

1227

1228 - `ASC("asc")`

1229

1230 - `DESC("desc")`

1231

1232### Returns

1233

1234- `class VectorStoreFile:`

1235

1236 A list of files attached to a vector store.

1237

1238 - `String id`

1239

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

1241

1242 - `long createdAt`

1243

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

1245

1246 - `Optional<LastError> lastError`

1247

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

1249

1250 - `Code code`

1251

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

1253

1254 - `SERVER_ERROR("server_error")`

1255

1256 - `UNSUPPORTED_FILE("unsupported_file")`

1257

1258 - `INVALID_FILE("invalid_file")`

1259

1260 - `String message`

1261

1262 A human-readable description of the error.

1263

1264 - `JsonValue; object_ "vector_store.file"constant`

1265

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

1267

1268 - `VECTOR_STORE_FILE("vector_store.file")`

1269

1270 - `Status status`

1271

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

1273

1274 - `IN_PROGRESS("in_progress")`

1275

1276 - `COMPLETED("completed")`

1277

1278 - `CANCELLED("cancelled")`

1279

1280 - `FAILED("failed")`

1281

1282 - `long usageBytes`

1283

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

1285

1286 - `String vectorStoreId`

1287

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

1289

1290 - `Optional<Attributes> attributes`

1291

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

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

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

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

1296 length of 512 characters, booleans, or numbers.

1297

1298 - `String`

1299

1300 - `double`

1301

1302 - `boolean`

1303

1304 - `Optional<JsonValue> chunkingStrategy`

1305

1306### Example

1307

1308```java

1309package com.openai.example;

1310

1311import com.openai.client.OpenAIClient;

1312import com.openai.client.okhttp.OpenAIOkHttpClient;

1313import com.openai.models.vectorstores.files.FileListPage;

1314import com.openai.models.vectorstores.files.FileListParams;

1315

1316public final class Main {

1317 private Main() {}

1318

1319 public static void main(String[] args) {

1320 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

1321

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

1323 }

1324}

1325```

1326

1327#### Response

1328

1329```json

1330{

1331 "data": [

1332 {

1333 "id": "id",

1334 "created_at": 0,

1335 "last_error": {

1336 "code": "server_error",

1337 "message": "message"

1338 },

1339 "object": "vector_store.file",

1340 "status": "in_progress",

1341 "usage_bytes": 0,

1342 "vector_store_id": "vector_store_id",

1343 "attributes": {

1344 "foo": "string"

1345 },

1346 "chunking_strategy": {}

1347 }

1348 ],

1349 "first_id": "file-abc123",

1350 "has_more": false,

1351 "last_id": "file-abc456",

1352 "object": "list"

1353}

1354```

1355

1356## Create vector store file

1357

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

1359

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

1361

1362Create vector store file

1363

1364### Parameters

1365

1366- `FileCreateParams params`

1367

1368 - `Optional<String> vectorStoreId`

1369

1370 - `String fileId`

1371

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

1373

1374 - `Optional<Attributes> attributes`

1375

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

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

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

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

1380 length of 512 characters, booleans, or numbers.

1381

1382 - `String`

1383

1384 - `double`

1385

1386 - `boolean`

1387

1388 - `Optional<JsonValue> chunkingStrategy`

1389

1390### Returns

1391

1392- `class VectorStoreFile:`

1393

1394 A list of files attached to a vector store.

1395

1396 - `String id`

1397

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

1399

1400 - `long createdAt`

1401

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

1403

1404 - `Optional<LastError> lastError`

1405

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

1407

1408 - `Code code`

1409

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

1411

1412 - `SERVER_ERROR("server_error")`

1413

1414 - `UNSUPPORTED_FILE("unsupported_file")`

1415

1416 - `INVALID_FILE("invalid_file")`

1417

1418 - `String message`

1419

1420 A human-readable description of the error.

1421

1422 - `JsonValue; object_ "vector_store.file"constant`

1423

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

1425

1426 - `VECTOR_STORE_FILE("vector_store.file")`

1427

1428 - `Status status`

1429

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

1431

1432 - `IN_PROGRESS("in_progress")`

1433

1434 - `COMPLETED("completed")`

1435

1436 - `CANCELLED("cancelled")`

1437

1438 - `FAILED("failed")`

1439

1440 - `long usageBytes`

1441

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

1443

1444 - `String vectorStoreId`

1445

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

1447

1448 - `Optional<Attributes> attributes`

1449

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

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

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

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

1454 length of 512 characters, booleans, or numbers.

1455

1456 - `String`

1457

1458 - `double`

1459

1460 - `boolean`

1461

1462 - `Optional<JsonValue> chunkingStrategy`

1463

1464### Example

1465

1466```java

1467package com.openai.example;

1468

1469import com.openai.client.OpenAIClient;

1470import com.openai.client.okhttp.OpenAIOkHttpClient;

1471import com.openai.models.vectorstores.files.FileCreateParams;

1472import com.openai.models.vectorstores.files.VectorStoreFile;

1473

1474public final class Main {

1475 private Main() {}

1476

1477 public static void main(String[] args) {

1478 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

1479

1480 FileCreateParams params = FileCreateParams.builder()

1481 .vectorStoreId("vs_abc123")

1482 .fileId("file_id")

1483 .build();

1484 VectorStoreFile vectorStoreFile = client.vectorStores().files().create(params);

1485 }

1486}

1487```

1488

1489#### Response

1490

1491```json

1492{

1493 "id": "id",

1494 "created_at": 0,

1495 "last_error": {

1496 "code": "server_error",

1497 "message": "message"

1498 },

1499 "object": "vector_store.file",

1500 "status": "in_progress",

1501 "usage_bytes": 0,

1502 "vector_store_id": "vector_store_id",

1503 "attributes": {

1504 "foo": "string"

1505 },

1506 "chunking_strategy": {}

1507}

1508```

1509

1510## Update vector store file attributes

1511

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

1513

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

1515

1516Update vector store file attributes

1517

1518### Parameters

1519

1520- `FileUpdateParams params`

1521

1522 - `String vectorStoreId`

1523

1524 - `Optional<String> fileId`

1525

1526 - `Optional<Attributes> attributes`

1527

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

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

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

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

1532 length of 512 characters, booleans, or numbers.

1533

1534 - `String`

1535

1536 - `double`

1537

1538 - `boolean`

1539

1540### Returns

1541

1542- `class VectorStoreFile:`

1543

1544 A list of files attached to a vector store.

1545

1546 - `String id`

1547

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

1549

1550 - `long createdAt`

1551

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

1553

1554 - `Optional<LastError> lastError`

1555

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

1557

1558 - `Code code`

1559

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

1561

1562 - `SERVER_ERROR("server_error")`

1563

1564 - `UNSUPPORTED_FILE("unsupported_file")`

1565

1566 - `INVALID_FILE("invalid_file")`

1567

1568 - `String message`

1569

1570 A human-readable description of the error.

1571

1572 - `JsonValue; object_ "vector_store.file"constant`

1573

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

1575

1576 - `VECTOR_STORE_FILE("vector_store.file")`

1577

1578 - `Status status`

1579

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

1581

1582 - `IN_PROGRESS("in_progress")`

1583

1584 - `COMPLETED("completed")`

1585

1586 - `CANCELLED("cancelled")`

1587

1588 - `FAILED("failed")`

1589

1590 - `long usageBytes`

1591

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

1593

1594 - `String vectorStoreId`

1595

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

1597

1598 - `Optional<Attributes> attributes`

1599

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

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

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

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

1604 length of 512 characters, booleans, or numbers.

1605

1606 - `String`

1607

1608 - `double`

1609

1610 - `boolean`

1611

1612 - `Optional<JsonValue> chunkingStrategy`

1613

1614### Example

1615

1616```java

1617package com.openai.example;

1618

1619import com.openai.client.OpenAIClient;

1620import com.openai.client.okhttp.OpenAIOkHttpClient;

1621import com.openai.core.JsonValue;

1622import com.openai.models.vectorstores.files.FileUpdateParams;

1623import com.openai.models.vectorstores.files.VectorStoreFile;

1624

1625public final class Main {

1626 private Main() {}

1627

1628 public static void main(String[] args) {

1629 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

1630

1631 FileUpdateParams params = FileUpdateParams.builder()

1632 .vectorStoreId("vs_abc123")

1633 .fileId("file-abc123")

1634 .attributes(FileUpdateParams.Attributes.builder()

1635 .putAdditionalProperty("foo", JsonValue.from("string"))

1636 .build())

1637 .build();

1638 VectorStoreFile vectorStoreFile = client.vectorStores().files().update(params);

1639 }

1640}

1641```

1642

1643#### Response

1644

1645```json

1646{

1647 "id": "id",

1648 "created_at": 0,

1649 "last_error": {

1650 "code": "server_error",

1651 "message": "message"

1652 },

1653 "object": "vector_store.file",

1654 "status": "in_progress",

1655 "usage_bytes": 0,

1656 "vector_store_id": "vector_store_id",

1657 "attributes": {

1658 "foo": "string"

1659 },

1660 "chunking_strategy": {}

1661}

1662```

1663

1664## Retrieve vector store file

1665

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

1667

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

1669

1670Retrieve vector store file

1671

1672### Parameters

1673

1674- `FileRetrieveParams params`

1675

1676 - `String vectorStoreId`

1677

1678 - `Optional<String> fileId`

1679

1680### Returns

1681

1682- `class VectorStoreFile:`

1683

1684 A list of files attached to a vector store.

1685

1686 - `String id`

1687

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

1689

1690 - `long createdAt`

1691

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

1693

1694 - `Optional<LastError> lastError`

1695

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

1697

1698 - `Code code`

1699

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

1701

1702 - `SERVER_ERROR("server_error")`

1703

1704 - `UNSUPPORTED_FILE("unsupported_file")`

1705

1706 - `INVALID_FILE("invalid_file")`

1707

1708 - `String message`

1709

1710 A human-readable description of the error.

1711

1712 - `JsonValue; object_ "vector_store.file"constant`

1713

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

1715

1716 - `VECTOR_STORE_FILE("vector_store.file")`

1717

1718 - `Status status`

1719

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

1721

1722 - `IN_PROGRESS("in_progress")`

1723

1724 - `COMPLETED("completed")`

1725

1726 - `CANCELLED("cancelled")`

1727

1728 - `FAILED("failed")`

1729

1730 - `long usageBytes`

1731

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

1733

1734 - `String vectorStoreId`

1735

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

1737

1738 - `Optional<Attributes> attributes`

1739

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

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

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

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

1744 length of 512 characters, booleans, or numbers.

1745

1746 - `String`

1747

1748 - `double`

1749

1750 - `boolean`

1751

1752 - `Optional<JsonValue> chunkingStrategy`

1753

1754### Example

1755

1756```java

1757package com.openai.example;

1758

1759import com.openai.client.OpenAIClient;

1760import com.openai.client.okhttp.OpenAIOkHttpClient;

1761import com.openai.models.vectorstores.files.FileRetrieveParams;

1762import com.openai.models.vectorstores.files.VectorStoreFile;

1763

1764public final class Main {

1765 private Main() {}

1766

1767 public static void main(String[] args) {

1768 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

1769

1770 FileRetrieveParams params = FileRetrieveParams.builder()

1771 .vectorStoreId("vs_abc123")

1772 .fileId("file-abc123")

1773 .build();

1774 VectorStoreFile vectorStoreFile = client.vectorStores().files().retrieve(params);

1775 }

1776}

1777```

1778

1779#### Response

1780

1781```json

1782{

1783 "id": "id",

1784 "created_at": 0,

1785 "last_error": {

1786 "code": "server_error",

1787 "message": "message"

1788 },

1789 "object": "vector_store.file",

1790 "status": "in_progress",

1791 "usage_bytes": 0,

1792 "vector_store_id": "vector_store_id",

1793 "attributes": {

1794 "foo": "string"

1795 },

1796 "chunking_strategy": {}

1797}

1798```

1799

1800## Delete vector store file

1801

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

1803

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

1805

1806Delete vector store file

1807

1808### Parameters

1809

1810- `FileDeleteParams params`

1811

1812 - `String vectorStoreId`

1813

1814 - `Optional<String> fileId`

1815

1816### Returns

1817

1818- `class VectorStoreFileDeleted:`

1819

1820 - `String id`

1821

1822 - `boolean deleted`

1823

1824 - `JsonValue; object_ "vector_store.file.deleted"constant`

1825

1826 - `VECTOR_STORE_FILE_DELETED("vector_store.file.deleted")`

1827

1828### Example

1829

1830```java

1831package com.openai.example;

1832

1833import com.openai.client.OpenAIClient;

1834import com.openai.client.okhttp.OpenAIOkHttpClient;

1835import com.openai.models.vectorstores.files.FileDeleteParams;

1836import com.openai.models.vectorstores.files.VectorStoreFileDeleted;

1837

1838public final class Main {

1839 private Main() {}

1840

1841 public static void main(String[] args) {

1842 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

1843

1844 FileDeleteParams params = FileDeleteParams.builder()

1845 .vectorStoreId("vector_store_id")

1846 .fileId("file_id")

1847 .build();

1848 VectorStoreFileDeleted vectorStoreFileDeleted = client.vectorStores().files().delete(params);

1849 }

1850}

1851```

1852

1853#### Response

1854

1855```json

1856{

1857 "id": "id",

1858 "deleted": true,

1859 "object": "vector_store.file.deleted"

1860}

1861```

1862

1863## Retrieve vector store file content

1864

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

1866

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

1868

1869Retrieve vector store file content

1870

1871### Parameters

1872

1873- `FileContentParams params`

1874

1875 - `String vectorStoreId`

1876

1877 - `Optional<String> fileId`

1878

1879### Returns

1880

1881- `class FileContentResponse:`

1882

1883 - `Optional<String> text`

1884

1885 The text content

1886

1887 - `Optional<String> type`

1888

1889 The content type (currently only `"text"`)

1890

1891### Example

1892

1893```java

1894package com.openai.example;

1895

1896import com.openai.client.OpenAIClient;

1897import com.openai.client.okhttp.OpenAIOkHttpClient;

1898import com.openai.models.vectorstores.files.FileContentPage;

1899import com.openai.models.vectorstores.files.FileContentParams;

1900

1901public final class Main {

1902 private Main() {}

1903

1904 public static void main(String[] args) {

1905 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

1906

1907 FileContentParams params = FileContentParams.builder()

1908 .vectorStoreId("vs_abc123")

1909 .fileId("file-abc123")

1910 .build();

1911 FileContentPage page = client.vectorStores().files().content(params);

1912 }

1913}

1914```

1915

1916#### Response

1917

1918```json

1919{

1920 "data": [

1921 {

1922 "text": "text",

1923 "type": "type"

1924 }

1925 ],

1926 "has_more": true,

1927 "next_page": "next_page",

1928 "object": "vector_store.file_content.page"

1929}

1930```

1931

1932## Domain Types

1933

1934### Vector Store File

1935

1936- `class VectorStoreFile:`

1937

1938 A list of files attached to a vector store.

1939

1940 - `String id`

1941

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

1943

1944 - `long createdAt`

1945

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

1947

1948 - `Optional<LastError> lastError`

1949

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

1951

1952 - `Code code`

1953

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

1955

1956 - `SERVER_ERROR("server_error")`

1957

1958 - `UNSUPPORTED_FILE("unsupported_file")`

1959

1960 - `INVALID_FILE("invalid_file")`

1961

1962 - `String message`

1963

1964 A human-readable description of the error.

1965

1966 - `JsonValue; object_ "vector_store.file"constant`

1967

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

1969

1970 - `VECTOR_STORE_FILE("vector_store.file")`

1971

1972 - `Status status`

1973

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

1975

1976 - `IN_PROGRESS("in_progress")`

1977

1978 - `COMPLETED("completed")`

1979

1980 - `CANCELLED("cancelled")`

1981

1982 - `FAILED("failed")`

1983

1984 - `long usageBytes`

1985

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

1987

1988 - `String vectorStoreId`

1989

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

1991

1992 - `Optional<Attributes> attributes`

1993

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

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

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

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

1998 length of 512 characters, booleans, or numbers.

1999

2000 - `String`

2001

2002 - `double`

2003

2004 - `boolean`

2005

2006 - `Optional<JsonValue> chunkingStrategy`

2007

2008### Vector Store File Deleted

2009

2010- `class VectorStoreFileDeleted:`

2011

2012 - `String id`

2013

2014 - `boolean deleted`

2015

2016 - `JsonValue; object_ "vector_store.file.deleted"constant`

2017

2018 - `VECTOR_STORE_FILE_DELETED("vector_store.file.deleted")`

2019

2020# File Batches

2021

2022## Create vector store file batch

2023

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

2025

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

2027

2028Create vector store file batch

2029

2030### Parameters

2031

2032- `FileBatchCreateParams params`

2033

2034 - `Optional<String> vectorStoreId`

2035

2036 - `Optional<Attributes> attributes`

2037

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

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

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

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

2042 length of 512 characters, booleans, or numbers.

2043

2044 - `String`

2045

2046 - `double`

2047

2048 - `boolean`

2049

2050 - `Optional<JsonValue> chunkingStrategy`

2051

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

2053

2054 A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that the vector store should use. Useful for tools like `file_search` that can access files. 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`.

2055

2056 - `Optional<List<File>> files`

2057

2058 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`.

2059

2060 - `String fileId`

2061

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

2063

2064 - `Optional<Attributes> attributes`

2065

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

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

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

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

2070 length of 512 characters, booleans, or numbers.

2071

2072 - `String`

2073

2074 - `double`

2075

2076 - `boolean`

2077

2078 - `Optional<JsonValue> chunkingStrategy`

2079

2080### Returns

2081

2082- `class VectorStoreFileBatch:`

2083

2084 A batch of files attached to a vector store.

2085

2086 - `String id`

2087

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

2089

2090 - `long createdAt`

2091

2092 The Unix timestamp (in seconds) for when the vector store files batch was created.

2093

2094 - `FileCounts fileCounts`

2095

2096 - `long cancelled`

2097

2098 The number of files that where cancelled.

2099

2100 - `long completed`

2101

2102 The number of files that have been processed.

2103

2104 - `long failed`

2105

2106 The number of files that have failed to process.

2107

2108 - `long inProgress`

2109

2110 The number of files that are currently being processed.

2111

2112 - `long total`

2113

2114 The total number of files.

2115

2116 - `JsonValue; object_ "vector_store.files_batch"constant`

2117

2118 The object type, which is always `vector_store.file_batch`.

2119

2120 - `VECTOR_STORE_FILES_BATCH("vector_store.files_batch")`

2121

2122 - `Status status`

2123

2124 The status of the vector store files batch, which can be either `in_progress`, `completed`, `cancelled` or `failed`.

2125

2126 - `IN_PROGRESS("in_progress")`

2127

2128 - `COMPLETED("completed")`

2129

2130 - `CANCELLED("cancelled")`

2131

2132 - `FAILED("failed")`

2133

2134 - `String vectorStoreId`

2135

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

2137

2138### Example

2139

2140```java

2141package com.openai.example;

2142

2143import com.openai.client.OpenAIClient;

2144import com.openai.client.okhttp.OpenAIOkHttpClient;

2145import com.openai.models.vectorstores.filebatches.FileBatchCreateParams;

2146import com.openai.models.vectorstores.filebatches.VectorStoreFileBatch;

2147

2148public final class Main {

2149 private Main() {}

2150

2151 public static void main(String[] args) {

2152 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

2153

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

2155 }

2156}

2157```

2158

2159#### Response

2160

2161```json

2162{

2163 "id": "id",

2164 "created_at": 0,

2165 "file_counts": {

2166 "cancelled": 0,

2167 "completed": 0,

2168 "failed": 0,

2169 "in_progress": 0,

2170 "total": 0

2171 },

2172 "object": "vector_store.files_batch",

2173 "status": "in_progress",

2174 "vector_store_id": "vector_store_id"

2175}

2176```

2177

2178## Retrieve vector store file batch

2179

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

2181

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

2183

2184Retrieve vector store file batch

2185

2186### Parameters

2187

2188- `FileBatchRetrieveParams params`

2189

2190 - `String vectorStoreId`

2191

2192 - `Optional<String> batchId`

2193

2194### Returns

2195

2196- `class VectorStoreFileBatch:`

2197

2198 A batch of files attached to a vector store.

2199

2200 - `String id`

2201

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

2203

2204 - `long createdAt`

2205

2206 The Unix timestamp (in seconds) for when the vector store files batch was created.

2207

2208 - `FileCounts fileCounts`

2209

2210 - `long cancelled`

2211

2212 The number of files that where cancelled.

2213

2214 - `long completed`

2215

2216 The number of files that have been processed.

2217

2218 - `long failed`

2219

2220 The number of files that have failed to process.

2221

2222 - `long inProgress`

2223

2224 The number of files that are currently being processed.

2225

2226 - `long total`

2227

2228 The total number of files.

2229

2230 - `JsonValue; object_ "vector_store.files_batch"constant`

2231

2232 The object type, which is always `vector_store.file_batch`.

2233

2234 - `VECTOR_STORE_FILES_BATCH("vector_store.files_batch")`

2235

2236 - `Status status`

2237

2238 The status of the vector store files batch, which can be either `in_progress`, `completed`, `cancelled` or `failed`.

2239

2240 - `IN_PROGRESS("in_progress")`

2241

2242 - `COMPLETED("completed")`

2243

2244 - `CANCELLED("cancelled")`

2245

2246 - `FAILED("failed")`

2247

2248 - `String vectorStoreId`

2249

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

2251

2252### Example

2253

2254```java

2255package com.openai.example;

2256

2257import com.openai.client.OpenAIClient;

2258import com.openai.client.okhttp.OpenAIOkHttpClient;

2259import com.openai.models.vectorstores.filebatches.FileBatchRetrieveParams;

2260import com.openai.models.vectorstores.filebatches.VectorStoreFileBatch;

2261

2262public final class Main {

2263 private Main() {}

2264

2265 public static void main(String[] args) {

2266 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

2267

2268 FileBatchRetrieveParams params = FileBatchRetrieveParams.builder()

2269 .vectorStoreId("vs_abc123")

2270 .batchId("vsfb_abc123")

2271 .build();

2272 VectorStoreFileBatch vectorStoreFileBatch = client.vectorStores().fileBatches().retrieve(params);

2273 }

2274}

2275```

2276

2277#### Response

2278

2279```json

2280{

2281 "id": "id",

2282 "created_at": 0,

2283 "file_counts": {

2284 "cancelled": 0,

2285 "completed": 0,

2286 "failed": 0,

2287 "in_progress": 0,

2288 "total": 0

2289 },

2290 "object": "vector_store.files_batch",

2291 "status": "in_progress",

2292 "vector_store_id": "vector_store_id"

2293}

2294```

2295

2296## Cancel vector store file batch

2297

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

2299

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

2301

2302Cancel vector store file batch

2303

2304### Parameters

2305

2306- `FileBatchCancelParams params`

2307

2308 - `String vectorStoreId`

2309

2310 - `Optional<String> batchId`

2311

2312### Returns

2313

2314- `class VectorStoreFileBatch:`

2315

2316 A batch of files attached to a vector store.

2317

2318 - `String id`

2319

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

2321

2322 - `long createdAt`

2323

2324 The Unix timestamp (in seconds) for when the vector store files batch was created.

2325

2326 - `FileCounts fileCounts`

2327

2328 - `long cancelled`

2329

2330 The number of files that where cancelled.

2331

2332 - `long completed`

2333

2334 The number of files that have been processed.

2335

2336 - `long failed`

2337

2338 The number of files that have failed to process.

2339

2340 - `long inProgress`

2341

2342 The number of files that are currently being processed.

2343

2344 - `long total`

2345

2346 The total number of files.

2347

2348 - `JsonValue; object_ "vector_store.files_batch"constant`

2349

2350 The object type, which is always `vector_store.file_batch`.

2351

2352 - `VECTOR_STORE_FILES_BATCH("vector_store.files_batch")`

2353

2354 - `Status status`

2355

2356 The status of the vector store files batch, which can be either `in_progress`, `completed`, `cancelled` or `failed`.

2357

2358 - `IN_PROGRESS("in_progress")`

2359

2360 - `COMPLETED("completed")`

2361

2362 - `CANCELLED("cancelled")`

2363

2364 - `FAILED("failed")`

2365

2366 - `String vectorStoreId`

2367

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

2369

2370### Example

2371

2372```java

2373package com.openai.example;

2374

2375import com.openai.client.OpenAIClient;

2376import com.openai.client.okhttp.OpenAIOkHttpClient;

2377import com.openai.models.vectorstores.filebatches.FileBatchCancelParams;

2378import com.openai.models.vectorstores.filebatches.VectorStoreFileBatch;

2379

2380public final class Main {

2381 private Main() {}

2382

2383 public static void main(String[] args) {

2384 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

2385

2386 FileBatchCancelParams params = FileBatchCancelParams.builder()

2387 .vectorStoreId("vector_store_id")

2388 .batchId("batch_id")

2389 .build();

2390 VectorStoreFileBatch vectorStoreFileBatch = client.vectorStores().fileBatches().cancel(params);

2391 }

2392}

2393```

2394

2395#### Response

2396

2397```json

2398{

2399 "id": "id",

2400 "created_at": 0,

2401 "file_counts": {

2402 "cancelled": 0,

2403 "completed": 0,

2404 "failed": 0,

2405 "in_progress": 0,

2406 "total": 0

2407 },

2408 "object": "vector_store.files_batch",

2409 "status": "in_progress",

2410 "vector_store_id": "vector_store_id"

2411}

2412```

2413

2414## List vector store files in a batch

2415

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

2417

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

2419

2420List vector store files in a batch

2421

2422### Parameters

2423

2424- `FileBatchListFilesParams params`

2425

2426 - `String vectorStoreId`

2427

2428 - `Optional<String> batchId`

2429

2430 - `Optional<String> after`

2431

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

2433

2434 - `Optional<String> before`

2435

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

2437

2438 - `Optional<Filter> filter`

2439

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

2441

2442 - `IN_PROGRESS("in_progress")`

2443

2444 - `COMPLETED("completed")`

2445

2446 - `FAILED("failed")`

2447

2448 - `CANCELLED("cancelled")`

2449

2450 - `Optional<Long> limit`

2451

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

2453

2454 - `Optional<Order> order`

2455

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

2457

2458 - `ASC("asc")`

2459

2460 - `DESC("desc")`

2461

2462### Returns

2463

2464- `class VectorStoreFile:`

2465

2466 A list of files attached to a vector store.

2467

2468 - `String id`

2469

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

2471

2472 - `long createdAt`

2473

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

2475

2476 - `Optional<LastError> lastError`

2477

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

2479

2480 - `Code code`

2481

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

2483

2484 - `SERVER_ERROR("server_error")`

2485

2486 - `UNSUPPORTED_FILE("unsupported_file")`

2487

2488 - `INVALID_FILE("invalid_file")`

2489

2490 - `String message`

2491

2492 A human-readable description of the error.

2493

2494 - `JsonValue; object_ "vector_store.file"constant`

2495

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

2497

2498 - `VECTOR_STORE_FILE("vector_store.file")`

2499

2500 - `Status status`

2501

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

2503

2504 - `IN_PROGRESS("in_progress")`

2505

2506 - `COMPLETED("completed")`

2507

2508 - `CANCELLED("cancelled")`

2509

2510 - `FAILED("failed")`

2511

2512 - `long usageBytes`

2513

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

2515

2516 - `String vectorStoreId`

2517

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

2519

2520 - `Optional<Attributes> attributes`

2521

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

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

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

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

2526 length of 512 characters, booleans, or numbers.

2527

2528 - `String`

2529

2530 - `double`

2531

2532 - `boolean`

2533

2534 - `Optional<JsonValue> chunkingStrategy`

2535

2536### Example

2537

2538```java

2539package com.openai.example;

2540

2541import com.openai.client.OpenAIClient;

2542import com.openai.client.okhttp.OpenAIOkHttpClient;

2543import com.openai.models.vectorstores.filebatches.FileBatchListFilesPage;

2544import com.openai.models.vectorstores.filebatches.FileBatchListFilesParams;

2545

2546public final class Main {

2547 private Main() {}

2548

2549 public static void main(String[] args) {

2550 OpenAIClient client = OpenAIOkHttpClient.fromEnv();

2551

2552 FileBatchListFilesParams params = FileBatchListFilesParams.builder()

2553 .vectorStoreId("vector_store_id")

2554 .batchId("batch_id")

2555 .build();

2556 FileBatchListFilesPage page = client.vectorStores().fileBatches().listFiles(params);

2557 }

2558}

2559```

2560

2561#### Response

2562

2563```json

2564{

2565 "data": [

2566 {

2567 "id": "id",

2568 "created_at": 0,

2569 "last_error": {

2570 "code": "server_error",

2571 "message": "message"

2572 },

2573 "object": "vector_store.file",

2574 "status": "in_progress",

2575 "usage_bytes": 0,

2576 "vector_store_id": "vector_store_id",

2577 "attributes": {

2578 "foo": "string"

2579 },

2580 "chunking_strategy": {}

2581 }

2582 ],

2583 "first_id": "file-abc123",

2584 "has_more": false,

2585 "last_id": "file-abc456",

2586 "object": "list"

2587}

2588```

2589

2590## Domain Types

2591

2592### Vector Store File Batch

2593

2594- `class VectorStoreFileBatch:`

2595

2596 A batch of files attached to a vector store.

2597

2598 - `String id`

2599

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

2601

2602 - `long createdAt`

2603

2604 The Unix timestamp (in seconds) for when the vector store files batch was created.

2605

2606 - `FileCounts fileCounts`

2607

2608 - `long cancelled`

2609

2610 The number of files that where cancelled.

2611

2612 - `long completed`

2613

2614 The number of files that have been processed.

2615

2616 - `long failed`

2617

2618 The number of files that have failed to process.

2619

2620 - `long inProgress`

2621

2622 The number of files that are currently being processed.

2623

2624 - `long total`

2625

2626 The total number of files.

2627

2628 - `JsonValue; object_ "vector_store.files_batch"constant`

2629

2630 The object type, which is always `vector_store.file_batch`.

2631

2632 - `VECTOR_STORE_FILES_BATCH("vector_store.files_batch")`

2633

2634 - `Status status`

2635

2636 The status of the vector store files batch, which can be either `in_progress`, `completed`, `cancelled` or `failed`.

2637

2638 - `IN_PROGRESS("in_progress")`

2639

2640 - `COMPLETED("completed")`

2641

2642 - `CANCELLED("cancelled")`

2643

2644 - `FAILED("failed")`

2645

2646 - `String vectorStoreId`

2647

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

java/resources/vector_stores/index.md 2026-07-07 08:02 UTC to 2026-07-09 20: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