from pinecone import Pinecone

pc = Pinecone(api_key="YOUR_API_KEY")

models = pc.inference.list_models()

print(models)

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

const models = await pc.inference.listModels();

console.log(models);

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

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

        Inference inference = pinecone.getInferenceClient();

        // List all models
        ModelInfoList models = inference.listModels();
        System.out.println(models);

        // List by model type ("embed" or "rerank")
        ModelInfoList modelsByModelType = inference.listModels("rerank");
        System.out.println(modelsByModelType);

        // List by model type ("embed" or "rerank") and vector type ("dense" or "sparse")
        ModelInfoList modelsByModelTypeAndVectorType = inference.listModels("embed", "dense");
        System.out.println(modelsByModelTypeAndVectorType);
    }
}

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

    embed := "embed"
    rerank := "rerank"

    embedModels, err := pc.Inference.ListModels(ctx, &pinecone.ListModelsParams{
        Type: &embed,
    })
    if err != nil {
        log.Fatalf("Failed to list embedding models: %v", err)
    }
    fmt.Printf(prettifyStruct(embedModels))

    rerankModels, err := pc.Inference.ListModels(ctx, &pinecone.ListModelsParams{
        Type: &rerank,
    })
    if err != nil {
        log.Fatalf("Failed to list reranking models: %v", err)
    }
    fmt.Printf(prettifyStruct(rerankModels))
}

using Pinecone;
using Pinecone.Inference;

var pinecone = new PineconeClient("YOUR_API_KEY");

var models = await pinecone.Inference.Models.ListAsync(new ListModelsRequest());

Console.WriteLine(models);

PINECONE_API_KEY="YOUR_API_KEY"

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

[{
    "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",
    "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,
            "default": "END",
            "allowed_values": [
                "END",
                "NONE",
                "START"
            ]
        },
        {
            "parameter": "dimension",
            "type": "one_of",
            "value_type": "integer",
            "required": false,
            "default": 1024,
            "allowed_values": [
                384,
                512,
                768,
                1024,
                2048
            ]
        }
    ],
    "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
    ]
}, {
    "model": "multilingual-e5-large",
    "short_description": "A high-performance dense embedding model trained on a mixture of multilingual datasets. It works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)",
    "type": "embed",
    "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,
            "default": "END",
            "allowed_values": [
                "END",
                "NONE"
            ]
        }
    ],
    "vector_type": "dense",
    "default_dimension": 1024,
    "modality": "text",
    "max_sequence_length": 507,
    "max_batch_size": 96,
    "provider_name": "Microsoft",
    "supported_metrics": [
        "cosine",
        "euclidean"
    ],
    "supported_dimensions": [
        1024
    ]
}, {
    "model": "pinecone-sparse-english-v0",
    "short_description": "A sparse embedding model for converting text to sparse vectors for keyword or hybrid semantic/keyword search. Built on the innovations of the DeepImpact architecture.",
    "type": "embed",
    "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,
            "default": "END",
            "allowed_values": [
                "END",
                "NONE"
            ]
        },
        {
            "parameter": "return_tokens",
            "type": "any",
            "value_type": "boolean",
            "required": false,
            "default": false
        }
    ],
    "vector_type": "sparse",
    "modality": "text",
    "max_sequence_length": 512,
    "max_batch_size": 96,
    "provider_name": "Pinecone",
    "supported_metrics": [
        "dotproduct"
    ]
}, {
    "model": "bge-reranker-v2-m3",
    "short_description": "A high-performance, multilingual reranking model that works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)",
    "type": "rerank",
    "supported_parameters": [
        {
            "parameter": "truncate",
            "type": "one_of",
            "value_type": "string",
            "required": false,
            "default": "NONE",
            "allowed_values": [
                "END",
                "NONE"
            ]
        }
    ],
    "modality": "text",
    "max_sequence_length": 1024,
    "max_batch_size": 100,
    "provider_name": "BAAI",
    "supported_metrics": []
}, {
    "model": "cohere-rerank-3.5",
    "short_description": "Cohere's leading reranking model, balancing performance and latency for a wide range of enterprise search applications.",
    "type": "rerank",
    "supported_parameters": [
        {
            "parameter": "max_chunks_per_doc",
            "type": "numeric_range",
            "value_type": "integer",
            "required": false,
            "default": 3072,
            "min": 1.0,
            "max": 3072.0
        }
    ],
    "modality": "text",
    "max_sequence_length": 40000,
    "max_batch_size": 200,
    "provider_name": "Cohere",
    "supported_metrics": []
}, {
    "model": "pinecone-rerank-v0",
    "short_description": "A state of the art reranking model that out-performs competitors on widely accepted benchmarks. It can handle chunks up to 512 tokens (1-2 paragraphs)",
    "type": "rerank",
    "supported_parameters": [
        {
            "parameter": "truncate",
            "type": "one_of",
            "value_type": "string",
            "required": false,
            "default": "END",
            "allowed_values": [
                "END",
                "NONE"
            ]
        }
    ],
    "modality": "text",
    "max_sequence_length": 512,
    "max_batch_size": 100,
    "provider_name": "Pinecone",
    "supported_metrics": []
}]

