Skip to main content
GET
/
models
/
{model_name}
from pinecone import Pinecone

pc = Pinecone(api_key="YOUR_API_KEY")

model = pc.inference.get_model(model_name="llama-text-embed-v2")

print(model)

const pc = new Pinecone({ apiKey: 'YOUR_API_KEY' });

const model = await pc.inference.getModel('llama-text-embed-v2');

console.log(model);

import io.pinecone.clients.Inference;
import io.pinecone.clients.Pinecone;
import org.openapitools.inference.client.ApiException;
import org.openapitools.inference.client.model.ModelInfo;

public class DescribeModel {
    public static void main(String[] args) throws ApiException {
        Pinecone pinecone = new Pinecone.Builder("YOUR_API_KEY").build();

        Inference inference = pinecone.getInferenceClient();

        ModelInfo modelInfo = inference.describeModel("llama-text-embed-v2");
        System.out.println(modelInfo);
    }
}

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "github.com/pinecone-io/go-pinecone/v4/pinecone"
)

func prettifyStruct(obj interface{}) string {
  	bytes, _ := json.MarshalIndent(obj, "", "  ")
    return string(bytes)
}

func main() {
    ctx := context.Background()

    pc, err := pinecone.NewClient(pinecone.NewClientParams{
        ApiKey: "YOUR_API_KEY",
    })
    if err != nil {
        log.Fatalf("Failed to create Client: %v", err)
    }

    model, err := pc.Inference.DescribeModel(ctx, "llama-text-embed-v2")
    if err != nil {
        log.Fatalf("Failed to get model: %v", err)
    }
    fmt.Printf(prettifyStruct(model))
}

using Pinecone;
using Pinecone.Inference;

var pinecone = new PineconeClient("YOUR_API_KEY");

var model = await pinecone.Inference.Models.GetAsync("llama-text-embed-v2");

Console.WriteLine(model);

PINECONE_API_KEY="YOUR_API_KEY"

curl "https://api.pinecone.io/models/llama-text-embed-v2" \
    -H "Api-Key: $PINECONE_API_KEY" \
    -H "X-Pinecone-Api-Version: 2025-04"

{'default_dimension': 1024,
 'max_batch_size': 96,
 'max_sequence_length': 2048,
 'modality': 'text',
 'model': 'llama-text-embed-v2',
 'provider_name': 'NVIDIA',
 'short_description': 'A high performance dense embedding model optimized for '
                      'multilingual and cross-lingual text question-answering '
                      'retrieval with support for long documents (up to 2048 '
                      'tokens) and dynamic embedding size (Matryoshka '
                      'Embeddings).',
 'supported_dimensions': [384, 512, 768, 1024, 2048],
 'supported_metrics': [cosine, dotproduct],
 'supported_parameters': [{'allowed_values': ['query', 'passage'],
                           'parameter': 'input_type',
                           'required': True,
                           'type': 'one_of',
                           'value_type': 'string'},
                          {'allowed_values': ['END', 'NONE', 'START'],
                           'default': 'END',
                           'parameter': 'truncate',
                           'required': False,
                           'type': 'one_of',
                           'value_type': 'string'},
                          {'allowed_values': [384, 512, 768, 1024, 2048],
                           'default': 1024,
                           'parameter': 'dimension',
                           'required': False,
                           'type': 'one_of',
                           'value_type': 'integer'}],
 'type': 'embed',
 'vector_type': 'dense'}

