Vector Stores

List vector stores

client.VectorStores.List(ctx, query) (*CursorPage[VectorStore], error)

get /vector_stores

Returns a list of vector stores.

Parameters

query VectorStoreListParams
- After param.Field[string]
  
  A cursor for use in pagination. after is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
- Before param.Field[string]
  
  A cursor for use in pagination. before is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.
- Limit param.Field[int64]
  
  A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
- Order param.Field[VectorStoreListParamsOrder]
  
  Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
  - const VectorStoreListParamsOrderAsc VectorStoreListParamsOrder = "asc"
  - const VectorStoreListParamsOrderDesc VectorStoreListParamsOrder = "desc"

Returns

type VectorStore struct{…}

A vector store is a collection of processed files can be used by the file_search tool.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store was created.
- FileCounts VectorStoreFileCounts
  - Cancelled int64
    
    The number of files that were cancelled.
  - Completed int64
    
    The number of files that have been successfully processed.
  - Failed int64
    
    The number of files that have failed to process.
  - InProgress int64
    
    The number of files that are currently being processed.
  - Total int64
    
    The total number of files.
- LastActiveAt int64
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- Metadata Metadata
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- Name string
  
  The name of the vector store.
- Object VectorStore
  
  The object type, which is always vector_store.
  - const VectorStoreVectorStore VectorStore = "vector_store"
- Status VectorStoreStatus
  
  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.
  - const VectorStoreStatusExpired VectorStoreStatus = "expired"
  - const VectorStoreStatusInProgress VectorStoreStatus = "in_progress"
  - const VectorStoreStatusCompleted VectorStoreStatus = "completed"
- UsageBytes int64
  
  The total number of bytes used by the files in the vector store.
- ExpiresAfter VectorStoreExpiresAfter
  
  The expiration policy for a vector store.
  - Anchor LastActiveAt
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - const LastActiveAtLastActiveAt LastActiveAt = "last_active_at"
  - Days int64
    
    The number of days after the anchor time that the vector store will expire.
