{
  "openapi": "3.0.3",
  "info": {
    "title": "Pinecone API",
    "version": "version not set",
    "contact": {
      "name": "Pinecone.io Ops",
      "url": "https://pinecone.io",
      "email": "support@pinecone.io"
    }
  },
  "x-readme": {
    "explorer-enabled": true,
    "proxy-enabled": false,
    "samples-languages": [
      "curl",
      "python",
      "http",
      "node"
    ],
    "samples-enabled": true
  },
  "servers": [
    {
      "url": "https://controller.{environment}.pinecone.io",
      "variables": {
        "environment": {
          "default": "us-east1-gcp",
          "description": "The cloud region for your project. See the Pinecone console > API keys."
        }
      }
    }
  ],
  "externalDocs": {
    "description": "More Pinecone.io API docs",
    "url": "https://www.pinecone.io/docs"
  },
  "security": [
    {
      "ApiKeyAuth": []
    }
  ],
  "tags": [
    {
      "name": "Vector Operations"
    },
    {
      "name": "Index Operations"
    }
  ],
  "paths": {
    "/collections": {
      "get": {
        "summary": "list_collections",
        "operationId": "list_collections",
        "description": "This operation returns a list of your Pinecone collections.",
        "responses": {
          "200": {
            "description": "This operation returns a list of all the collections in your current project.",
            "content": {
              "application/json; charset=utf-8": {
                "schema": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  }
                }
              }
            }
          }
        },
        "tags": [
          "Index Operations"
        ],
        "x-readme": {
          "code-samples": [
            {
              "language": "python",
              "code": "import pinecone \n\npinecone.init(api_key='YOUR_API_KEY', environment='us-east1-gcp') \n\nactive_collections = pinecone.list_collections()"
            },
            {
              "language": "node",
              "code": "const client = new PineconeClient(); \n\nawait client.init{( \n  apiKey: 'YOUR_API_KEY', \n  environment: 'us_east1-gcp', \n\n}); \n\nconst list = await client.listCollections().data;"
            }
          ]
        }
      },
      "post": {
        "summary": "create_collection",
        "operationId": "create_collection",
        "description": "This operation creates a Pinecone collection.",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/createCollectionRequest"
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "The collection has been successfully created.",
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            }
          },
          "400": {
            "description": "Bad request. Request exceeds quota or collection name is invalid."
          },
          "409": {
            "description": "A collection with the name provided already exists."
          },
          "500": {
            "description": "Internal error. Can be caused by invalid parameters."
          }
        },
        "tags": [
          "Index Operations"
        ],
        "x-readme": {
          "code-samples": [
            {
              "language": "python",
              "code": "import pinecone \n\npinecone.init(api_key='YOUR_API_KEY', environment='us-east1-gcp') \n\npinecone.create_collection('example-collection', 'example-index')"
            },
            {
              "language": "node",
              "code": "const client = new PineconeClient(); \n\nawait client.init{( \n  apiKey: 'YOUR_API_KEY', \n  environment: 'us_east1-gcp', \n\n}); \n\nawait client.createCollection('example-collection');"
            }
          ]
        }
      },
      "servers": [
        {
          "url": "https://controller.{environment}.pinecone.io",
          "variables": {
            "environment": {
              "default": "us-east1-gcp",
              "description": "The cloud region for your project. See the Pinecone console > API keys."
            }
          }
        }
      ]
    },
    "/collections/{collectionName}": {
      "get": {
        "summary": "describe_collection",
        "operationId": "describe_collection",
        "description": "Get a description of a collection.",
        "parameters": [
          {
            "name": "collectionName",
            "required": true,
            "in": "path",
            "description": "The name of the collection",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Configuration information and deployment status of the index",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "$ref": "#/components/schemas/collectionMeta"
                }
              }
            }
          },
          "404": {
            "description": "Index not found."
          },
          "500": {
            "description": "Internal error. Can be caused by invalid parameters."
          }
        },
        "tags": [
          "Index Operations"
        ],
        "x-readme": {
          "code-samples": [
            {
              "language": "python",
              "code": "import pinecone \n\npinecone.init(api_key='YOUR_API_KEY', environment='us-east1-gcp') \n\ncollection_description = pinecone.describe_collection('example-collection')"
            },
            {
              "language": "node",
              "code": "const client = new PineconeClient(); \n\nawait client.init{( \n  apiKey: 'YOUR_API_KEY', \n  environment: 'us_east1-gcp', \n\n}); \n\nconst description = await client.describeCollection('example-collection').data;"
            }
          ]
        }
      },
      "delete": {
        "summary": "delete_collection",
        "operationId": "delete_collection",
        "description": "This operation deletes an existing collection.",
        "parameters": [
          {
            "name": "collectionName",
            "required": true,
            "in": "path",
            "schema": {
              "type": "string"
            },
            "description": "The name of the collection"
          }
        ],
        "responses": {
          "202": {
            "description": "The index has been successfully deleted.",
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            }
          },
          "404": {
            "description": "Collection not found."
          },
          "500": {
            "description": "Internal error. Can be caused by invalid parameters."
          }
        },
        "tags": [
          "Index Operations"
        ],
        "x-readme": {
          "code-samples": [
            {
              "language": "python",
              "code": "import pinecone \n\npinecone.init(api_key='YOUR_API_KEY', environment='us-east1-gcp') \n\npinecone.delete_collection('example-collection')"
            },
            {
              "language": "node",
              "code": "const client = new PineconeClient(); \n\nawait client.init{( \n  apiKey: 'YOUR_API_KEY', \n  environment: 'us_east1-gcp', \n\n}); \n\nawait client.deleteCollection('example-collection');"
            }
          ]
        }
      },
      "servers": [
        {
          "url": "https://controller.{environment}.pinecone.io",
          "variables": {
            "environment": {
              "default": "us-east1-gcp",
              "description": "The cloud region for your project. See the Pinecone console > API keys."
            }
          }
        }
      ]
    },
    "/databases": {
      "get": {
        "summary": "list_indexes",
        "operationId": "list_indexes",
        "description": "This operation returns a list of your Pinecone indexes.",
        "responses": {
          "200": {
            "description": "This operation returns a list of all the indexes that you have previously created, and which are associated with the given API key",
            "content": {
              "application/json; charset=utf-8": {
                "schema": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  }
                }
              }
            }
          }
        },
        "tags": [
          "Index Operations"
        ],
        "x-readme": {
          "code-samples": [
            {
              "language": "python",
              "code": "import pinecone \n\npinecone.init(api_key='YOUR_API_KEY', environment='us-east1-gcp') \n\nactive_indexes = pinecone.list_indexes()"
            },
            {
              "language": "node",
              "code": "const client = new PineconeClient(); \n\nawait client.init{( \n  apiKey: 'YOUR_API_KEY', \n  environment: 'us_east1-gcp', \n}); \n\nconst list = await client.listIndexes().data;"
            }
          ]
        }
      },
      "post": {
        "summary": "create_index",
        "operationId": "create_index",
        "description": "This operation creates a Pinecone index. You can use it to specify the measure of similarity, the dimension of vectors to be stored in the index, the numbers of replicas to use, and more.",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/createRequest"
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "The index has been successfully created",
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            }
          },
          "400": {
            "description": "Bad request. Encountered when request exceeds quota or an invalid index name."
          },
          "409": {
            "description": "Index of given name already exists."
          },
          "500": {
            "description": "Internal error. Can be caused by invalid parameters."
          }
        },
        "tags": [
          "Index Operations"
        ],
        "x-readme": {
          "code-samples": [
            {
              "language": "python",
              "code": "import pinecone \n\npinecone.init(api_key='YOUR_API_KEY', environment='us-east1-gcp') \n\n## The following example creates an index without a metadata\n## configuration. By default, Pinecone indexes all metadata.\n\npinecone.create_index('example-index', dimension=1024)\n\n## The following example creates an index that only indexes\n## the 'color' metadata field. Queries against this index\n## cannot filter based on any other metadata field.\n\nmetadata_config = {\n    'indexed': ['color']\n}\n\npinecone.create_index('example-index-2', dimension=1024,\n                      metadata_config=metadata_config)"
            },
            {
              "language": "node",
              "code": "const client = new PineconeClient(); \n\nawait client.init{( \n  apiKey: 'YOUR_API_KEY', \n  environment: 'us_east1-gcp', \n\n}); \n\nconst list = await client.createIndex('example-index', 3, 'cosine');"
            }
          ]
        }
      },
      "servers": [
        {
          "url": "https://controller.{environment}.pinecone.io",
          "variables": {
            "environment": {
              "default": "us-east1-gcp",
              "description": "The cloud region for your project. See the Pinecone console > API keys."
            }
          }
        }
      ]
    },
    "/databases/{indexName}": {
      "get": {
        "summary": "describe_index",
        "operationId": "describe_index",
        "description": "Get a description of an index.",
        "parameters": [
          {
            "name": "indexName",
            "required": true,
            "in": "path",
            "description": "The name of the index",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Configuration information and deployment status of the index",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "$ref": "#/components/schemas/indexMeta"
                }
              }
            }
          },
          "404": {
            "description": "Index not found"
          },
          "500": {
            "description": "Internal error. Can be caused by invalid parameters."
          }
        },
        "tags": [
          "Index Operations"
        ],
        "x-readme": {
          "code-samples": [
            {
              "language": "python",
              "code": "import pinecone \n\npinecone.init(api_key='YOUR_API_KEY', environment='us-east1-gcp') \n\nindex_description = pinecone.describe_index('example-index')"
            },
            {
              "language": "node",
              "code": "const client = new PineconeClient(); \n\nawait client.init{( \n  apiKey: 'YOUR_API_KEY', \n  environment: 'us_east1-gcp', \n}); \n\nconst indexDescription = await client.describeIndex('example-index');"
            }
          ]
        }
      },
      "delete": {
        "summary": "delete_index",
        "operationId": "delete_index",
        "description": "This operation deletes an existing index.",
        "parameters": [
          {
            "name": "indexName",
            "required": true,
            "in": "path",
            "schema": {
              "type": "string"
            },
            "description": "The name of the index"
          }
        ],
        "responses": {
          "202": {
            "description": "The index has been successfully deleted.",
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            }
          },
          "404": {
            "description": "Index not found."
          },
          "500": {
            "description": "Internal error. Can be caused by invalid parameters."
          }
        },
        "tags": [
          "Index Operations"
        ],
        "x-readme": {
          "code-samples": [
            {
              "language": "python",
              "code": "import pinecone\n\npinecone.init(api_key='YOUR_API_KEY', environment='us-east1-gcp') \n\npinecone.delete_index('example-index')"
            },
            {
              "language": "node",
              "code": "const client = new PineconeClient(); \n\nawait client.init{( \n  apiKey: 'YOUR_API_KEY', \n  environment: 'us_east1-gcp', \n\n}); \n\nawait client.deleteIndex('example-index');"
            }
          ]
        }
      },
      "patch": {
        "summary": "configure_index",
        "operationId": "configure_index",
        "description": "This operation specifies the pod type and number of replicas for an index.",
        "parameters": [
          {
            "name": "indexName",
            "required": true,
            "in": "path",
            "schema": {
              "type": "string"
            },
            "description": "The name of the index"
          }
        ],
        "requestBody": {
          "description": "The desired pod type and replica configuration for the index.",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/patchRequest"
              }
            }
          }
        },
        "responses": {
          "202": {
            "description": "The index has been successfully updated",
            "content": {
              "text/plain": {
                "schema": {
                  "type": "string"
                }
              }
            }
          },
          "400": {
            "description": "Bad request,not enough quota."
          },
          "404": {
            "description": "Index not found."
          },
          "500": {
            "description": "Internal error. Can be caused by invalid parameters."
          }
        },
        "tags": [
          "Index Operations"
        ],
        "x-readme": {
          "code-samples": [
            {
              "language": "python",
              "code": "import pinecone \n\npinecone.init(api_key='YOUR_API_KEY', environment='us-east1-gcp') \n\nnew_number_of_replicas = 4\npinecone.configure_index('example-index', replicas=new_number_of_replicas)"
            },
            {
              "language": "node",
              "code": "const client = new PineconeClient(); \n\nawait client.init{( \n  apiKey: 'YOUR_API_KEY', \n  environment: 'us_east1-gcp', \n\n}); \n\nconst patchRequest = {\n    replicas: 2,\n    pod_type: 'p2.x1'\n}\n\nclient.configureIndex(indexName, patchRequest)"
            }
          ]
        }
      },
      "servers": [
        {
          "url": "https://controller.{environment}.pinecone.io",
          "variables": {
            "environment": {
              "default": "us-east1-gcp",
              "description": "The cloud region for your project. See the Pinecone console > API keys."
            }
          }
        }
      ]
    }
  },
  "components": {
    "schemas": {
      "DeleteRequest": {
        "type": "object",
        "properties": {
          "ids": {
            "type": "array",
            "example": [
              "id-0",
              "id-1"
            ],
            "items": {
              "type": "string"
            },
            "description": "Vectors to delete.",
            "maxLength": 1000,
            "minLength": 1
          },
          "deleteAll": {
            "type": "boolean",
            "example": false,
            "default": "false",
            "description": "This indicates that all vectors in the index namespace should be deleted."
          },
          "namespace": {
            "type": "string",
            "example": "example-namespace",
            "description": "The namespace to delete vectors from, if applicable."
          },
          "filter": {
            "type": "object",
            "description": "If specified, the metadata filter here will be used to select the vectors to delete. This is mutually exclusive\nwith specifying ids to delete in the ids param or using delete_all=True.\nSee https://www.pinecone.io/docs/metadata-filtering/."
          }
        },
        "description": "The request for the `Delete` operation."
      },
      "DeleteResponse": {
        "type": "object",
        "description": "The response for the `Delete` operation."
      },
      "DescribeIndexStatsRequest": {
        "type": "object",
        "properties": {
          "filter": {
            "type": "object",
            "description": "If this parameter is present, the operation only returns statistics\nfor vectors that satisfy the filter.\nSee https://www.pinecone.io/docs/metadata-filtering/."
          }
        },
        "description": "The request for the `DescribeIndexStats` operation."
      },
      "DescribeIndexStatsResponse": {
        "type": "object",
        "example": {
          "namespaces": {
            "": {
              "vectorCount": 50000
            },
            "example-namespace-2": {
              "vectorCount": 30000
            }
          },
          "dimension": 1024,
          "index_fullness": 0.4
        },
        "properties": {
          "namespaces": {
            "type": "object",
            "additionalProperties": {
              "$ref": "#/components/schemas/NamespaceSummary"
            },
            "description": "A mapping for each namespace in the index from the namespace name to a\nsummary of its contents. If a metadata filter expression is present, the\nsummary will reflect only vectors matching that expression."
          },
          "dimension": {
            "type": "integer",
            "format": "int64",
            "example": 1024,
            "description": "The dimension of the indexed vectors."
          },
          "indexFullness": {
            "type": "number",
            "format": "float",
            "example": 0.4,
            "description": "The fullness of the index, regardless of whether a metadata filter expression was passed. The granularity of this metric is 10%."
          },
          "totalVectorCount": {
            "type": "integer",
            "format": "int64",
            "example": 80000,
            "title": "The total number of vectors in the index, regardless of whether a metadata filter expression was passed"
          }
        },
        "description": "The response for the `DescribeIndexStats` operation."
      },
      "FetchResponse": {
        "type": "object",
        "properties": {
          "vectors": {
            "type": "object",
            "additionalProperties": {
              "$ref": "#/components/schemas/Vector"
            },
            "title": "The fetched vectors, in the form of a map between the fetched ids and the fetched vectors"
          },
          "namespace": {
            "type": "string",
            "example": "example-namespace",
            "description": "The namespace of the vectors."
          }
        },
        "description": "The response for the `Fetch` operation."
      },
      "NamespaceSummary": {
        "type": "object",
        "properties": {
          "vectorCount": {
            "type": "integer",
            "format": "int64",
            "example": 50000,
            "description": "The number of vectors stored in this namespace. Note that updates to this field may lag behind updates to the\nunderlying index and corresponding query results, etc."
          }
        },
        "description": "A summary of the contents of a namespace."
      },
      "QueryRequest": {
        "type": "object",
        "properties": {
          "namespace": {
            "type": "string",
            "example": "example-namespace",
            "description": "The namespace to query."
          },
          "topK": {
            "type": "integer",
            "format": "int64",
            "example": 10,
            "description": "The number of results to return for each query.",
            "maximum": 10000,
            "minimum": 1,
            "required": [
              "top_k"
            ]
          },
          "filter": {
            "type": "object",
            "example": {
              "genre": {
                "$in": [
                  "comedy",
                  "documentary",
                  "drama"
                ]
              },
              "year": {
                "$eq": 2019
              }
            },
            "description": "The filter to apply. You can use vector metadata to limit your search. See https://www.pinecone.io/docs/metadata-filtering/."
          },
          "includeValues": {
            "type": "boolean",
            "example": true,
            "default": "false",
            "description": "Indicates whether vector values are included in the response."
          },
          "includeMetadata": {
            "type": "boolean",
            "example": true,
            "default": "false",
            "description": "Indicates whether metadata is included in the response as well as the ids."
          },
          "queries": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/QueryVector"
            },
            "description": "DEPRECATED. The query vectors. Each `query()` request can contain only one of the parameters `queries`, `vector`, or  `id`.",
            "maxLength": 10,
            "minLength": 1,
            "deprecated": true
          },
          "vector": {
            "type": "array",
            "example": [
              0.1,
              0.2,
              0.3,
              0.4,
              0.5,
              0.6,
              0.7,
              0.8
            ],
            "items": {
              "type": "number",
              "format": "float"
            },
            "description": "The query vector. This should be the same length as the dimension of the index being queried. Each `query()` request can contain only one of the parameters `id` or `vector`.",
            "maxLength": 20000,
            "minLength": 1
          },
          "sparseVector": {
            "$ref": "#/components/schemas/SparseValues"
          },
          "id": {
            "type": "string",
            "example": "example-vector-1",
            "description": "The unique ID of the vector to be used as a query vector. Each `query()` request can contain only one of the parameters `queries`, `vector`, or  `id`.",
            "maxLength": 512
          }
        },
        "description": "The request for the `Query` operation.",
        "required": [
          "topK"
        ]
      },
      "QueryResponse": {
        "type": "object",
        "properties": {
          "matches": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ScoredVector"
            },
            "description": "The matches for the vectors."
          },
          "namespace": {
            "type": "string",
            "description": "The namespace for the vectors."
          }
        },
        "description": "The response for the `Query` operation. These are the matches found for a particular query vector. The matches are ordered from most similar to least similar."
      },
      "QueryVector": {
        "type": "object",
        "properties": {
          "values": {
            "type": "array",
            "example": [
              0.1,
              0.2,
              0.3,
              0.4,
              0.5,
              0.6,
              0.7,
              0.8
            ],
            "items": {
              "type": "number",
              "format": "float"
            },
            "description": "The query vector values. This should be the same length as the dimension of the index being queried.",
            "maxLength": 20000,
            "minLength": 1,
            "required": [
              "values"
            ]
          },
          "sparseValues": {
            "$ref": "#/components/schemas/SparseValues"
          },
          "topK": {
            "type": "integer",
            "format": "int64",
            "example": 10,
            "description": "An override for the number of results to return for this query vector.",
            "maximum": 10000,
            "minimum": 1
          },
          "namespace": {
            "type": "string",
            "example": "example-namespace",
            "description": "An override the namespace to search."
          },
          "filter": {
            "type": "object",
            "example": {
              "genre": {
                "$in": [
                  "comedy",
                  "documentary",
                  "drama"
                ]
              },
              "year": {
                "$eq": 2019
              }
            },
            "description": "An override for the metadata filter to apply. This replaces the request-level filter."
          }
        },
        "description": "A single query vector within a `QueryRequest`.",
        "required": [
          "values"
        ],
        "deprecated": true
      },
      "ScoredVector": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "example": "example-vector-1",
            "description": "This is the vector's unique id.",
            "maxLength": 512,
            "minLength": 1,
            "required": [
              "id"
            ]
          },
          "score": {
            "type": "number",
            "format": "float",
            "example": 0.08,
            "description": "This is a measure of similarity between this vector and the query vector.  The higher the score, the more they are similar."
          },
          "values": {
            "type": "array",
            "example": [
              0.1,
              0.2,
              0.3,
              0.4,
              0.5,
              0.6,
              0.7,
              0.8
            ],
            "items": {
              "type": "number",
              "format": "float"
            },
            "description": "This is the vector data, if it is requested."
          },
          "sparseValues": {
            "$ref": "#/components/schemas/SparseValues"
          },
          "metadata": {
            "type": "object",
            "example": {
              "genre": "documentary",
              "year": 2019
            },
            "description": "This is the metadata, if it is requested."
          }
        },
        "required": [
          "id"
        ]
      },
      "SingleQueryResults": {
        "type": "object",
        "properties": {
          "matches": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ScoredVector"
            },
            "description": "The matches for the vectors."
          },
          "namespace": {
            "type": "string",
            "example": "example-namespace",
            "description": "The namespace for the vectors."
          }
        },
        "title": "The query results for a single `QueryVector`"
      },
      "SparseValues": {
        "type": "object",
        "properties": {
          "indices": {
            "type": "array",
            "example": [
              1,
              312,
              822,
              14,
              980
            ],
            "items": {
              "type": "integer",
              "format": "int64"
            },
            "description": "The indices of the sparse data.",
            "maxLength": 1000,
            "minLength": 1,
            "required": [
              "indices"
            ]
          },
          "values": {
            "type": "array",
            "example": [
              0.1,
              0.2,
              0.3,
              0.4,
              0.5
            ],
            "items": {
              "type": "number",
              "format": "float"
            },
            "description": "The corresponding values of the sparse data, which must be the same length as the indices.",
            "maxLength": 1000,
            "minLength": 1,
            "required": [
              "values"
            ]
          }
        },
        "description": "Vector sparse data. Represented as a list of indices and a list of corresponded values, which must be the same length.",
        "required": [
          "indices",
          "values"
        ]
      },
      "UpdateRequest": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "example": "example-vector-1",
            "description": "Vector's unique id.",
            "maxLength": 512,
            "minLength": 1,
            "required": [
              "id"
            ]
          },
          "values": {
            "type": "array",
            "example": [
              0.1,
              0.2,
              0.3,
              0.4,
              0.5,
              0.6,
              0.7,
              0.8
            ],
            "items": {
              "type": "number",
              "format": "float"
            },
            "description": "Vector data.",
            "maxLength": 20000,
            "minLength": 1
          },
          "sparseValues": {
            "$ref": "#/components/schemas/SparseValues"
          },
          "setMetadata": {
            "type": "object",
            "example": {
              "genre": "documentary",
              "year": 2019
            },
            "description": "Metadata to *set* for the vector."
          },
          "namespace": {
            "type": "string",
            "example": "example-namespace",
            "description": "The namespace containing the vector to update."
          }
        },
        "description": "The request for the `Upsert` operation.",
        "required": [
          "id"
        ]
      },
      "UpdateResponse": {
        "type": "object",
        "description": "The response for the `Update` operation."
      },
      "UpsertRequest": {
        "type": "object",
        "properties": {
          "vectors": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Vector"
            },
            "description": "An array containing the vectors to upsert. Recommended batch limit is 100 vectors.",
            "maxLength": 1000,
            "minLength": 1,
            "required": [
              "vectors"
            ]
          },
          "namespace": {
            "type": "string",
            "example": "example-namespace",
            "description": "This is the namespace name where you upsert vectors."
          }
        },
        "description": "The request for the `Upsert` operation.",
        "required": [
          "vectors"
        ]
      },
      "UpsertResponse": {
        "type": "object",
        "properties": {
          "upsertedCount": {
            "type": "integer",
            "format": "int64",
            "example": 10,
            "description": "The number of vectors upserted."
          }
        },
        "description": "The response for the `Upsert` operation."
      },
      "Vector": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "example": "example-vector-1",
            "description": "This is the vector's unique id.",
            "maxLength": 512,
            "minLength": 1,
            "required": [
              "id"
            ]
          },
          "values": {
            "type": "array",
            "example": [
              0.1,
              0.2,
              0.3,
              0.4,
              0.5,
              0.6,
              0.7,
              0.8
            ],
            "items": {
              "type": "number",
              "format": "float"
            },
            "description": "This is the vector data included in the request.",
            "maxLength": 20000,
            "minLength": 1,
            "required": [
              "values"
            ]
          },
          "sparseValues": {
            "$ref": "#/components/schemas/SparseValues"
          },
          "metadata": {
            "type": "object",
            "example": {
              "genre": "documentary",
              "year": 2019
            },
            "description": "This is the metadata included in the request."
          }
        },
        "required": [
          "id",
          "values"
        ]
      },
      "protobufAny": {
        "type": "object",
        "properties": {
          "typeUrl": {
            "type": "string"
          },
          "value": {
            "type": "string",
            "format": "byte"
          }
        }
      },
      "protobufNullValue": {
        "type": "string",
        "enum": [
          "NULL_VALUE"
        ],
        "default": "NULL_VALUE",
        "description": "`NullValue` is a singleton enumeration to represent the null value for the\n`Value` type union.\n\n The JSON representation for `NullValue` is JSON `null`.\n\n - NULL_VALUE: Null value."
      },
      "rpcStatus": {
        "type": "object",
        "properties": {
          "code": {
            "type": "integer",
            "format": "int32"
          },
          "message": {
            "type": "string"
          },
          "details": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/protobufAny"
            }
          }
        }
      },
      "createRequest": {
        "type": "object",
        "required": [
          "name",
          "dimension"
        ],
        "properties": {
          "name": {
            "type": "string",
            "description": "The name of the index to be created. The maximum length is 45 characters.",
            "example": "example-index"
          },
          "dimension": {
            "type": "integer",
            "description": "The dimensions of the vectors to be inserted in the index",
            "example": 1024
          },
          "index_type": {
            "type": "string",
            "description": "The type of vector index. Pinecone supports 'approximated'.",
            "default": "approximated",
            "deprecated": true
          },
          "metric": {
            "type": "string",
            "description": "The distance metric to be used for similarity search. You can use 'euclidean', 'cosine', or 'dotproduct'.",
            "default": "cosine"
          },
          "pods": {
            "type": "integer",
            "description": "The number of pods for the index to use,including replicas.",
            "default": 1
          },
          "replicas": {
            "type": "integer",
            "description": "The number of replicas. Replicas duplicate your index. They provide higher availability and throughput.",
            "default": 1
          },
          "pod_type": {
            "type": "string",
            "description": "The type of pod to use. One of `s1`, `p1`, or `p2` appended with `.` and one of `x1`, `x2`, `x4`, or `x8`.",
            "default": "p1.x1"
          },
          "index_config": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/ApproximatedConfig"
              }
            ],
            "deprecated": true
          },
          "metadata_config": {
            "type": "object",
            "description": "Configuration for the behavior of Pinecone's internal metadata index. By default, all metadata is indexed; when `metadata_config` is present, only specified metadata fields are indexed. To specify metadata fields to index, provide a JSON object of the following form: \n  ``` \n {\"indexed\": [\"example_metadata_field\"]} \n ``` ",
            "nullable": true
          },
          "source_collection": {
            "type": "string",
            "description": "The name of the collection to create an index from"
          }
        }
      },
      "createCollectionRequest": {
        "type": "object",
        "required": [
          "name",
          "source"
        ],
        "properties": {
          "name": {
            "type": "string",
            "description": "The name of the collection to be created.",
            "example": "example-collection"
          },
          "source": {
            "type": "string",
            "description": "The name of the source index to be used as the source for the collection.",
            "example": "example-source-index"
          }
        }
      },
      "collectionMeta": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "example": "example-collection"
          },
          "size": {
            "type": "integer",
            "description": "The size of the collection in bytes.",
            "example": 1
          },
          "status": {
            "type": "string",
            "description": "The status of the collection.",
            "example": "created"
          }
        }
      },
      "indexMeta": {
        "type": "object",
        "properties": {
          "database": {
            "type": "object",
            "properties": {
              "name": {
                "type": "string"
              },
              "dimension": {
                "type": "string"
              },
              "index_type": {
                "type": "string",
                "deprecated": true
              },
              "metric": {
                "type": "string"
              },
              "pods": {
                "type": "integer"
              },
              "replicas": {
                "type": "integer"
              },
              "shards": {
                "type": "integer"
              },
              "pod_type": {
                "type": "string"
              },
              "index_config": {
                "oneOf": [
                  {
                    "$ref": "#/components/schemas/ApproximatedConfig"
                  }
                ]
              },
              "metadata_config": {
                "type": "object"
              },
              "status": {
                "type": "object",
                "properties": {
                  "ready": {
                    "type": "boolean"
                  },
                  "state": {
                    "type": "string",
                    "enum": [
                      "Initializing",
                      "ScalingUp",
                      "ScalingDown",
                      "Terminating",
                      "Ready",
                      "InitializationFailed"
                    ]
                  }
                }
              }
            }
          }
        }
      },
      "patchRequest": {
        "type": "object",
        "properties": {
          "replicas": {
            "type": "integer",
            "description": "The desired number of replicas for the index.",
            "example": 3
          },
          "pod_type": {
            "type": "string",
            "description": "The new pod type for the index. One of `s1`, `p1`, or `p2` appended with `.` and one of `x1`, `x2`, `x4`, or `x8`.",
            "example": "s1.x2"
          }
        }
      },
      "HnswConfig": {
        "type": "object",
        "properties": {
          "ef_construction": {
            "type": "integer",
            "default": 500
          },
          "ef": {
            "type": "integer",
            "default": 250
          },
          "M": {
            "type": "integer",
            "default": 12
          },
          "max_elements": {
            "type": "integer",
            "default": 50000000
          }
        }
      },
      "ApproximatedConfig": {
        "type": "object",
        "properties": {
          "k_bits": {
            "type": "integer",
            "default": 512
          },
          "hybrid": {
            "type": "boolean",
            "default": false
          }
        }
      }
    },
    "securitySchemes": {
      "ApiKeyAuth": {
        "type": "apiKey",
        "description": "An API Key is required to call Pinecone APIs. Get yours at https://www.pinecone.io/start/",
        "name": "Api-Key",
        "in": "header"
      }
    }
  },
  "_id": "6385160b2d80c50016823ac4"
}