{
  models: [
    {
      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: [Array],
      supportedMetrics: [Array],
      supportedParameters: [Array]
    },
    {
      model: 'multilingual-e5-large',
      shortDescription: 'A high-performance dense embedding model trained on a mixture of multilingual datasets. It works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)',
      type: 'embed',
      vectorType: 'dense',
      defaultDimension: 1024,
      modality: 'text',
      maxSequenceLength: 507,
      maxBatchSize: 96,
      providerName: 'Microsoft',
      supportedDimensions: [Array],
      supportedMetrics: [Array],
      supportedParameters: [Array]
    },
    {
      model: 'pinecone-sparse-english-v0',
      shortDescription: 'A sparse embedding model for converting text to sparse vectors for keyword or hybrid semantic/keyword search. Built on the innovations of the DeepImpact architecture.',
      type: 'embed',
      vectorType: 'sparse',
      defaultDimension: undefined,
      modality: 'text',
      maxSequenceLength: 512,
      maxBatchSize: 96,
      providerName: 'Pinecone',
      supportedDimensions: undefined,
      supportedMetrics: [Array],
      supportedParameters: [Array]
    },
    {
      model: 'bge-reranker-v2-m3',
      shortDescription: 'A high-performance, multilingual reranking model that works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)',
      type: 'rerank',
      vectorType: undefined,
      defaultDimension: undefined,
      modality: 'text',
      maxSequenceLength: 1024,
      maxBatchSize: 100,
      providerName: 'BAAI',
      supportedDimensions: undefined,
      supportedMetrics: undefined,
      supportedParameters: [Array]
    },
    {
      model: 'cohere-rerank-3.5',
      shortDescription: "Cohere's leading reranking model, balancing performance and latency for a wide range of enterprise search applications.",
      type: 'rerank',
      vectorType: undefined,
      defaultDimension: undefined,
      modality: 'text',
      maxSequenceLength: 40000,
      maxBatchSize: 200,
      providerName: 'Cohere',
      supportedDimensions: undefined,
      supportedMetrics: undefined,
      supportedParameters: [Array]
    },
    {
      model: 'pinecone-rerank-v0',
      shortDescription: 'A state of the art reranking model that out-performs competitors on widely accepted benchmarks. It can handle chunks up to 512 tokens (1-2 paragraphs)',
      type: 'rerank',
      vectorType: undefined,
      defaultDimension: undefined,
      modality: 'text',
      maxSequenceLength: 512,
      maxBatchSize: 100,
      providerName: 'Pinecone',
      supportedDimensions: undefined,
      supportedMetrics: undefined,
      supportedParameters: [Array]
    }
  ]
}