- ExpiresAt int64
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  page, err := client.VectorStores.List(context.TODO(), openai.VectorStoreListParams{

  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}

Response

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

Create vector store

client.VectorStores.New(ctx, body) (*VectorStore, error)

post /vector_stores

Create a vector store.

Parameters

body VectorStoreNewParams
- ChunkingStrategy param.Field[FileChunkingStrategyParamUnionResp]
  
  The chunking strategy used to chunk the file(s). If not set, will use the auto strategy. Only applicable if file_ids is non-empty.
- Description param.Field[string]
  
  A description for the vector store. Can be used to describe the vector store's purpose.
- ExpiresAfter param.Field[VectorStoreNewParamsExpiresAfter]
  
  The expiration policy for a vector store.
  - Anchor LastActiveAt
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - const LastActiveAtLastActiveAt LastActiveAt = "last_active_at"
  - Days int64
    
    The number of days after the anchor time that the vector store will expire.
- FileIDs param.Field[[]string]
  
  A list of File IDs that the vector store should use. Useful for tools like file_search that can access files.
- Metadata param.Field[Metadata]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- Name param.Field[string]
  
  The name of the vector store.

Returns

type VectorStore struct{…}

A vector store is a collection of processed files can be used by the file_search tool.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store was created.
- FileCounts VectorStoreFileCounts
  - Cancelled int64
    
    The number of files that were cancelled.
  - Completed int64
    
    The number of files that have been successfully processed.
  - Failed int64
    
    The number of files that have failed to process.
  - InProgress int64
    
    The number of files that are currently being processed.
  - Total int64
    
    The total number of files.
- LastActiveAt int64
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- Metadata Metadata
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- Name string
  
  The name of the vector store.
- Object VectorStore
  
  The object type, which is always vector_store.
  - const VectorStoreVectorStore VectorStore = "vector_store"
- Status VectorStoreStatus
  
  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.
  - const VectorStoreStatusExpired VectorStoreStatus = "expired"
  - const VectorStoreStatusInProgress VectorStoreStatus = "in_progress"
  - const VectorStoreStatusCompleted VectorStoreStatus = "completed"
- UsageBytes int64
  
  The total number of bytes used by the files in the vector store.
- ExpiresAfter VectorStoreExpiresAfter
  
  The expiration policy for a vector store.
  - Anchor LastActiveAt
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - const LastActiveAtLastActiveAt LastActiveAt = "last_active_at"
  - Days int64
    
    The number of days after the anchor time that the vector store will expire.
- ExpiresAt int64
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStore, err := client.VectorStores.New(context.TODO(), openai.VectorStoreNewParams{

  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStore.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
}

Retrieve vector store

client.VectorStores.Get(ctx, vectorStoreID) (*VectorStore, error)

get /vector_stores/{vector_store_id}

Retrieves a vector store.

Parameters

vectorStoreID string

Returns

type VectorStore struct{…}

A vector store is a collection of processed files can be used by the file_search tool.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store was created.
- FileCounts VectorStoreFileCounts
  - Cancelled int64
    
    The number of files that were cancelled.
  - Completed int64
    
    The number of files that have been successfully processed.
  - Failed int64
    
    The number of files that have failed to process.
  - InProgress int64
    
    The number of files that are currently being processed.
  - Total int64
    
    The total number of files.
- LastActiveAt int64
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- Metadata Metadata
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- Name string
  
  The name of the vector store.
- Object VectorStore
  
  The object type, which is always vector_store.
  - const VectorStoreVectorStore VectorStore = "vector_store"
- Status VectorStoreStatus
  
  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.
  - const VectorStoreStatusExpired VectorStoreStatus = "expired"
  - const VectorStoreStatusInProgress VectorStoreStatus = "in_progress"
  - const VectorStoreStatusCompleted VectorStoreStatus = "completed"
- UsageBytes int64
  
  The total number of bytes used by the files in the vector store.
- ExpiresAfter VectorStoreExpiresAfter
  
  The expiration policy for a vector store.
  - Anchor LastActiveAt
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - const LastActiveAtLastActiveAt LastActiveAt = "last_active_at"
  - Days int64
    
    The number of days after the anchor time that the vector store will expire.
- ExpiresAt int64
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStore, err := client.VectorStores.Get(context.TODO(), "vector_store_id")
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStore.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

client.VectorStores.Update(ctx, vectorStoreID, body) (*VectorStore, error)

post /vector_stores/{vector_store_id}

Modifies a vector store.

Parameters

vectorStoreID string
body VectorStoreUpdateParams
- ExpiresAfter param.Field[VectorStoreUpdateParamsExpiresAfter]
  
  The expiration policy for a vector store.
  - Anchor LastActiveAt
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - const LastActiveAtLastActiveAt LastActiveAt = "last_active_at"
  - Days int64
    
    The number of days after the anchor time that the vector store will expire.
- Metadata param.Field[Metadata]
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- Name param.Field[string]
  
  The name of the vector store.

Returns

type VectorStore struct{…}

A vector store is a collection of processed files can be used by the file_search tool.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store was created.
- FileCounts VectorStoreFileCounts
  - Cancelled int64
    
    The number of files that were cancelled.
  - Completed int64
    
    The number of files that have been successfully processed.
  - Failed int64
    
    The number of files that have failed to process.
  - InProgress int64
    
    The number of files that are currently being processed.
  - Total int64
    
    The total number of files.
- LastActiveAt int64
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- Metadata Metadata
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- Name string
  
  The name of the vector store.
- Object VectorStore
  
  The object type, which is always vector_store.
  - const VectorStoreVectorStore VectorStore = "vector_store"
- Status VectorStoreStatus
  
  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.
  - const VectorStoreStatusExpired VectorStoreStatus = "expired"
  - const VectorStoreStatusInProgress VectorStoreStatus = "in_progress"
  - const VectorStoreStatusCompleted VectorStoreStatus = "completed"
- UsageBytes int64
  
  The total number of bytes used by the files in the vector store.
- ExpiresAfter VectorStoreExpiresAfter
  
  The expiration policy for a vector store.
  - Anchor LastActiveAt
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - const LastActiveAtLastActiveAt LastActiveAt = "last_active_at"
  - Days int64
    
    The number of days after the anchor time that the vector store will expire.
- ExpiresAt int64
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStore, err := client.VectorStores.Update(
    context.TODO(),
    "vector_store_id",
    openai.VectorStoreUpdateParams{

    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStore.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

client.VectorStores.Delete(ctx, vectorStoreID) (*VectorStoreDeleted, error)

delete /vector_stores/{vector_store_id}

Delete a vector store.

Parameters

vectorStoreID string

Returns

type VectorStoreDeleted struct{…}
- ID string
- Deleted bool
- Object VectorStoreDeleted
  - const VectorStoreDeletedVectorStoreDeleted VectorStoreDeleted = "vector_store.deleted"

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStoreDeleted, err := client.VectorStores.Delete(context.TODO(), "vector_store_id")
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStoreDeleted.ID)
}

Response

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

Search vector store

client.VectorStores.Search(ctx, vectorStoreID, body) (*Page[VectorStoreSearchResponse], error)

post /vector_stores/{vector_store_id}/search

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

Parameters

vectorStoreID string
body VectorStoreSearchParams
- Query param.Field[VectorStoreSearchParamsQueryUnion]
  
  A query string for a search
  - string
  - type VectorStoreSearchParamsQueryArray []string
- Filters param.Field[VectorStoreSearchParamsFiltersUnion]
  
  A filter to apply based on file attributes.
  - type ComparisonFilter struct{…}
    
    A filter used to compare a specified attribute key to a given value using a defined comparison operation.
    - Key string
      
      The key to compare against the value.
    - Type ComparisonFilterType
      
      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
      - const ComparisonFilterTypeEq ComparisonFilterType = "eq"
      - const ComparisonFilterTypeNe ComparisonFilterType = "ne"
      - const ComparisonFilterTypeGt ComparisonFilterType = "gt"
      - const ComparisonFilterTypeGte ComparisonFilterType = "gte"
      - const ComparisonFilterTypeLt ComparisonFilterType = "lt"
      - const ComparisonFilterTypeLte ComparisonFilterType = "lte"
      - const ComparisonFilterTypeIn ComparisonFilterType = "in"
      - const ComparisonFilterTypeNin ComparisonFilterType = "nin"
    - Value ComparisonFilterValueUnion
      
      The value to compare against the attribute key; supports string, number, or boolean types.
      - string
      - float64
      - bool
      - type ComparisonFilterValueArray []ComparisonFilterValueArrayItemUnion
        
        string
        
        float64
  - type CompoundFilter struct{…}
    
    Combine multiple filters using and or or.
    - Filters []ComparisonFilter
      
      Array of filters to combine. Items can be ComparisonFilter or CompoundFilter.
      - type ComparisonFilter struct{…}
        
        A filter used to compare a specified attribute key to a given value using a defined comparison operation.
    - Type CompoundFilterType
      
      Type of operation: and or or.
      - const CompoundFilterTypeAnd CompoundFilterType = "and"
      - const CompoundFilterTypeOr CompoundFilterType = "or"
- MaxNumResults param.Field[int64]
  
  The maximum number of results to return. This number should be between 1 and 50 inclusive.
- RankingOptions param.Field[VectorStoreSearchParamsRankingOptions]
  
  Ranking options for search.
  - Ranker string
    
    Enable re-ranking; set to none to disable, which can help reduce latency.
    - const VectorStoreSearchParamsRankingOptionsRankerNone VectorStoreSearchParamsRankingOptionsRanker = "none"
    - const VectorStoreSearchParamsRankingOptionsRankerAuto VectorStoreSearchParamsRankingOptionsRanker = "auto"
    - const VectorStoreSearchParamsRankingOptionsRankerDefault2024_11_15 VectorStoreSearchParamsRankingOptionsRanker = "default-2024-11-15"
  - ScoreThreshold float64
- RewriteQuery param.Field[bool]
  
  Whether to rewrite the natural language query for vector search.

Returns

type VectorStoreSearchResponse struct{…}
- Attributes map[string, VectorStoreSearchResponseAttributeUnion]
  
  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
  - float64
  - bool
- Content []VectorStoreSearchResponseContent
  
  Content chunks from the file.
  - Text string
    
    The text content returned from search.
  - Type string
    
    The type of content.
    - const VectorStoreSearchResponseContentTypeText VectorStoreSearchResponseContentType = "text"
- FileID string
  
  The ID of the vector store file.
- Filename string
  
  The name of the vector store file.
- Score float64
  
  The similarity score for the result.

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  page, err := client.VectorStores.Search(
    context.TODO(),
    "vs_abc123",
    openai.VectorStoreSearchParams{
      Query: openai.VectorStoreSearchParamsQueryUnion{
        OfString: openai.String("string"),
      },
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}

Response

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

Domain Types

Auto File Chunking Strategy Param

type AutoFileChunkingStrategyParamResp struct{…}

The default strategy. This strategy currently uses a max_chunk_size_tokens of 800 and chunk_overlap_tokens of 400.
- Type Auto
  
  Always auto.
  - const AutoAuto Auto = "auto"

File Chunking Strategy

type FileChunkingStrategyUnion interface{…}

The strategy used to chunk the file.
- type StaticFileChunkingStrategyObject struct{…}
  - Static StaticFileChunkingStrategy
    - ChunkOverlapTokens int64
      
      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.
    - MaxChunkSizeTokens int64
      
      The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
  - Type Static
    
    Always static.
    - const StaticStatic Static = "static"
- type OtherFileChunkingStrategyObject struct{…}
  
  This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the chunking_strategy concept was introduced in the API.
  - Type Other
    
    Always other.
    - const OtherOther Other = "other"

File Chunking Strategy Param

type FileChunkingStrategyParamUnionResp interface{…}

The chunking strategy used to chunk the file(s). If not set, will use the auto strategy. Only applicable if file_ids is non-empty.
- type AutoFileChunkingStrategyParamResp struct{…}
  
  The default strategy. This strategy currently uses a max_chunk_size_tokens of 800 and chunk_overlap_tokens of 400.
  - Type Auto
    
    Always auto.
    - const AutoAuto Auto = "auto"
- type StaticFileChunkingStrategyObjectParamResp struct{…}
  
  Customize your own chunking strategy by setting chunk size and chunk overlap.
  - Static StaticFileChunkingStrategy
    - ChunkOverlapTokens int64
      
      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.
    - MaxChunkSizeTokens int64
      
      The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
  - Type Static
    
    Always static.
    - const StaticStatic Static = "static"

Other File Chunking Strategy Object

type OtherFileChunkingStrategyObject struct{…}

This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the chunking_strategy concept was introduced in the API.
- Type Other
  
  Always other.
  - const OtherOther Other = "other"

Static File Chunking Strategy

type StaticFileChunkingStrategy struct{…}
- ChunkOverlapTokens int64
  
  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.
- MaxChunkSizeTokens int64
  
  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

type StaticFileChunkingStrategyObject struct{…}
- Static StaticFileChunkingStrategy
  - ChunkOverlapTokens int64
    
    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.
  - MaxChunkSizeTokens int64
    
    The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
- Type Static
  
  Always static.
  - const StaticStatic Static = "static"

Static File Chunking Strategy Object Param

type StaticFileChunkingStrategyObjectParamResp struct{…}

Customize your own chunking strategy by setting chunk size and chunk overlap.
- Static StaticFileChunkingStrategy
  - ChunkOverlapTokens int64
    
    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.
  - MaxChunkSizeTokens int64
    
    The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
- Type Static
  
  Always static.
  - const StaticStatic Static = "static"

Vector Store

type VectorStore struct{…}

A vector store is a collection of processed files can be used by the file_search tool.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store was created.
- FileCounts VectorStoreFileCounts
  - Cancelled int64
    
    The number of files that were cancelled.
  - Completed int64
    
    The number of files that have been successfully processed.
  - Failed int64
    
    The number of files that have failed to process.
  - InProgress int64
    
    The number of files that are currently being processed.
  - Total int64
    
    The total number of files.
- LastActiveAt int64
  
  The Unix timestamp (in seconds) for when the vector store was last active.
- Metadata Metadata
  
  Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard.
  
  Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.
- Name string
  
  The name of the vector store.
- Object VectorStore
  
  The object type, which is always vector_store.
  - const VectorStoreVectorStore VectorStore = "vector_store"
- Status VectorStoreStatus
  
  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.
  - const VectorStoreStatusExpired VectorStoreStatus = "expired"
  - const VectorStoreStatusInProgress VectorStoreStatus = "in_progress"
  - const VectorStoreStatusCompleted VectorStoreStatus = "completed"
- UsageBytes int64
  
  The total number of bytes used by the files in the vector store.
- ExpiresAfter VectorStoreExpiresAfter
  
  The expiration policy for a vector store.
  - Anchor LastActiveAt
    
    Anchor timestamp after which the expiration policy applies. Supported anchors: last_active_at.
    - const LastActiveAtLastActiveAt LastActiveAt = "last_active_at"
  - Days int64
    
    The number of days after the anchor time that the vector store will expire.
- ExpiresAt int64
  
  The Unix timestamp (in seconds) for when the vector store will expire.

Vector Store Deleted

type VectorStoreDeleted struct{…}
- ID string
- Deleted bool
- Object VectorStoreDeleted
  - const VectorStoreDeletedVectorStoreDeleted VectorStoreDeleted = "vector_store.deleted"

Files

List vector store files

client.VectorStores.Files.List(ctx, vectorStoreID, query) (*CursorPage[VectorStoreFile], error)

get /vector_stores/{vector_store_id}/files

Returns a list of vector store files.

Parameters

vectorStoreID string
query VectorStoreFileListParams
- After param.Field[string]
  
  A cursor for use in pagination. after is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
- Before param.Field[string]
  
  A cursor for use in pagination. before is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.
- Filter param.Field[VectorStoreFileListParamsFilter]
  
  Filter by file status. One of in_progress, completed, failed, cancelled.
  - const VectorStoreFileListParamsFilterInProgress VectorStoreFileListParamsFilter = "in_progress"
  - const VectorStoreFileListParamsFilterCompleted VectorStoreFileListParamsFilter = "completed"
  - const VectorStoreFileListParamsFilterFailed VectorStoreFileListParamsFilter = "failed"
  - const VectorStoreFileListParamsFilterCancelled VectorStoreFileListParamsFilter = "cancelled"
- Limit param.Field[int64]
  
  A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
- Order param.Field[VectorStoreFileListParamsOrder]
  
  Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
  - const VectorStoreFileListParamsOrderAsc VectorStoreFileListParamsOrder = "asc"
  - const VectorStoreFileListParamsOrderDesc VectorStoreFileListParamsOrder = "desc"

Returns

type VectorStoreFile struct{…}

A list of files attached to a vector store.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- LastError VectorStoreFileLastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code string
    
    One of server_error, unsupported_file, or invalid_file.
    - const VectorStoreFileLastErrorCodeServerError VectorStoreFileLastErrorCode = "server_error"
    - const VectorStoreFileLastErrorCodeUnsupportedFile VectorStoreFileLastErrorCode = "unsupported_file"
    - const VectorStoreFileLastErrorCodeInvalidFile VectorStoreFileLastErrorCode = "invalid_file"
  - Message string
    
    A human-readable description of the error.
- Object VectorStoreFile
  
  The object type, which is always vector_store.file.
  - const VectorStoreFileVectorStoreFile VectorStoreFile = "vector_store.file"
- Status VectorStoreFileStatus
  
  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.
  - const VectorStoreFileStatusInProgress VectorStoreFileStatus = "in_progress"
  - const VectorStoreFileStatusCompleted VectorStoreFileStatus = "completed"
  - const VectorStoreFileStatusCancelled VectorStoreFileStatus = "cancelled"
  - const VectorStoreFileStatusFailed VectorStoreFileStatus = "failed"
- UsageBytes int64
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- VectorStoreID string
  
  The ID of the vector store that the File is attached to.
- Attributes map[string, VectorStoreFileAttributeUnion]
  
  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
  - float64
  - bool
- ChunkingStrategy FileChunkingStrategyUnion
  
  The strategy used to chunk the file.
  - type StaticFileChunkingStrategyObject struct{…}
    - Static StaticFileChunkingStrategy
      - ChunkOverlapTokens int64
        
        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.
      - MaxChunkSizeTokens int64
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - Type Static
      
      Always static.
      - const StaticStatic Static = "static"
  - type OtherFileChunkingStrategyObject struct{…}
    
    This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the chunking_strategy concept was introduced in the API.
    - Type Other
      
      Always other.
      - const OtherOther Other = "other"

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  page, err := client.VectorStores.Files.List(
    context.TODO(),
    "vector_store_id",
    openai.VectorStoreFileListParams{

    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}

Response

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

Create vector store file

client.VectorStores.Files.New(ctx, vectorStoreID, body) (*VectorStoreFile, error)

post /vector_stores/{vector_store_id}/files

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

Parameters

vectorStoreID string
body VectorStoreFileNewParams
- FileID param.Field[string]
  
  A File ID that the vector store should use. Useful for tools like file_search that can access files. For multi-file ingestion, we recommend file_batches to minimize per-vector-store write requests.
- Attributes param.Field[map[string, VectorStoreFileNewParamsAttributeUnion]]
  
  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
  - float64
  - bool
- ChunkingStrategy param.Field[FileChunkingStrategyParamUnionResp]
  
  The chunking strategy used to chunk the file(s). If not set, will use the auto strategy. Only applicable if file_ids is non-empty.

Returns

type VectorStoreFile struct{…}

A list of files attached to a vector store.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- LastError VectorStoreFileLastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code string
    
    One of server_error, unsupported_file, or invalid_file.
    - const VectorStoreFileLastErrorCodeServerError VectorStoreFileLastErrorCode = "server_error"
    - const VectorStoreFileLastErrorCodeUnsupportedFile VectorStoreFileLastErrorCode = "unsupported_file"
    - const VectorStoreFileLastErrorCodeInvalidFile VectorStoreFileLastErrorCode = "invalid_file"
  - Message string
    
    A human-readable description of the error.
- Object VectorStoreFile
  
  The object type, which is always vector_store.file.
  - const VectorStoreFileVectorStoreFile VectorStoreFile = "vector_store.file"
- Status VectorStoreFileStatus
  
  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.
  - const VectorStoreFileStatusInProgress VectorStoreFileStatus = "in_progress"
  - const VectorStoreFileStatusCompleted VectorStoreFileStatus = "completed"
  - const VectorStoreFileStatusCancelled VectorStoreFileStatus = "cancelled"
  - const VectorStoreFileStatusFailed VectorStoreFileStatus = "failed"
- UsageBytes int64
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- VectorStoreID string
  
  The ID of the vector store that the File is attached to.
- Attributes map[string, VectorStoreFileAttributeUnion]
  
  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
  - float64
  - bool
- ChunkingStrategy FileChunkingStrategyUnion
  
  The strategy used to chunk the file.
  - type StaticFileChunkingStrategyObject struct{…}
    - Static StaticFileChunkingStrategy
      - ChunkOverlapTokens int64
        
        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.
      - MaxChunkSizeTokens int64
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - Type Static
      
      Always static.
      - const StaticStatic Static = "static"
  - type OtherFileChunkingStrategyObject struct{…}
    
    This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the chunking_strategy concept was introduced in the API.
    - Type Other
      
      Always other.
      - const OtherOther Other = "other"

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStoreFile, err := client.VectorStores.Files.New(
    context.TODO(),
    "vs_abc123",
    openai.VectorStoreFileNewParams{
      FileID: "file_id",
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStoreFile.ID)
}

Response

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

Update vector store file attributes

client.VectorStores.Files.Update(ctx, vectorStoreID, fileID, body) (*VectorStoreFile, error)

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

Update attributes on a vector store file.

Parameters

vectorStoreID string
fileID string
body VectorStoreFileUpdateParams
- Attributes param.Field[map[string, VectorStoreFileUpdateParamsAttributeUnion]]
  
  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
  - float64
  - bool

Returns

type VectorStoreFile struct{…}

A list of files attached to a vector store.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- LastError VectorStoreFileLastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code string
    
    One of server_error, unsupported_file, or invalid_file.
    - const VectorStoreFileLastErrorCodeServerError VectorStoreFileLastErrorCode = "server_error"
    - const VectorStoreFileLastErrorCodeUnsupportedFile VectorStoreFileLastErrorCode = "unsupported_file"
    - const VectorStoreFileLastErrorCodeInvalidFile VectorStoreFileLastErrorCode = "invalid_file"
  - Message string
    
    A human-readable description of the error.
- Object VectorStoreFile
  
  The object type, which is always vector_store.file.
  - const VectorStoreFileVectorStoreFile VectorStoreFile = "vector_store.file"
- Status VectorStoreFileStatus
  
  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.
  - const VectorStoreFileStatusInProgress VectorStoreFileStatus = "in_progress"
  - const VectorStoreFileStatusCompleted VectorStoreFileStatus = "completed"
  - const VectorStoreFileStatusCancelled VectorStoreFileStatus = "cancelled"
  - const VectorStoreFileStatusFailed VectorStoreFileStatus = "failed"
- UsageBytes int64
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- VectorStoreID string
  
  The ID of the vector store that the File is attached to.
- Attributes map[string, VectorStoreFileAttributeUnion]
  
  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
  - float64
  - bool
- ChunkingStrategy FileChunkingStrategyUnion
  
  The strategy used to chunk the file.
  - type StaticFileChunkingStrategyObject struct{…}
    - Static StaticFileChunkingStrategy
      - ChunkOverlapTokens int64
        
        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.
      - MaxChunkSizeTokens int64
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - Type Static
      
      Always static.
      - const StaticStatic Static = "static"
  - type OtherFileChunkingStrategyObject struct{…}
    
    This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the chunking_strategy concept was introduced in the API.
    - Type Other
      
      Always other.
      - const OtherOther Other = "other"

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStoreFile, err := client.VectorStores.Files.Update(
    context.TODO(),
    "vs_abc123",
    "file-abc123",
    openai.VectorStoreFileUpdateParams{
      Attributes: map[string]openai.VectorStoreFileUpdateParamsAttributeUnion{
      "foo": openai.VectorStoreFileUpdateParamsAttributeUnion{
        OfString: openai.String("string"),
      },
      },
    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStoreFile.ID)
}

Response

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

Retrieve vector store file

client.VectorStores.Files.Get(ctx, vectorStoreID, fileID) (*VectorStoreFile, error)

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

Retrieves a vector store file.

Parameters

vectorStoreID string
fileID string

Returns

type VectorStoreFile struct{…}

A list of files attached to a vector store.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- LastError VectorStoreFileLastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code string
    
    One of server_error, unsupported_file, or invalid_file.
    - const VectorStoreFileLastErrorCodeServerError VectorStoreFileLastErrorCode = "server_error"
    - const VectorStoreFileLastErrorCodeUnsupportedFile VectorStoreFileLastErrorCode = "unsupported_file"
    - const VectorStoreFileLastErrorCodeInvalidFile VectorStoreFileLastErrorCode = "invalid_file"
  - Message string
    
    A human-readable description of the error.
- Object VectorStoreFile
  
  The object type, which is always vector_store.file.
  - const VectorStoreFileVectorStoreFile VectorStoreFile = "vector_store.file"
- Status VectorStoreFileStatus
  
  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.
  - const VectorStoreFileStatusInProgress VectorStoreFileStatus = "in_progress"
  - const VectorStoreFileStatusCompleted VectorStoreFileStatus = "completed"
  - const VectorStoreFileStatusCancelled VectorStoreFileStatus = "cancelled"
  - const VectorStoreFileStatusFailed VectorStoreFileStatus = "failed"
- UsageBytes int64
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- VectorStoreID string
  
  The ID of the vector store that the File is attached to.
- Attributes map[string, VectorStoreFileAttributeUnion]
  
  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
  - float64
  - bool
- ChunkingStrategy FileChunkingStrategyUnion
  
  The strategy used to chunk the file.
  - type StaticFileChunkingStrategyObject struct{…}
    - Static StaticFileChunkingStrategy
      - ChunkOverlapTokens int64
        
        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.
      - MaxChunkSizeTokens int64
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - Type Static
      
      Always static.
      - const StaticStatic Static = "static"
  - type OtherFileChunkingStrategyObject struct{…}
    
    This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the chunking_strategy concept was introduced in the API.
    - Type Other
      
      Always other.
      - const OtherOther Other = "other"

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStoreFile, err := client.VectorStores.Files.Get(
    context.TODO(),
    "vs_abc123",
    "file-abc123",
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStoreFile.ID)
}

Response

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

Delete vector store file

client.VectorStores.Files.Delete(ctx, vectorStoreID, fileID) (*VectorStoreFileDeleted, error)

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

Delete a vector store file. This will remove the file from the vector store but the file itself will not be deleted. To delete the file, use the delete file endpoint.

Parameters

vectorStoreID string
fileID string

Returns

type VectorStoreFileDeleted struct{…}
- ID string
- Deleted bool
- Object VectorStoreFileDeleted
  - const VectorStoreFileDeletedVectorStoreFileDeleted VectorStoreFileDeleted = "vector_store.file.deleted"

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStoreFileDeleted, err := client.VectorStores.Files.Delete(
    context.TODO(),
    "vector_store_id",
    "file_id",
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStoreFileDeleted.ID)
}

Response

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

Retrieve vector store file content

client.VectorStores.Files.Content(ctx, vectorStoreID, fileID) (*Page[VectorStoreFileContentResponse], error)

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

Retrieve the parsed contents of a vector store file.

Parameters

vectorStoreID string
fileID string

Returns

type VectorStoreFileContentResponse struct{…}
- Text string
  
  The text content
- Type string
  
  The content type (currently only "text")

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  page, err := client.VectorStores.Files.Content(
    context.TODO(),
    "vs_abc123",
    "file-abc123",
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}

Response

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

Domain Types

Vector Store File

type VectorStoreFile struct{…}

A list of files attached to a vector store.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- LastError VectorStoreFileLastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code string
    
    One of server_error, unsupported_file, or invalid_file.
    - const VectorStoreFileLastErrorCodeServerError VectorStoreFileLastErrorCode = "server_error"
    - const VectorStoreFileLastErrorCodeUnsupportedFile VectorStoreFileLastErrorCode = "unsupported_file"
    - const VectorStoreFileLastErrorCodeInvalidFile VectorStoreFileLastErrorCode = "invalid_file"
  - Message string
    
    A human-readable description of the error.
- Object VectorStoreFile
  
  The object type, which is always vector_store.file.
  - const VectorStoreFileVectorStoreFile VectorStoreFile = "vector_store.file"
- Status VectorStoreFileStatus
  
  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.
  - const VectorStoreFileStatusInProgress VectorStoreFileStatus = "in_progress"
  - const VectorStoreFileStatusCompleted VectorStoreFileStatus = "completed"
  - const VectorStoreFileStatusCancelled VectorStoreFileStatus = "cancelled"
  - const VectorStoreFileStatusFailed VectorStoreFileStatus = "failed"
- UsageBytes int64
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- VectorStoreID string
  
  The ID of the vector store that the File is attached to.
- Attributes map[string, VectorStoreFileAttributeUnion]
  
  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
  - float64
  - bool
- ChunkingStrategy FileChunkingStrategyUnion
  
  The strategy used to chunk the file.
  - type StaticFileChunkingStrategyObject struct{…}
    - Static StaticFileChunkingStrategy
      - ChunkOverlapTokens int64
        
        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.
      - MaxChunkSizeTokens int64
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - Type Static
      
      Always static.
      - const StaticStatic Static = "static"
  - type OtherFileChunkingStrategyObject struct{…}
    
    This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the chunking_strategy concept was introduced in the API.
    - Type Other
      
      Always other.
      - const OtherOther Other = "other"

Vector Store File Deleted

type VectorStoreFileDeleted struct{…}
- ID string
- Deleted bool
- Object VectorStoreFileDeleted
  - const VectorStoreFileDeletedVectorStoreFileDeleted VectorStoreFileDeleted = "vector_store.file.deleted"

File Batches

Create vector store file batch

client.VectorStores.FileBatches.New(ctx, vectorStoreID, body) (*VectorStoreFileBatch, error)

post /vector_stores/{vector_store_id}/file_batches

Create a vector store file batch.

Parameters

vectorStoreID string
body VectorStoreFileBatchNewParams
- Attributes param.Field[map[string, VectorStoreFileBatchNewParamsAttributeUnion]]
  
  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
  - float64
  - bool
- ChunkingStrategy param.Field[FileChunkingStrategyParamUnionResp]
  
  The chunking strategy used to chunk the file(s). If not set, will use the auto strategy. Only applicable if file_ids is non-empty.
- FileIDs param.Field[[]string]
  
  A list of File IDs that the vector store should use. Useful for tools like file_search that can access files. If attributes or chunking_strategy are provided, they will be applied to all files in the batch. The maximum batch size is 2000 files. This endpoint is recommended for multi-file ingestion and helps reduce per-vector-store write request pressure. Mutually exclusive with files.
- Files param.Field[[]VectorStoreFileBatchNewParamsFile]
  
  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.
  - FileID string
    
    A File ID that the vector store should use. Useful for tools like file_search that can access files. For multi-file ingestion, we recommend file_batches to minimize per-vector-store write requests.
  - Attributes map[string, VectorStoreFileBatchNewParamsFileAttributeUnion]
    
    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
    - float64
    - bool
  - ChunkingStrategy FileChunkingStrategyParamUnionResp
    
    The chunking strategy used to chunk the file(s). If not set, will use the auto strategy. Only applicable if file_ids is non-empty.
    - type AutoFileChunkingStrategyParamResp struct{…}
      
      The default strategy. This strategy currently uses a max_chunk_size_tokens of 800 and chunk_overlap_tokens of 400.
      - Type Auto
        
        Always auto.
        
        const AutoAuto Auto = "auto"
    - type StaticFileChunkingStrategyObjectParamResp struct{…}
      
      Customize your own chunking strategy by setting chunk size and chunk overlap.
      - Static StaticFileChunkingStrategy
        
        ChunkOverlapTokens int64
        
        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.
        
        MaxChunkSizeTokens int64
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
      - Type Static
        
        Always static.
        
        const StaticStatic Static = "static"

Returns

type VectorStoreFileBatch struct{…}

A batch of files attached to a vector store.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- FileCounts VectorStoreFileBatchFileCounts
  - Cancelled int64
    
    The number of files that where cancelled.
  - Completed int64
    
    The number of files that have been processed.
  - Failed int64
    
    The number of files that have failed to process.
  - InProgress int64
    
    The number of files that are currently being processed.
  - Total int64
    
    The total number of files.
- Object VectorStoreFilesBatch
  
  The object type, which is always vector_store.file_batch.
  - const VectorStoreFilesBatchVectorStoreFilesBatch VectorStoreFilesBatch = "vector_store.files_batch"
- Status VectorStoreFileBatchStatus
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - const VectorStoreFileBatchStatusInProgress VectorStoreFileBatchStatus = "in_progress"
  - const VectorStoreFileBatchStatusCompleted VectorStoreFileBatchStatus = "completed"
  - const VectorStoreFileBatchStatusCancelled VectorStoreFileBatchStatus = "cancelled"
  - const VectorStoreFileBatchStatusFailed VectorStoreFileBatchStatus = "failed"
- VectorStoreID string
  
  The ID of the vector store that the File is attached to.

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStoreFileBatch, err := client.VectorStores.FileBatches.New(
    context.TODO(),
    "vs_abc123",
    openai.VectorStoreFileBatchNewParams{

    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStoreFileBatch.ID)
}

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

client.VectorStores.FileBatches.Get(ctx, vectorStoreID, batchID) (*VectorStoreFileBatch, error)

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

Retrieves a vector store file batch.

Parameters

vectorStoreID string
batchID string

Returns

type VectorStoreFileBatch struct{…}

A batch of files attached to a vector store.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- FileCounts VectorStoreFileBatchFileCounts
  - Cancelled int64
    
    The number of files that where cancelled.
  - Completed int64
    
    The number of files that have been processed.
  - Failed int64
    
    The number of files that have failed to process.
  - InProgress int64
    
    The number of files that are currently being processed.
  - Total int64
    
    The total number of files.
- Object VectorStoreFilesBatch
  
  The object type, which is always vector_store.file_batch.
  - const VectorStoreFilesBatchVectorStoreFilesBatch VectorStoreFilesBatch = "vector_store.files_batch"
- Status VectorStoreFileBatchStatus
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - const VectorStoreFileBatchStatusInProgress VectorStoreFileBatchStatus = "in_progress"
  - const VectorStoreFileBatchStatusCompleted VectorStoreFileBatchStatus = "completed"
  - const VectorStoreFileBatchStatusCancelled VectorStoreFileBatchStatus = "cancelled"
  - const VectorStoreFileBatchStatusFailed VectorStoreFileBatchStatus = "failed"
- VectorStoreID string
  
  The ID of the vector store that the File is attached to.

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStoreFileBatch, err := client.VectorStores.FileBatches.Get(
    context.TODO(),
    "vs_abc123",
    "vsfb_abc123",
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStoreFileBatch.ID)
}

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

client.VectorStores.FileBatches.Cancel(ctx, vectorStoreID, batchID) (*VectorStoreFileBatch, error)

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

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

Parameters

vectorStoreID string
batchID string

Returns

type VectorStoreFileBatch struct{…}

A batch of files attached to a vector store.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- FileCounts VectorStoreFileBatchFileCounts
  - Cancelled int64
    
    The number of files that where cancelled.
  - Completed int64
    
    The number of files that have been processed.
  - Failed int64
    
    The number of files that have failed to process.
  - InProgress int64
    
    The number of files that are currently being processed.
  - Total int64
    
    The total number of files.
- Object VectorStoreFilesBatch
  
  The object type, which is always vector_store.file_batch.
  - const VectorStoreFilesBatchVectorStoreFilesBatch VectorStoreFilesBatch = "vector_store.files_batch"
- Status VectorStoreFileBatchStatus
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - const VectorStoreFileBatchStatusInProgress VectorStoreFileBatchStatus = "in_progress"
  - const VectorStoreFileBatchStatusCompleted VectorStoreFileBatchStatus = "completed"
  - const VectorStoreFileBatchStatusCancelled VectorStoreFileBatchStatus = "cancelled"
  - const VectorStoreFileBatchStatusFailed VectorStoreFileBatchStatus = "failed"
- VectorStoreID string
  
  The ID of the vector store that the File is attached to.

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  vectorStoreFileBatch, err := client.VectorStores.FileBatches.Cancel(
    context.TODO(),
    "vector_store_id",
    "batch_id",
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", vectorStoreFileBatch.ID)
}

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

client.VectorStores.FileBatches.ListFiles(ctx, vectorStoreID, batchID, query) (*CursorPage[VectorStoreFile], error)

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

Returns a list of vector store files in a batch.

Parameters

vectorStoreID string
batchID string
query VectorStoreFileBatchListFilesParams
- After param.Field[string]
  
  A cursor for use in pagination. after is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
- Before param.Field[string]
  
  A cursor for use in pagination. before is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.
- Filter param.Field[VectorStoreFileBatchListFilesParamsFilter]
  
  Filter by file status. One of in_progress, completed, failed, cancelled.
  - const VectorStoreFileBatchListFilesParamsFilterInProgress VectorStoreFileBatchListFilesParamsFilter = "in_progress"
  - const VectorStoreFileBatchListFilesParamsFilterCompleted VectorStoreFileBatchListFilesParamsFilter = "completed"
  - const VectorStoreFileBatchListFilesParamsFilterFailed VectorStoreFileBatchListFilesParamsFilter = "failed"
  - const VectorStoreFileBatchListFilesParamsFilterCancelled VectorStoreFileBatchListFilesParamsFilter = "cancelled"
- Limit param.Field[int64]
  
  A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.
- Order param.Field[VectorStoreFileBatchListFilesParamsOrder]
  
  Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
  - const VectorStoreFileBatchListFilesParamsOrderAsc VectorStoreFileBatchListFilesParamsOrder = "asc"
  - const VectorStoreFileBatchListFilesParamsOrderDesc VectorStoreFileBatchListFilesParamsOrder = "desc"

Returns

type VectorStoreFile struct{…}

A list of files attached to a vector store.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store file was created.
- LastError VectorStoreFileLastError
  
  The last error associated with this vector store file. Will be null if there are no errors.
  - Code string
    
    One of server_error, unsupported_file, or invalid_file.
    - const VectorStoreFileLastErrorCodeServerError VectorStoreFileLastErrorCode = "server_error"
    - const VectorStoreFileLastErrorCodeUnsupportedFile VectorStoreFileLastErrorCode = "unsupported_file"
    - const VectorStoreFileLastErrorCodeInvalidFile VectorStoreFileLastErrorCode = "invalid_file"
  - Message string
    
    A human-readable description of the error.
- Object VectorStoreFile
  
  The object type, which is always vector_store.file.
  - const VectorStoreFileVectorStoreFile VectorStoreFile = "vector_store.file"
- Status VectorStoreFileStatus
  
  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.
  - const VectorStoreFileStatusInProgress VectorStoreFileStatus = "in_progress"
  - const VectorStoreFileStatusCompleted VectorStoreFileStatus = "completed"
  - const VectorStoreFileStatusCancelled VectorStoreFileStatus = "cancelled"
  - const VectorStoreFileStatusFailed VectorStoreFileStatus = "failed"
- UsageBytes int64
  
  The total vector store usage in bytes. Note that this may be different from the original file size.
- VectorStoreID string
  
  The ID of the vector store that the File is attached to.
- Attributes map[string, VectorStoreFileAttributeUnion]
  
  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
  - float64
  - bool
- ChunkingStrategy FileChunkingStrategyUnion
  
  The strategy used to chunk the file.
  - type StaticFileChunkingStrategyObject struct{…}
    - Static StaticFileChunkingStrategy
      - ChunkOverlapTokens int64
        
        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.
      - MaxChunkSizeTokens int64
        
        The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
    - Type Static
      
      Always static.
      - const StaticStatic Static = "static"
  - type OtherFileChunkingStrategyObject struct{…}
    
    This is returned when the chunking strategy is unknown. Typically, this is because the file was indexed before the chunking_strategy concept was introduced in the API.
    - Type Other
      
      Always other.
      - const OtherOther Other = "other"

Example

package main

import (
  "context"
  "fmt"

  "github.com/openai/openai-go"
  "github.com/openai/openai-go/option"
)

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  page, err := client.VectorStores.FileBatches.ListFiles(
    context.TODO(),
    "vector_store_id",
    "batch_id",
    openai.VectorStoreFileBatchListFilesParams{

    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}

Response

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

Domain Types

Vector Store File Batch

type VectorStoreFileBatch struct{…}

A batch of files attached to a vector store.
- ID string
  
  The identifier, which can be referenced in API endpoints.
- CreatedAt int64
  
  The Unix timestamp (in seconds) for when the vector store files batch was created.
- FileCounts VectorStoreFileBatchFileCounts
  - Cancelled int64
    
    The number of files that where cancelled.
  - Completed int64
    
    The number of files that have been processed.
  - Failed int64
    
    The number of files that have failed to process.
  - InProgress int64
    
    The number of files that are currently being processed.
  - Total int64
    
    The total number of files.
- Object VectorStoreFilesBatch
  
  The object type, which is always vector_store.file_batch.
  - const VectorStoreFilesBatchVectorStoreFilesBatch VectorStoreFilesBatch = "vector_store.files_batch"
- Status VectorStoreFileBatchStatus
  
  The status of the vector store files batch, which can be either in_progress, completed, cancelled or failed.
  - const VectorStoreFileBatchStatusInProgress VectorStoreFileBatchStatus = "in_progress"
  - const VectorStoreFileBatchStatusCompleted VectorStoreFileBatchStatus = "completed"
  - const VectorStoreFileBatchStatusCancelled VectorStoreFileBatchStatus = "cancelled"
  - const VectorStoreFileBatchStatusFailed VectorStoreFileBatchStatus = "failed"
- VectorStoreID string
  
  The ID of the vector store that the File is attached to.

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

6 6

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

8 8

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

10 10

11### Parameters11### Parameters

12 12

193 193

194**post** `/vector_stores`194**post** `/vector_stores`

195 195

196Create vector store196Create a vector store.

197 197

198### Parameters198### Parameters

199 199

200- `body VectorStoreNewParams`200- `body VectorStoreNewParams`

201 201

202 - `ChunkingStrategy param.Field[any]`202 - `ChunkingStrategy param.Field[FileChunkingStrategyParamUnionResp]`

203

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

203 205

204 - `Description param.Field[string]`206 - `Description param.Field[string]`

205 207

389 391

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

391 393

392Retrieve vector store394Retrieves a vector store.

393 395

394### Parameters396### Parameters

395 397

546 548

547**post** `/vector_stores/{vector_store_id}`549**post** `/vector_stores/{vector_store_id}`

548 550

549Modify vector store551Modifies a vector store.

550 552

551### Parameters553### Parameters

552 554

738 740

739**delete** `/vector_stores/{vector_store_id}`741**delete** `/vector_stores/{vector_store_id}`

740 742

741Delete vector store743Delete a vector store.

742 744

743### Parameters745### Parameters

744 746

797 799

798**post** `/vector_stores/{vector_store_id}/search`800**post** `/vector_stores/{vector_store_id}/search`

799 801

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

801 803

802### Parameters804### Parameters

803 805

864 866

865 - `bool`867 - `bool`

866 868

867 - `type ComparisonFilterValueArray []any`869 - `type ComparisonFilterValueArray []ComparisonFilterValueArrayItemUnion`

870

871 - `string`

872

873 - `float64`

868 874

869 - `type CompoundFilter struct{…}`875 - `type CompoundFilter struct{…}`

870 876

1032 1038

1033### File Chunking Strategy1039### File Chunking Strategy

1034 1040

1035- `type FileChunkingStrategy interface{…}`1041- `type FileChunkingStrategyUnion interface{…}`

1042

1043 The strategy used to chunk the file.

1044

1045 - `type StaticFileChunkingStrategyObject struct{…}`

1046

1047 - `Static StaticFileChunkingStrategy`

1048

1049 - `ChunkOverlapTokens int64`

1050

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

1052

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

1054

1055 - `MaxChunkSizeTokens int64`

1056

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

1058

1059 - `Type Static`

1060

1061 Always `static`.

1062

1063 - `const StaticStatic Static = "static"`

1064

1065 - `type OtherFileChunkingStrategyObject struct{…}`

1066

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

1068

1069 - `Type Other`

1070

1071 Always `other`.

1072

1073 - `const OtherOther Other = "other"`

1036 1074

1037### File Chunking Strategy Param1075### File Chunking Strategy Param

1038 1076

1039- `type FileChunkingStrategyParam interface{…}`1077- `type FileChunkingStrategyParamUnionResp interface{…}`

1078

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

1080

1081 - `type AutoFileChunkingStrategyParamResp struct{…}`

1082

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

1084

1085 - `Type Auto`

1086

1087 Always `auto`.

1088

1089 - `const AutoAuto Auto = "auto"`

1090

1091 - `type StaticFileChunkingStrategyObjectParamResp struct{…}`

1092

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

1094

1095 - `Static StaticFileChunkingStrategy`

1096

1097 - `ChunkOverlapTokens int64`

1098

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

1100

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

1102

1103 - `MaxChunkSizeTokens int64`

1104

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

1106

1107 - `Type Static`

1108

1109 Always `static`.

1110

1111 - `const StaticStatic Static = "static"`

1040 1112

1041### Other File Chunking Strategy Object1113### Other File Chunking Strategy Object

1042 1114

1221 1293

1222**get** `/vector_stores/{vector_store_id}/files`1294**get** `/vector_stores/{vector_store_id}/files`

1223 1295

1224List vector store files1296Returns a list of vector store files.

1225 1297

1226### Parameters1298### Parameters

1227 1299

1333 1405

1334 - `bool`1406 - `bool`

1335 1407

1336 - `ChunkingStrategy any`1408 - `ChunkingStrategy FileChunkingStrategyUnion`

1409

1410 The strategy used to chunk the file.

1411

1412 - `type StaticFileChunkingStrategyObject struct{…}`

1413

1414 - `Static StaticFileChunkingStrategy`

1415

1416 - `ChunkOverlapTokens int64`

1417

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

1419

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

1421

1422 - `MaxChunkSizeTokens int64`

1423

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

1425

1426 - `Type Static`

1427

1428 Always `static`.

1429

1430 - `const StaticStatic Static = "static"`

1431

1432 - `type OtherFileChunkingStrategyObject struct{…}`

1433

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

1435

1436 - `Type Other`

1437

1438 Always `other`.

1439

1440 - `const OtherOther Other = "other"`

1337 1441

1338### Example1442### Example

1339 1443

1385 "attributes": {1489 "attributes": {

1386 "foo": "string"1490 "foo": "string"

1387 },1491 },

1388 "chunking_strategy": {}1492 "chunking_strategy": {

1493 "static": {

1494 "chunk_overlap_tokens": 0,

1495 "max_chunk_size_tokens": 100

1496 },

1497 "type": "static"

1498 }

1389 }1499 }