{
  "model": "llama-text-embed-v2",
  "shortDescription": "A high performance dense embedding model optimized for multilingual and cross-lingual text question-answering retrieval with support for long documents (up to 2048 tokens) and dynamic embedding size (Matryoshka Embeddings).",
  "type": "embed",
  "vectorType": "dense",
  "defaultDimension": 1024,
  "modality": "text",
  "maxSequenceLength": 2048,
  "maxBatchSize": 96,
  "providerName": "NVIDIA",
  "supportedDimensions": [ 384, 512, 768, 1024, 2048 ],
  "supportedMetrics": [ "Cosine", "DotProduct" ],
  "supportedParameters": [
    {
      parameter: 'input_type',
      type: 'one_of',
      valueType: 'string',
      required: true,
      allowedValues: [Array],
      min: undefined,
      max: undefined,
      _default: undefined
    },
    {
      parameter: 'truncate',
      type: 'one_of',
      valueType: 'string',
      required: false,
      allowedValues: [Array],
      min: undefined,
      max: undefined,
      _default: 'END'
    },
    {
      parameter: 'dimension',
      type: 'one_of',
      valueType: 'integer',
      required: false,
      allowedValues: [Array],
      min: undefined,
      max: undefined,
      _default: 1024
    }
  ]
}

class ModelInfo {
    model: llama-text-embed-v2
    shortDescription: A high performance dense embedding model optimized for multilingual and cross-lingual text question-answering retrieval with support for long documents (up to 2048 tokens) and dynamic embedding size (Matryoshka Embeddings).
    type: embed
    vectorType: dense
    defaultDimension: 1024
    modality: text
    maxSequenceLength: 2048
    maxBatchSize: 96
    providerName: NVIDIA
    supportedDimensions: [384, 512, 768, 1024, 2048]
    supportedMetrics: [cosine, dotproduct]
    supportedParameters: [class ModelInfoSupportedParameter {
        parameter: input_type
        type: one_of
        valueType: string
        required: true
        allowedValues: [class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: query
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: passage
            isNullable: false
            schemaType: anyOf
        }]
        min: null
        max: null
        _default: null
        additionalProperties: null
    }, class ModelInfoSupportedParameter {
        parameter: truncate
        type: one_of
        valueType: string
        required: false
        allowedValues: [class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: END
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: NONE
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: START
            isNullable: false
            schemaType: anyOf
        }]
        min: null
        max: null
        _default: class class org.openapitools.inference.client.model.ModelInfoSupportedParameterDefault {
            instance: END
            isNullable: false
            schemaType: anyOf
        }
        additionalProperties: null
    }, class ModelInfoSupportedParameter {
        parameter: dimension
        type: one_of
        valueType: integer
        required: false
        allowedValues: [class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: 384
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: 512
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: 768
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: 1024
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: 2048
            isNullable: false
            schemaType: anyOf
        }]
        min: null
        max: null
        _default: class class org.openapitools.inference.client.model.ModelInfoSupportedParameterDefault {
            instance: 1024
            isNullable: false
            schemaType: anyOf
        }
        additionalProperties: null
    }]
    additionalProperties: null
}

{
  "default_dimension": 1024,
  "max_batch_size": 96,
  "max_sequence_length": 2048,
  "modality": "text",
  "model": "llama-text-embed-v2",
  "provider_name": "NVIDIA",
  "short_description": "A high performance dense embedding model optimized for multilingual and cross-lingual text question-answering retrieval with support for long documents (up to 2048 tokens) and dynamic embedding size (Matryoshka Embeddings).",
  "supported_dimensions": [
    384,
    512,
    768,
    1024,
    2048
  ],
  "supported_metrics": [
    "cosine",
    "dotproduct"
  ],
  "supported_parameters": [
    {
      "allowed_values": [
        {
          "StringValue": "query",
          "IntValue": null,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": "passage",
          "IntValue": null,
          "FloatValue": null,
          "BoolValue": null
        }
      ],
      "parameter": "input_type",
      "required": true,
      "type": "one_of",
      "value_type": "string"
    },
    {
      "allowed_values": [
        {
          "StringValue": "END",
          "IntValue": null,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": "NONE",
          "IntValue": null,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": "START",
          "IntValue": null,
          "FloatValue": null,
          "BoolValue": null
        }
      ],
      "default": {
        "StringValue": "END",
        "IntValue": null,
        "FloatValue": null,
        "BoolValue": null
      },
      "parameter": "truncate",
      "required": false,
      "type": "one_of",
      "value_type": "string"
    },
    {
      "allowed_values": [
        {
          "StringValue": null,
          "IntValue": 384,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": null,
          "IntValue": 512,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": null,
          "IntValue": 768,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": null,
          "IntValue": 1024,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": null,
          "IntValue": 2048,
          "FloatValue": null,
          "BoolValue": null
        }
      ],
      "default": {
        "StringValue": null,
        "IntValue": 1024,
        "FloatValue": null,
        "BoolValue": null
      },
      "parameter": "dimension",
      "required": false,
      "type": "one_of",
      "value_type": "integer"
    }
  ],
  "type": "embed",
  "vector_type": "dense"
}