class ModelInfoList {
    models: [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
    }, class ModelInfo {
        model: multilingual-e5-large
        shortDescription: A high-performance dense embedding model trained on a mixture of multilingual datasets. It works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)
        type: embed
        vectorType: dense
        defaultDimension: 1024
        modality: text
        maxSequenceLength: 507
        maxBatchSize: 96
        providerName: Microsoft
        supportedDimensions: [1024]
        supportedMetrics: [cosine, euclidean]
        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
            }]
            min: null
            max: null
            _default: class class org.openapitools.inference.client.model.ModelInfoSupportedParameterDefault {
                instance: END
                isNullable: false
                schemaType: anyOf
            }
            additionalProperties: null
        }]
        additionalProperties: null
    }, class ModelInfo {
        model: pinecone-sparse-english-v0
        shortDescription: A sparse embedding model for converting text to sparse vectors for keyword or hybrid semantic/keyword search. Built on the innovations of the DeepImpact architecture.
        type: embed
        vectorType: sparse
        defaultDimension: null
        modality: text
        maxSequenceLength: 512
        maxBatchSize: 96
        providerName: Pinecone
        supportedDimensions: null
        supportedMetrics: [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
            }]
            min: null
            max: null
            _default: class class org.openapitools.inference.client.model.ModelInfoSupportedParameterDefault {
                instance: END
                isNullable: false
                schemaType: anyOf
            }
            additionalProperties: null
        }, class ModelInfoSupportedParameter {
            parameter: return_tokens
            type: any
            valueType: boolean
            required: false
            allowedValues: null
            min: null
            max: null
            _default: class class org.openapitools.inference.client.model.ModelInfoSupportedParameterDefault {
                instance: false
                isNullable: false
                schemaType: anyOf
            }
            additionalProperties: null
        }, class ModelInfoSupportedParameter {
            parameter: max_tokens_per_sequence
            type: one_of
            valueType: integer
            required: false
            allowedValues: [class class org.openapitools.inference.client.model.ModelInfoSupportedParameterAllowedValuesInner {
                instance: 512
                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: 512
                isNullable: false
                schemaType: anyOf
            }
            additionalProperties: null
        }]
        additionalProperties: null
    }, class ModelInfo {
        model: bge-reranker-v2-m3
        shortDescription: A high-performance, multilingual reranking model that works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)
        type: rerank
        vectorType: null
        defaultDimension: null
        modality: text
        maxSequenceLength: 1024
        maxBatchSize: 100
        providerName: BAAI
        supportedDimensions: null
        supportedMetrics: null
        supportedParameters: [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
            }]
            min: null
            max: null
            _default: class class org.openapitools.inference.client.model.ModelInfoSupportedParameterDefault {
                instance: NONE
                isNullable: false
                schemaType: anyOf
            }
            additionalProperties: null
        }]
        additionalProperties: null
    }, class ModelInfo {
        model: cohere-rerank-3.5
        shortDescription: Cohere's leading reranking model, balancing performance and latency for a wide range of enterprise search applications.
        type: rerank
        vectorType: null
        defaultDimension: null
        modality: text
        maxSequenceLength: 40000
        maxBatchSize: 200
        providerName: Cohere
        supportedDimensions: null
        supportedMetrics: null
        supportedParameters: [class ModelInfoSupportedParameter {
            parameter: max_chunks_per_doc
            type: numeric_range
            valueType: integer
            required: false
            allowedValues: null
            min: 1
            max: 3072
            _default: class class org.openapitools.inference.client.model.ModelInfoSupportedParameterDefault {
                instance: 3072
                isNullable: false
                schemaType: anyOf
            }
            additionalProperties: null
        }]
        additionalProperties: null
    }, class ModelInfo {
        model: pinecone-rerank-v0
        shortDescription: A state of the art reranking model that out-performs competitors on widely accepted benchmarks. It can handle chunks up to 512 tokens (1-2 paragraphs)
        type: rerank
        vectorType: null
        defaultDimension: null
        modality: text
        maxSequenceLength: 512
        maxBatchSize: 100
        providerName: Pinecone
        supportedDimensions: null
        supportedMetrics: null
        supportedParameters: [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
            }]
            min: null
            max: null
            _default: class class org.openapitools.inference.client.model.ModelInfoSupportedParameterDefault {
                instance: END
                isNullable: false
                schemaType: anyOf
            }
            additionalProperties: null
        }]
        additionalProperties: null
    }]
    additionalProperties: null
}