1390 ],1500 ],

1391 "first_id": "file-abc123",1501 "first_id": "file-abc123",

1401 1511

1402**post** `/vector_stores/{vector_store_id}/files`1512**post** `/vector_stores/{vector_store_id}/files`

1403 1513

1404Create vector store file1514Create a vector store file by attaching a [File](https://platform.openai.com/docs/api-reference/files) to a [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object).

1405 1515

1406### Parameters1516### Parameters

1407 1517

1427 1537

1428 - `bool`1538 - `bool`

1429 1539

1430 - `ChunkingStrategy param.Field[any]`1540 - `ChunkingStrategy param.Field[FileChunkingStrategyParamUnionResp]`

1541

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

1431 1543

1432### Returns1544### Returns

1433 1545

1501 1613

1502 - `bool`1614 - `bool`

1503 1615

1504 - `ChunkingStrategy any`1616 - `ChunkingStrategy FileChunkingStrategyUnion`

1617

1618 The strategy used to chunk the file.

1619

1620 - `type StaticFileChunkingStrategyObject struct{…}`

1621

1622 - `Static StaticFileChunkingStrategy`

1623

1624 - `ChunkOverlapTokens int64`

1625

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

1627

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

1629

1630 - `MaxChunkSizeTokens int64`

1631

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

1633

1634 - `Type Static`

1635

1636 Always `static`.

1637

1638 - `const StaticStatic Static = "static"`

1639

1640 - `type OtherFileChunkingStrategyObject struct{…}`

1641

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

1643

1644 - `Type Other`

1645

1646 Always `other`.

1647

1648 - `const OtherOther Other = "other"`

1505 1649

1506### Example1650### Example

1507 1651

1551 "attributes": {1695 "attributes": {

1552 "foo": "string"1696 "foo": "string"

1553 },1697 },

1554 "chunking_strategy": {}1698 "chunking_strategy": {

1699 "static": {

1700 "chunk_overlap_tokens": 0,

1701 "max_chunk_size_tokens": 100

1702 },

1703 "type": "static"

1704 }

1555}1705}