{
  "model": "llama-text-embed-v2",
  "short_description": "A high performance dense embedding model optimized for multilingual and cross-lingual text question-answering retrieval with support for long documents (up to 2048 tokens) and dynamic embedding size (Matryoshka Embeddings).",
  "type": "embed",
  "vector_type": "dense",
  "default_dimension": 1024,
  "modality": "text",
  "max_sequence_length": 2048,
  "max_batch_size": 96,
  "provider_name": "NVIDIA",
  "supported_dimensions": [
    384,
    512,
    768,
    1024,
    2048
  ],
  "supported_metrics": [
    "cosine",
    "cosine"
  ],
  "supported_parameters": [
    {
      "parameter": "input_type",
      "type": "one_of",
      "value_type": "string",
      "required": true,
      "allowed_values": [
        "query",
        "passage"
      ]
    },
    {
      "parameter": "truncate",
      "type": "one_of",
      "value_type": "string",
      "required": false,
      "allowed_values": [
        "END",
        "NONE",
        "START"
      ],
      "default": "END"
    },
    {
      "parameter": "dimension",
      "type": "one_of",
      "value_type": "integer",
      "required": false,
      "allowed_values": [
        384,
        512,
        768,
        1024,
        2048
      ],
      "default": 1024
    }
  ]
}

{
  "model": "llama-text-embed-v2",
  "short_description": "A high performance dense embedding model optimized for multilingual and cross-lingual text question-answering retrieval with support for long documents (up to 2048 tokens) and dynamic embedding size (Matryoshka Embeddings).",
  "type": "embed",
  "vector_type": "dense",
  "default_dimension": 1024,
  "modality": "text",
  "max_sequence_length": 2048,
  "max_batch_size": 96,
  "provider_name": "NVIDIA",
  "supported_metrics": [
    "Cosine",
    "DotProduct"
  ],
  "supported_dimensions": [
    384,
    512,
    768,
    1024,
    2048
  ],
  "supported_parameters": [
    {
      "parameter": "input_type",
      "required": true,
      "type": "one_of",
      "value_type": "string",
      "allowed_values": [
        "query",
        "passage"
      ]
    },
    {
      "parameter": "truncate",
      "required": false,
      "default": "END",
      "type": "one_of",
      "value_type": "string",
      "allowed_values": [
        "END",
        "NONE",
        "START"
      ]
    },
    {
      "parameter": "dimension",
      "required": false,
      "default": 1024,
      "type": "one_of",
      "value_type": "integer",
      "allowed_values": [
        384,
        512,
        768,
        1024,
        2048
      ]
    }
  ]
}

from pinecone import Pinecone

pc = Pinecone(api_key="YOUR_API_KEY")

model = pc.inference.get_model(model_name="llama-text-embed-v2")

print(model)

const pc = new Pinecone({ apiKey: 'YOUR_API_KEY' });

const model = await pc.inference.getModel('llama-text-embed-v2');

console.log(model);

import io.pinecone.clients.Inference;
import io.pinecone.clients.Pinecone;
import org.openapitools.inference.client.ApiException;
import org.openapitools.inference.client.model.ModelInfo;

public class DescribeModel {
    public static void main(String[] args) throws ApiException {
        Pinecone pinecone = new Pinecone.Builder("YOUR_API_KEY").build();

        Inference inference = pinecone.getInferenceClient();

        ModelInfo modelInfo = inference.describeModel("llama-text-embed-v2");
        System.out.println(modelInfo);
    }
}

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "github.com/pinecone-io/go-pinecone/v4/pinecone"
)