{
  "models": [
    {
      "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"
    },
    {
      "default_dimension": 1024,
      "max_batch_size": 96,
      "max_sequence_length": 507,
      "modality": "text",
      "model": "multilingual-e5-large",
      "provider_name": "Microsoft",
      "short_description": "A high-performance dense embedding model trained on a mixture of multilingual datasets. It works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)",
      "supported_dimensions": [
        1024
      ],
      "supported_metrics": [
        "cosine",
        "euclidean"
      ],
      "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
            }
          ],
          "default": {
            "StringValue": "END",
            "IntValue": null,
            "FloatValue": null,
            "BoolValue": null
          },
          "parameter": "truncate",
          "required": false,
          "type": "one_of",
          "value_type": "string"
        }
      ],
      "type": "embed",
      "vector_type": "dense"
    },
    {
      "max_batch_size": 96,
      "max_sequence_length": 512,
      "modality": "text",
      "model": "pinecone-sparse-english-v0",
      "provider_name": "Pinecone",
      "short_description": "A sparse embedding model for converting text to sparse vectors for keyword or hybrid semantic/keyword search. Built on the innovations of the DeepImpact architecture.",
      "supported_metrics": [
        "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
            }
          ],
          "default": {
            "StringValue": "END",
            "IntValue": null,
            "FloatValue": null,
            "BoolValue": null
          },
          "parameter": "truncate",
          "required": false,
          "type": "one_of",
          "value_type": "string"
        },
        {
          "default": {
            "StringValue": null,
            "IntValue": null,
            "FloatValue": null,
            "BoolValue": false
          },
          "parameter": "return_tokens",
          "required": false,
          "type": "any",
          "value_type": "boolean"
        },
        {
          "allowed_values": [
            {
              "StringValue": null,
              "IntValue": 512,
              "FloatValue": null,
              "BoolValue": null
            },
            {
              "StringValue": null,
              "IntValue": 2048,
              "FloatValue": null,
              "BoolValue": null
            }
          ],
          "default": {
            "StringValue": null,
            "IntValue": 512,
            "FloatValue": null,
            "BoolValue": null
          },
          "parameter": "max_tokens_per_sequence",
          "required": false,
          "type": "one_of",
          "value_type": "integer"
        }
      ],
      "type": "embed",
      "vector_type": "sparse"
    }
  ]
}{
  "models": [
    {
      "max_batch_size": 100,
      "max_sequence_length": 1024,
      "modality": "text",
      "model": "bge-reranker-v2-m3",
      "provider_name": "BAAI",
      "short_description": "A high-performance, multilingual reranking model that works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)",
      "supported_parameters": [
        {
          "allowed_values": [
            {
              "StringValue": "END",
              "IntValue": null,
              "FloatValue": null,
              "BoolValue": null
            },
            {
              "StringValue": "NONE",
              "IntValue": null,
              "FloatValue": null,
              "BoolValue": null
            }
          ],
          "default": {
            "StringValue": "NONE",
            "IntValue": null,
            "FloatValue": null,
            "BoolValue": null
          },
          "parameter": "truncate",
          "required": false,
          "type": "one_of",
          "value_type": "string"
        }
      ],
      "type": "rerank"
    },
    {
      "max_batch_size": 200,
      "max_sequence_length": 40000,
      "modality": "text",
      "model": "cohere-rerank-3.5",
      "provider_name": "Cohere",
      "short_description": "Cohere's leading reranking model, balancing performance and latency for a wide range of enterprise search applications.",
      "supported_parameters": [
        {
          "default": {
            "StringValue": null,
            "IntValue": 3072,
            "FloatValue": null,
            "BoolValue": null
          },
          "max": 3072,
          "min": 1,
          "parameter": "max_chunks_per_doc",
          "required": false,
          "type": "numeric_range",
          "value_type": "integer"
        }
      ],
      "type": "rerank"
    },
    {
      "max_batch_size": 100,
      "max_sequence_length": 512,
      "modality": "text",
      "model": "pinecone-rerank-v0",
      "provider_name": "Pinecone",
      "short_description": "A state of the art reranking model that out-performs competitors on widely accepted benchmarks. It can handle chunks up to 512 tokens (1-2 paragraphs)",
      "supported_parameters": [
        {
          "allowed_values": [
            {
              "StringValue": "END",
              "IntValue": null,
              "FloatValue": null,
              "BoolValue": null
            },
            {
              "StringValue": "NONE",
              "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"
        }
      ],
      "type": "rerank"
    }
  ]
}

{
    "models": [
        {
            "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": "multilingual-e5-large",
            "short_description": "A high-performance dense embedding model trained on a mixture of multilingual datasets. It works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)",
            "type": "embed",
            "vector_type": "dense",
            "default_dimension": 1024,
            "modality": "text",
            "max_sequence_length": 507,
            "max_batch_size": 96,
            "provider_name": "Microsoft",
            "supported_dimensions": [
                1024
            ],
            "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"
                    ],
                    "default": "END"
                }
            ]
        },
        {
            "model": "pinecone-sparse-english-v0",
            "short_description": "A sparse embedding model for converting text to sparse vectors for keyword or hybrid semantic/keyword search. Built on the innovations of the DeepImpact architecture.",
            "type": "embed",
            "vector_type": "sparse",
            "modality": "text",
            "max_sequence_length": 512,
            "max_batch_size": 96,
            "provider_name": "Pinecone",
            "supported_metrics": [
                "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"
                    ],
                    "default": "END"
                },
                {
                    "parameter": "return_tokens",
                    "type": "any",
                    "value_type": "boolean",
                    "required": false,
                    "default": false
                }
            ]
        },
        {
            "model": "bge-reranker-v2-m3",
            "short_description": "A high-performance, multilingual reranking model that works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)",
            "type": "rerank",
            "modality": "text",
            "max_sequence_length": 1024,
            "max_batch_size": 100,
            "provider_name": "BAAI",
            "supported_parameters": [
                {
                    "parameter": "truncate",
                    "type": "one_of",
                    "value_type": "string",
                    "required": false,
                    "allowed_values": [
                        "END",
                        "NONE"
                    ],
                    "default": "NONE"
                }
            ]
        },
        {
            "model": "cohere-rerank-3.5",
            "short_description": "Cohere\u0027s leading reranking model, balancing performance and latency for a wide range of enterprise search applications.",
            "type": "rerank",
            "modality": "text",
            "max_sequence_length": 40000,
            "max_batch_size": 200,
            "provider_name": "Cohere",
            "supported_parameters": [
                {
                    "parameter": "max_chunks_per_doc",
                    "type": "numeric_range",
                    "value_type": "integer",
                    "required": false,
                    "min": 1,
                    "max": 3072,
                    "default": 3072
                }
            ]
        },
        {
            "model": "pinecone-rerank-v0",
            "short_description": "A state of the art reranking model that out-performs competitors on widely accepted benchmarks. It can handle chunks up to 512 tokens (1-2 paragraphs)",
            "type": "rerank",
            "modality": "text",
            "max_sequence_length": 512,
            "max_batch_size": 100,
            "provider_name": "Pinecone",
            "supported_parameters": [
                {
                    "parameter": "truncate",
                    "type": "one_of",
                    "value_type": "string",
                    "required": false,
                    "allowed_values": [
                        "END",
                        "NONE"
                    ],
                    "default": "END"
                }
            ]
        }
    ]
}