1556```1706```

1557 1707

1561 1711

1562**post** `/vector_stores/{vector_store_id}/files/{file_id}`1712**post** `/vector_stores/{vector_store_id}/files/{file_id}`

1563 1713

1564Update vector store file attributes1714Update attributes on a vector store file.

1565 1715

1566### Parameters1716### Parameters

1567 1717

1657 1807

1658 - `bool`1808 - `bool`

1659 1809

1660 - `ChunkingStrategy any`1810 - `ChunkingStrategy FileChunkingStrategyUnion`

1811

1812 The strategy used to chunk the file.

1813

1814 - `type StaticFileChunkingStrategyObject struct{…}`

1815

1816 - `Static StaticFileChunkingStrategy`

1817

1818 - `ChunkOverlapTokens int64`

1819

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

1821

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

1823

1824 - `MaxChunkSizeTokens int64`

1825

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

1827

1828 - `Type Static`

1829

1830 Always `static`.

1831

1832 - `const StaticStatic Static = "static"`

1833

1834 - `type OtherFileChunkingStrategyObject struct{…}`

1835

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

1837

1838 - `Type Other`

1839

1840 Always `other`.

1841

1842 - `const OtherOther Other = "other"`

1661 1843

1662### Example1844### Example

1663 1845

1712 "attributes": {1894 "attributes": {

1713 "foo": "string"1895 "foo": "string"

1714 },1896 },