func prettifyStruct(obj interface{}) string {
  	bytes, _ := json.MarshalIndent(obj, "", "  ")
    return string(bytes)
}

func main() {
    ctx := context.Background()

    pc, err := pinecone.NewClient(pinecone.NewClientParams{
        ApiKey: "YOUR_API_KEY",
    })
    if err != nil {
        log.Fatalf("Failed to create Client: %v", err)
    }

    model, err := pc.Inference.DescribeModel(ctx, "llama-text-embed-v2")
    if err != nil {
        log.Fatalf("Failed to get model: %v", err)
    }
    fmt.Printf(prettifyStruct(model))
}

using Pinecone;
using Pinecone.Inference;

var pinecone = new PineconeClient("YOUR_API_KEY");

var model = await pinecone.Inference.Models.GetAsync("llama-text-embed-v2");

Console.WriteLine(model);

PINECONE_API_KEY="YOUR_API_KEY"

curl "https://api.pinecone.io/models/llama-text-embed-v2" \
    -H "Api-Key: $PINECONE_API_KEY" \
    -H "X-Pinecone-Api-Version: 2025-04"

{'default_dimension': 1024,
 'max_batch_size': 96,
 'max_sequence_length': 2048,
 'modality': 'text',
 'model': 'llama-text-embed-v2',
 'provider_name': 'NVIDIA',
 'short_description': 'A high performance dense embedding model optimized for '
                      'multilingual and cross-lingual text question-answering '
                      'retrieval with support for long documents (up to 2048 '
                      'tokens) and dynamic embedding size (Matryoshka '
                      'Embeddings).',
 'supported_dimensions': [384, 512, 768, 1024, 2048],
 'supported_metrics': [cosine, dotproduct],
 'supported_parameters': [{'allowed_values': ['query', 'passage'],
                           'parameter': 'input_type',
                           'required': True,
                           'type': 'one_of',
                           'value_type': 'string'},
                          {'allowed_values': ['END', 'NONE', 'START'],
                           'default': 'END',
                           'parameter': 'truncate',
                           'required': False,
                           'type': 'one_of',
                           'value_type': 'string'},
                          {'allowed_values': [384, 512, 768, 1024, 2048],
                           'default': 1024,
                           'parameter': 'dimension',
                           'required': False,
                           'type': 'one_of',
                           'value_type': 'integer'}],
 'type': 'embed',
 'vector_type': 'dense'}

{
  "model": "llama-text-embed-v2",
  "shortDescription": "A high performance dense embedding model optimized for multilingual and cross-lingual text question-answering retrieval with support for long documents (up to 2048 tokens) and dynamic embedding size (Matryoshka Embeddings).",
  "type": "embed",
  "vectorType": "dense",
  "defaultDimension": 1024,
  "modality": "text",
  "maxSequenceLength": 2048,
  "maxBatchSize": 96,
  "providerName": "NVIDIA",
  "supportedDimensions": [ 384, 512, 768, 1024, 2048 ],
  "supportedMetrics": [ "Cosine", "DotProduct" ],
  "supportedParameters": [
    {
      parameter: 'input_type',
      type: 'one_of',
      valueType: 'string',
      required: true,
      allowedValues: [Array],
      min: undefined,
      max: undefined,
      _default: undefined
    },
    {
      parameter: 'truncate',
      type: 'one_of',
      valueType: 'string',
      required: false,
      allowedValues: [Array],
      min: undefined,
      max: undefined,
      _default: 'END'
    },
    {
      parameter: 'dimension',
      type: 'one_of',
      valueType: 'integer',
      required: false,
      allowedValues: [Array],
      min: undefined,
      max: undefined,
      _default: 1024
    }
  ]
}