{
  "models": [
    {
      "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
          ]
        }
      ]
    },
    {
      "model": "multilingual-e5-large",
      "short_description": "A high-performance dense embedding model trained on a mixture of multilingual datasets. It works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)",
      "type": "embed",
      "vector_type": "dense",
      "default_dimension": 1024,
      "modality": "text",
      "max_sequence_length": 507,
      "max_batch_size": 96,
      "provider_name": "Microsoft",
      "supported_metrics": [
        "Cosine",
        "Euclidean"
      ],
      "supported_dimensions": [
        1024
      ],
      "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"
          ]
        }
      ]
    },
    {
      "model": "pinecone-sparse-english-v0",
      "short_description": "A sparse embedding model for converting text to sparse vectors for keyword or hybrid semantic/keyword search. Built on the innovations of the DeepImpact architecture.",
      "type": "embed",
      "vector_type": "sparse",
      "modality": "text",
      "max_sequence_length": 512,
      "max_batch_size": 96,
      "provider_name": "Pinecone",
      "supported_metrics": [
        "DotProduct"
      ],
      "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"
          ]
        },
        {
          "parameter": "return_tokens",
          "required": false,
          "default": false,
          "type": "any",
          "value_type": "boolean"
        }
      ]
    },
    {
      "model": "bge-reranker-v2-m3",
      "short_description": "A high-performance, multilingual reranking model that works well on messy data and short queries expected to return medium-length passages of text (1-2 paragraphs)",
      "type": "rerank",
      "modality": "text",
      "max_sequence_length": 1024,
      "max_batch_size": 100,
      "provider_name": "BAAI",
      "supported_parameters": [
        {
          "parameter": "truncate",
          "required": false,
          "default": "NONE",
          "type": "one_of",
          "value_type": "string",
          "allowed_values": [
            "END",
            "NONE"
          ]
        }
      ]
    },
    {
      "model": "cohere-rerank-3.5",
      "short_description": "Cohere's leading reranking model, balancing performance and latency for a wide range of enterprise search applications.",
      "type": "rerank",
      "modality": "text",
      "max_sequence_length": 40000,
      "max_batch_size": 200,
      "provider_name": "Cohere",
      "supported_parameters": [
        {
          "parameter": "max_chunks_per_doc",
          "required": false,
          "default": 3072,
          "type": "numeric_range",
          "value_type": "integer",
          "min": 1,
          "max": 3072
        }
      ]
    },
    {
      "model": "pinecone-rerank-v0",
      "short_description": "A state of the art reranking model that out-performs competitors on widely accepted benchmarks. It can handle chunks up to 512 tokens (1-2 paragraphs)",
      "type": "rerank",
      "modality": "text",
      "max_sequence_length": 512,
      "max_batch_size": 100,
      "provider_name": "Pinecone",
      "supported_parameters": [
        {
          "parameter": "truncate",
          "required": false,
          "default": "END",
          "type": "one_of",
          "value_type": "string",
          "allowed_values": [
            "END",
            "NONE"
          ]
        }
      ]
    }
  ]
}