1715 "chunking_strategy": {}1897 "chunking_strategy": {

1898 "static": {

1899 "chunk_overlap_tokens": 0,

1900 "max_chunk_size_tokens": 100

1901 },

1902 "type": "static"

1903 }

1716}1904}

1717```1905```

1718 1906

1722 1910

1723**get** `/vector_stores/{vector_store_id}/files/{file_id}`1911**get** `/vector_stores/{vector_store_id}/files/{file_id}`

1724 1912

1725Retrieve vector store file1913Retrieves a vector store file.

1726 1914

1727### Parameters1915### Parameters

1728 1916

1802 1990

1803 - `bool`1991 - `bool`

1804 1992

1805 - `ChunkingStrategy any`1993 - `ChunkingStrategy FileChunkingStrategyUnion`

1994

1995 The strategy used to chunk the file.

1996

1997 - `type StaticFileChunkingStrategyObject struct{…}`

1998

1999 - `Static StaticFileChunkingStrategy`

2000

2001 - `ChunkOverlapTokens int64`

2002

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

2004

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

2006

2007 - `MaxChunkSizeTokens int64`

2008

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

2010

2011 - `Type Static`

2012

2013 Always `static`.

2014

2015 - `const StaticStatic Static = "static"`

2016

2017 - `type OtherFileChunkingStrategyObject struct{…}`