class ModelInfo {
    model: llama-text-embed-v2
    shortDescription: A high performance dense embedding model optimized for multilingual and cross-lingual text question-answering retrieval with support for long documents (up to 2048 tokens) and dynamic embedding size (Matryoshka Embeddings).
    type: embed
    vectorType: dense
    defaultDimension: 1024
    modality: text
    maxSequenceLength: 2048
    maxBatchSize: 96
    providerName: NVIDIA
    supportedDimensions: [384, 512, 768, 1024, 2048]
    supportedMetrics: [cosine, dotproduct]
    supportedParameters: [class ModelInfoSupportedParameter {
        parameter: input_type
        type: one_of
        valueType: string
        required: true
        allowedValues: [class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: query
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: passage
            isNullable: false
            schemaType: anyOf
        }]
        min: null
        max: null
        _default: null
        additionalProperties: null
    }, class ModelInfoSupportedParameter {
        parameter: truncate
        type: one_of
        valueType: string
        required: false
        allowedValues: [class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: END
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: NONE
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: START
            isNullable: false
            schemaType: anyOf
        }]
        min: null
        max: null
        _default: class class org.openapitools.inference.client.model.ModelInfoSupportedParameterDefault {
            instance: END
            isNullable: false
            schemaType: anyOf
        }
        additionalProperties: null
    }, class ModelInfoSupportedParameter {
        parameter: dimension
        type: one_of
        valueType: integer
        required: false
        allowedValues: [class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: 384
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: 512
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: 768
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: 1024
            isNullable: false
            schemaType: anyOf
        }, class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
            instance: 2048
            isNullable: false
            schemaType: anyOf
        }]
        min: null
        max: null
        _default: class class org.openapitools.inference.client.model.ModelInfoSupportedParameterDefault {
            instance: 1024
            isNullable: false
            schemaType: anyOf
        }
        additionalProperties: null
    }]
    additionalProperties: null
}

{
  "default_dimension": 1024,
  "max_batch_size": 96,
  "max_sequence_length": 2048,
  "modality": "text",
  "model": "llama-text-embed-v2",
  "provider_name": "NVIDIA",
  "short_description": "A high performance dense embedding model optimized for multilingual and cross-lingual text question-answering retrieval with support for long documents (up to 2048 tokens) and dynamic embedding size (Matryoshka Embeddings).",
  "supported_dimensions": [
    384,
    512,
    768,
    1024,
    2048
  ],
  "supported_metrics": [
    "cosine",
    "dotproduct"
  ],
  "supported_parameters": [
    {
      "allowed_values": [
        {
          "StringValue": "query",
          "IntValue": null,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": "passage",
          "IntValue": null,
          "FloatValue": null,
          "BoolValue": null
        }
      ],
      "parameter": "input_type",
      "required": true,
      "type": "one_of",
      "value_type": "string"
    },
    {
      "allowed_values": [
        {
          "StringValue": "END",
          "IntValue": null,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": "NONE",
          "IntValue": null,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": "START",
          "IntValue": null,
          "FloatValue": null,
          "BoolValue": null
        }
      ],
      "default": {
        "StringValue": "END",
        "IntValue": null,
        "FloatValue": null,
        "BoolValue": null
      },
      "parameter": "truncate",
      "required": false,
      "type": "one_of",
      "value_type": "string"
    },
    {
      "allowed_values": [
        {
          "StringValue": null,
          "IntValue": 384,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": null,
          "IntValue": 512,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": null,
          "IntValue": 768,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": null,
          "IntValue": 1024,
          "FloatValue": null,
          "BoolValue": null
        },
        {
          "StringValue": null,
          "IntValue": 2048,
          "FloatValue": null,
          "BoolValue": null
        }
      ],
      "default": {
        "StringValue": null,
        "IntValue": 1024,
        "FloatValue": null,
        "BoolValue": null
      },
      "parameter": "dimension",
      "required": false,
      "type": "one_of",
      "value_type": "integer"
    }
  ],
  "type": "embed",
  "vector_type": "dense"
}