2018

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

2020

2021 - `Type Other`

2022

2023 Always `other`.

2024

2025 - `const OtherOther Other = "other"`

1806 2026

1807### Example2027### Example

1808 2028

1850 "attributes": {2070 "attributes": {

1851 "foo": "string"2071 "foo": "string"

1852 },2072 },

1853 "chunking_strategy": {}2073 "chunking_strategy": {

2074 "static": {

2075 "chunk_overlap_tokens": 0,

2076 "max_chunk_size_tokens": 100

2077 },

2078 "type": "static"

2079 }

1854}2080}

1855```2081```

1856 2082

1860 2086

1861**delete** `/vector_stores/{vector_store_id}/files/{file_id}`2087**delete** `/vector_stores/{vector_store_id}/files/{file_id}`

1862 2088

1863Delete vector store file2089Delete a vector store file. This will remove the file from the vector store but the file itself will not be deleted. To delete the file, use the [delete file](https://platform.openai.com/docs/api-reference/files/delete) endpoint.

1864 2090

1865### Parameters2091### Parameters

1866 2092

1925 2151

1926**get** `/vector_stores/{vector_store_id}/files/{file_id}/content`2152**get** `/vector_stores/{vector_store_id}/files/{file_id}/content`

1927 2153

1928Retrieve vector store file content2154Retrieve the parsed contents of a vector store file.

1929 2155

1930### Parameters2156### Parameters

1931 2157

2064 2290

2065 - `bool`2291 - `bool`

2066 2292

2067 - `ChunkingStrategy any`2293 - `ChunkingStrategy FileChunkingStrategyUnion`

2294

2295 The strategy used to chunk the file.

2296

2297 - `type StaticFileChunkingStrategyObject struct{…}`

2298

2299 - `Static StaticFileChunkingStrategy`

2300

2301 - `ChunkOverlapTokens int64`

2302

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

2304

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

2306

2307 - `MaxChunkSizeTokens int64`

2308

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

2310

2311 - `Type Static`

2312

2313 Always `static`.

2314

2315 - `const StaticStatic Static = "static"`

2316

2317 - `type OtherFileChunkingStrategyObject struct{…}`

2318

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

2320

2321 - `Type Other`

2322

2323 Always `other`.

2324

2325 - `const OtherOther Other = "other"`

2068 2326

2069### Vector Store File Deleted2327### Vector Store File Deleted

2070 2328

2086 2344

2087**post** `/vector_stores/{vector_store_id}/file_batches`2345**post** `/vector_stores/{vector_store_id}/file_batches`

2088 2346

2089Create vector store file batch2347Create a vector store file batch.

2090 2348

2091### Parameters2349### Parameters

2092 2350

2108 2366

2109 - `bool`2367 - `bool`

2110 2368

2111 - `ChunkingStrategy param.Field[any]`2369 - `ChunkingStrategy param.Field[FileChunkingStrategyParamUnionResp]`

2370

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

2112 2372

2113 - `FileIDs param.Field[[]string]`2373 - `FileIDs param.Field[[]string]`

2114 2374

2136 2396

2137 - `bool`2397 - `bool`

2138 2398

2139 - `ChunkingStrategy any`2399 - `ChunkingStrategy FileChunkingStrategyParamUnionResp`

2400

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

2402

2403 - `type AutoFileChunkingStrategyParamResp struct{…}`

2404

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

2406

2407 - `Type Auto`

2408

2409 Always `auto`.

2410

2411 - `const AutoAuto Auto = "auto"`

2412

2413 - `type StaticFileChunkingStrategyObjectParamResp struct{…}`

2414

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

2416

2417 - `Static StaticFileChunkingStrategy`

2418

2419 - `ChunkOverlapTokens int64`

2420

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

2422

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

2424

2425 - `MaxChunkSizeTokens int64`

2426

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

2428

2429 - `Type Static`

2430

2431 Always `static`.

2432

2433 - `const StaticStatic Static = "static"`

2140 2434

2141### Returns2435### Returns

2142 2436

2252 2546

2253**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}`2547**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}`