{
  "model": "llama-text-embed-v2",
  "short_description": "A high performance dense embedding model optimized for multilingual and cross-lingual text question-answering retrieval with support for long documents (up to 2048 tokens) and dynamic embedding size (Matryoshka Embeddings).",
  "type": "embed",
  "vector_type": "dense",
  "default_dimension": 1024,
  "modality": "text",
  "max_sequence_length": 2048,
  "max_batch_size": 96,
  "provider_name": "NVIDIA",
  "supported_dimensions": [
    384,
    512,
    768,
    1024,
    2048
  ],
  "supported_metrics": [
    "cosine",
    "cosine"
  ],
  "supported_parameters": [
    {
      "parameter": "input_type",
      "type": "one_of",
      "value_type": "string",
      "required": true,
      "allowed_values": [
        "query",
        "passage"
      ]
    },
    {
      "parameter": "truncate",
      "type": "one_of",
      "value_type": "string",
      "required": false,
      "allowed_values": [
        "END",
        "NONE",
        "START"
      ],
      "default": "END"
    },
    {
      "parameter": "dimension",
      "type": "one_of",
      "value_type": "integer",
      "required": false,
      "allowed_values": [
        384,
        512,
        768,
        1024,
        2048
      ],
      "default": 1024
    }
  ]
}

{
  "model": "llama-text-embed-v2",
  "short_description": "A high performance dense embedding model optimized for multilingual and cross-lingual text question-answering retrieval with support for long documents (up to 2048 tokens) and dynamic embedding size (Matryoshka Embeddings).",
  "type": "embed",
  "vector_type": "dense",
  "default_dimension": 1024,
  "modality": "text",
  "max_sequence_length": 2048,
  "max_batch_size": 96,
  "provider_name": "NVIDIA",
  "supported_metrics": [
    "Cosine",
    "DotProduct"
  ],
  "supported_dimensions": [
    384,
    512,
    768,
    1024,
    2048
  ],
  "supported_parameters": [
    {
      "parameter": "input_type",
      "required": true,
      "type": "one_of",
      "value_type": "string",
      "allowed_values": [
        "query",
        "passage"
      ]
    },
    {
      "parameter": "truncate",
      "required": false,
      "default": "END",
      "type": "one_of",
      "value_type": "string",
      "allowed_values": [
        "END",
        "NONE",
        "START"
      ]
    },
    {
      "parameter": "dimension",
      "required": false,
      "default": 1024,
      "type": "one_of",
      "value_type": "integer",
      "allowed_values": [
        384,
        512,
        768,
        1024,
        2048
      ]
    }
  ]
}

Authorizations

​
Api-Key
string
header
required

An API Key is required to call Pinecone APIs. Get yours from the console.

Path Parameters

​
model_name
string
required

The name of the model to look up.

Response

The model details.

Represents the model configuration including model type, supported parameters, and other model details.

​
model
string
required

The name of the model.

Example:

"multilingual-e5-large"

​
short_description
string
required

A summary of the model.

Example:

"multilingual-e5-large"

​
type
string
required

The type of model (e.g. 'embed' or 'rerank').

Example:

"embed"

​
supported_parameters
object[]
required
​
vector_type
string

Whether the embedding model produces 'dense' or 'sparse' embeddings.

​
default_dimension
integer<int32>

The default embedding model dimension (applies to dense embedding models only).

Required range: 1 <= x <= 20000
Example:

1024

​
modality
string

The modality of the model (e.g. 'text').

Example:

"text"

​
max_sequence_length
integer<int32>

The maximum tokens per sequence supported by the model.

Required range: x >= 1
Example:

512

​
max_batch_size
integer<int32>

The maximum batch size (number of sequences) supported by the model.

Required range: x >= 1
Example:

96

​
provider_name
string

The name of the provider of the model.

Example:

"NVIDIA"

​
supported_dimensions
integer<int32>[]

The list of supported dimensions for the model (applies to dense embedding models only).

Required range: 1 <= x <= 20000
​
supported_metrics
enum<string>[]

The distance metrics supported by the model for similarity search.

A distance metric that the embedding model supports for similarity searches.

Available options:
cosine,
euclidean,
dotproduct