2254 2548

2255Retrieve vector store file batch2549Retrieves a vector store file batch.

2256 2550

2257### Parameters2551### Parameters

2258 2552

2372 2666

2373**post** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/cancel`2667**post** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/cancel`

2374 2668

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

2376 2670

2377### Parameters2671### Parameters

2378 2672

2492 2786

2493**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/files`2787**get** `/vector_stores/{vector_store_id}/file_batches/{batch_id}/files`

2494 2788

2495List vector store files in a batch2789Returns a list of vector store files in a batch.

2496 2790

2497### Parameters2791### Parameters

2498 2792

2606 2900

2607 - `bool`2901 - `bool`

2608 2902

2609 - `ChunkingStrategy any`2903 - `ChunkingStrategy FileChunkingStrategyUnion`

2904

2905 The strategy used to chunk the file.

2906

2907 - `type StaticFileChunkingStrategyObject struct{…}`

2908

2909 - `Static StaticFileChunkingStrategy`

2910

2911 - `ChunkOverlapTokens int64`

2912

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

2914

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

2916

2917 - `MaxChunkSizeTokens int64`

2918

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

2920

2921 - `Type Static`

2922

2923 Always `static`.

2924

2925 - `const StaticStatic Static = "static"`

2926

2927 - `type OtherFileChunkingStrategyObject struct{…}`

2928

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

2930

2931 - `Type Other`

2932

2933 Always `other`.

2934

2935 - `const OtherOther Other = "other"`

2610 2936

2611### Example2937### Example

2612 2938

2659 "attributes": {2985 "attributes": {

2660 "foo": "string"2986 "foo": "string"

2661 },2987 },

2662 "chunking_strategy": {}2988 "chunking_strategy": {

2989 "static": {

2990 "chunk_overlap_tokens": 0,

2991 "max_chunk_size_tokens": 100

2992 },

2993 "type": "static"

2994 }

2663 }2995 }

2664 ],2996 ],

2665 "first_id": "file-abc123",2997 "first_id": "file-abc123",

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

Vector Stores

List vector stores

Parameters

Returns

Example

Response

Create vector store

Parameters

Returns

Example

Response

Retrieve vector store

Parameters

Returns

Example

Response

Modify vector store

Parameters

Returns

Example

Response

Delete vector store

Parameters

Returns

Example

Response

Search vector store

Parameters

Returns

Example

Response

Domain Types

Auto File Chunking Strategy Param

File Chunking Strategy

File Chunking Strategy Param

Other File Chunking Strategy Object

Static File Chunking Strategy

Static File Chunking Strategy Object

Static File Chunking Strategy Object Param

Vector Store

Vector Store Deleted

Files

List vector store files

Parameters

Returns

Example

Response

Create vector store file

Parameters

Returns

Example

Response

Update vector store file attributes

Parameters

Returns

Example

Response

Retrieve vector store file

Parameters

Returns

Example

Response

Delete vector store file

Parameters

Returns

Example

Response

Retrieve vector store file content

Parameters

Returns

Example

Response

Domain Types

Vector Store File

Vector Store File Deleted

File Batches

Create vector store file batch

Parameters

Returns