pinecone ts client
v4.0.0
Este é o Node.js SDK oficial para Pinecone, escrito no TypeScript.
v0.x , consulte o V1 Migration Guide .v1.x , consulte o V2 Migration Guide .Os trechos mostrados neste readme devem ser concisos. Para exemplos mais realistas, explore esses exemplos:
2.x para 3.x Há uma mudança de ruptura envolvendo a operação configureIndex nesta atualização. A estrutura do objeto passada ao configurar um índice foi alterada para incluir deletionProtection . Os campos podType e replicas agora podem ser atualizados através do objeto spec.pod . Consulte Configurar índices baseados em POD para um exemplo do código.
2.x : Foram feitas muitas alterações nesta versão para oferecer suporte à nova oferta de índice sem servidor da Pinecone. As alterações são abordadas em detalhes no guia de migração V2 . Os índices sem servidor estão disponíveis apenas nas versões de liberação 2.x ou mais.1.x : Esta versão mudou oficialmente o SDK da versão beta, e há várias mudanças que precisam ser abordadas ao atualizar a partir de uma versão 0.x Consulte o Guia de Migração V1 para obter detalhes. O Pinecone TypeScript SDK é compatível com o TypeScript> = 4.1 e o nó> = 18.x.
npm install @pinecone-database/pinecone
O Pinecone Typescript SDK é destinado apenas ao uso do servidor . O uso do SDK em um contexto do navegador pode expor sua (s) chave (s) da API . Se você implantou o SDK para a produção em um navegador, gire suas chaves da API.
Uma chave da API é necessária para inicializar o cliente. Ele pode ser passado usando uma variável de ambiente ou em código através de um objeto de configuração. Obtenha uma chave de API no console.
A variável de ambiente usada para configurar a chave da API para o cliente é a seguinte:
PINECONE_API_KEY= " your_api_key " PINECONE_API_KEY é a única variável necessária. Quando essa variável de ambiente é definida, o construtor do cliente não requer argumentos adicionais.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ; Se você preferir passar a configuração no código, o construtor aceita um objeto de configuração que contém o valor apiKey . Este é o objeto em que você passaria propriedades como maxRetries (padrão para 3 ) para operações repetíveis ( upsert , update e configureIndex ).
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( {
apiKey : 'your_api_key' ,
maxRetries : 5 ,
} ) ; Se a sua configuração de rede exigir que você interaja com o Pinecone por meio de um proxy, você poderá passar por um ProxyAgent personalizado da biblioteca undici . Abaixo está um exemplo de como construir um ProxyAgent undici que direciona o tráfego de rede por meio de um servidor proxy mitm enquanto atinge o ponto final do Pinecone /indexes .
NOTA: A estratégia a seguir depende da implementação fetch nativa do Node, lançada no nó V16 e estabilizada no nó v21. Se você estiver executando as versões do nó 18-21, poderá ter problemas decorrentes da instabilidade do recurso. Atualmente, não há problemas conhecidos relacionados à proxy no nó v18+.
import {
Pinecone ,
type PineconeConfiguration ,
} from '@pinecone-database/pinecone' ;
import { Dispatcher , ProxyAgent } from 'undici' ;
import * as fs from 'fs' ;
const cert = fs . readFileSync ( 'path-to-your-mitm-proxy-cert-pem-file' ) ;
const client = new ProxyAgent ( {
uri : '<your proxy server URI>' ,
requestTls : {
port : '<your proxy server port>' ,
ca : cert ,
host : '<your proxy server host>' ,
} ,
} ) ;
const customFetch = (
input : string | URL | Request ,
init : RequestInit | undefined
) => {
return fetch ( input , {
... init ,
dispatcher : client as Dispatcher ,
keepalive : true , # optional
} ) ;
} ;
const config : PineconeConfiguration = {
apiKey :
'<your Pinecone API key, available in your dashboard at app.pinecone.io>' ,
fetchApi : customFetch ,
} ;
const pc = new Pinecone ( config ) ;
const indexes = async ( ) => {
return await pc . listIndexes ( ) ;
} ;
indexes ( ) . then ( ( response ) => {
console . log ( 'My indexes: ' , response ) ;
} ) ; No mínimo, para criar um índice sem servidor, você deve especificar um name , dimension e spec . A dimension indica o tamanho dos vetores que você pretende armazenar no índice. Por exemplo, se sua intenção era armazenar e consultar incorporações (vetores) geradas com o modelo Textembedding-Ada-002 da OpenAI, você precisaria criar um índice com a dimensão 1536 para corresponder à saída desse modelo.
A spec configura como o índice deve ser implantado. Para índices sem servidor, você define apenas a nuvem e a região onde o índice deve ser hospedado. Para índices baseados em POD, você define o ambiente em que o índice deve ser hospedado, o tipo de pod e o tamanho a serem usados e outras características do índice. Para obter mais informações sobre disponibilidade sem servidor e regional, consulte os índices de compreensão.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . createIndex ( {
name : 'sample-index' ,
dimension : 1536 ,
spec : {
serverless : {
cloud : 'aws' ,
region : 'us-west-2' ,
} ,
} ,
tags : { team : 'data-science' } ,
} ) ; Para criar um índice baseado em POD, você define pod no objeto spec , que contém o environment em que o índice deve ser hospedado e o tamanho do podType e pods a serem usados. Muitos campos de configuração opcionais permitem um maior controle sobre os recursos e a disponibilidade de hardware. Para saber mais sobre o objetivo desses campos, consulte os índices de compreensão e os índices baseados em POD em escala.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . createIndex ( {
name : 'sample-index-2' ,
dimension : 1536 ,
metric : 'dotproduct' ,
spec : {
pod : {
environment : 'us-east4-gcp' ,
pods : 2 ,
podType : 'p1.x2' ,
metadataConfig : {
indexed : [ 'product_type' ] ,
} ,
} ,
tags : { team : 'data-science' } ,
} ,
// This option tells the client not to throw if the index already exists.
suppressConflicts : true ,
// This option tells the client not to resolve the promise until the
// index is ready.
waitUntilReady : true ,
} ) ; O método createIndex emite uma solicitação de criação para a API que retorna rapidamente, mas o índice resultante não está imediatamente pronto para aprimorar, consultar ou executar outras operações de dados. Você pode usar o método describeIndex para descobrir o status de um índice e ver se ele está pronto para uso.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . describeIndex ( 'serverless-index' ) ;
// {
// name: 'serverless-index',
// dimension: 1536,
// metric: 'cosine',
// host: 'serverless-index-4zo0ijk.svc.us-west2-aws.pinecone.io',
// deletionProtection: 'disabled',
// spec: {
// serverless: {
// cloud: 'aws',
// region: 'us-west-2'
// }
// },
// status: {
// ready: false,
// state: 'Initializing'
// }
// } Se você passar na opção waitUntilReady , o cliente lidará com as atualizações de status em um índice recém -criado. A promessa retornada pelo createIndex não será resolvida até que o status do índice indique que está pronto para lidar com operações de dados. Isso pode ser especialmente útil para testes de integração, onde a criação do índice em uma etapa de configuração será seguida imediatamente pelas operações de dados.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . createIndex ( {
name : 'serverless-index' ,
dimension : 1536 ,
spec : {
serverless : {
cloud : 'aws' ,
region : 'us-west-2' ,
} ,
} ,
waitUntilReady : true ,
} ) ; Observação
Os índices sem servidores e iniciantes não suportam coleções.
À medida que você usa o Pinecone para mais coisas, você pode explorar diferentes configurações de índice com os mesmos dados vetoriais. As coleções fornecem uma maneira fácil de fazer isso. Veja outros métodos de cliente para trabalhar com coleções aqui.
Dado que você tem uma coleção existente:
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . describeCollection ( 'product-description-embeddings' ) ;
// {
// name: 'product-description-embeddings',
// size: 543427063,
// status: 'Ready',
// dimension: 2,
// vectorCount: 10001498,
// environment: 'us-east4-gcp'
// } NOTA: Para índices baseados em POD, você pode especificar uma sourceCollection para criar um índice. A coleção deve estar no mesmo ambiente que o índice.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . createIndex ( {
name : 'product-description-p1x1' ,
dimension : 256 ,
metric : 'cosine' ,
spec : {
pod : {
environment : 'us-east4-gcp' ,
pods : 1 ,
podType : 'p1.x1' ,
sourceCollection : 'product-description-embeddings' ,
} ,
} ,
} ) ;Quando o novo índice estiver pronto, ele deve conter todos os dados que estavam na coleção, prontos para serem consultados.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . index ( 'product-description-p2x2' ) . describeIndexStats ( ) ;
// {
// namespaces: { '': { recordCount: 78000 } },
// dimension: 256,
// indexFullness: 0.9,
// totalRecordCount: 78000
// } Você pode configurar os índices sem servidor e pod com deletionProtection . Qualquer índice com esta propriedade definida como 'enabled' não poderá ser excluída. Por padrão, deletionProtection será definida como 'disabled' se não for fornecida como parte da solicitação createIndex . Para ativar deletionProtection você pode passar o valor enquanto chama createIndex .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . createIndex ( {
name : 'deletion-protected-index' ,
dimension : 1536 ,
metric : 'cosine' ,
deletionProtection : 'enabled' ,
spec : {
serverless : {
cloud : 'aws' ,
region : 'us-west-2' ,
} ,
} ,
} ) ; Para desativar a proteção contra exclusão, você pode usar a operação configureIndex .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . configureIndex ( 'deletion-protected-index' , {
deletionProtection : 'disabled' ,
} ) ; Você pode criar ou configurar índices sem servidor e pod com tags. Os índices podem conter um número arbitrário de tags que descrevem metadados que você gostaria de anexar ao próprio objeto de índice, como propriedade da equipe, projeto ou qualquer outra informação relevante.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
// Create index with tag
await pc . createIndex ( {
name : 'tag-index' ,
dimension : 1536 ,
metric : 'cosine' ,
spec : {
serverless : {
cloud : 'aws' ,
region : 'us-west-2' ,
} ,
} ,
tags : { team : 'data-science' } , // index tag
} ) ;
// Configure index with a new tag
await pc . configureIndex ( 'tag-index' , {
tags : { project : 'recommendation' } , // new index tag
} ) ;
// Delete an existing tag
await pc . configureIndex ( 'tag-index' , {
tags : { project : '' } , // Pass an empty string to an existing key to delete a tag; this will delete the `project` tag
} ) ; Você pode buscar a descrição de qualquer índice por nome usando describeIndex .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . describeIndex ( 'serverless-index' ) ;
// {
// name: 'serverless-index',
// dimension: 1536,
// metric: 'cosine',
// host: 'serverless-index-4zo0ijk.svc.us-west2-aws.pinecone.io',
// deletionProtection: 'disabled',
// spec: {
// serverless: {
// cloud: 'aws',
// region: 'us-west-2'
// },
// },
// status: {
// ready: true,
// state: 'Ready'
// }
// }Observação
Esta seção se aplica apenas a índices baseados em POD. Com índices sem servidor, você não configura nenhum recurso de computação ou armazenamento. Em vez disso, os índices sem servidores são escaleiros automaticamente com base no uso.
Você pode ajustar o número de réplicas ou a escala para um tamanho de vagem maior (especificado com podType ). Consulte Índices baseados em POD em escala. Você não pode fazer o downgrade do tamanho da vagem ou alterar o tipo de vagem base.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . configureIndex ( 'pod-index' , {
spec : {
pod : {
replicas : 2 ,
podType : 'p1.x4' ,
} ,
} ,
} ) ;
const config = await pc . describeIndex ( 'pod-index' ) ;
// {
// name: 'pod-index',
// dimension: 1536,
// metric: 'cosine',
// host: 'pod-index-4zo0ijk.svc.us-east1-gcp.pinecone.io',
// deletionProtection: 'disabled',
// spec: {
// pod: {
// environment: 'us-east1-gcp',
// replicas: 2,
// shards: 2,
// podType: 'p1.x4',
// pods: 4,
// metadataConfig: [Object],
// sourceCollection: undefined
// }
// },
// status: {
// ready: true,
// state: 'ScalingUpPodSize'
// }
// }Os índices são excluídos pelo nome.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . deleteIndex ( 'sample-index' ) ; O comando listIndexes retorna um objeto com uma matriz de modelos de índice em indexes .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . listIndexes ( ) ;
// {
// indexes: [
// {
// name: 'serverless-index',
// dimension: 1536,
// metric: 'cosine',
// host: 'serverless-index-4zo0ijk.svc.us-west2-aws.pinecone.io',
// deletionProtection: 'disabled',
// spec: {
// serverless: {
// cloud: 'aws',
// region: 'us-west-2',
// },
// },
// status: {
// ready: true,
// state: 'Ready',
// },
// },
// {
// name: 'pod-index',
// dimension: 1536,
// metric: 'cosine',
// host: 'pod-index-4zo0ijk.svc.us-west2-aws.pinecone.io',
// deletionProtection: 'disabled',
// spec: {
// pod: {
// environment: 'us-west2-aws',
// replicas: 1,
// shards: 1,
// podType: 'p1.x1',
// pods: 1,
// },
// },
// status: {
// ready: true,
// state: 'Ready',
// },
// },
// ],
// } Observação
Os índices sem servidores e iniciantes não suportam coleções.
Uma coleção é uma cópia estática de um índice baseado em POD que pode ser usado para criar backups, criar cópias de índices ou realizar experimentos com diferentes configurações de índice. Para saber mais sobre as coleções Pinecone, consulte Compreendendo as coleções.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . createCollection ( {
name : 'collection-name' ,
source : 'index-name' ,
} ) ; Essa chamada da API deve retornar rapidamente, mas a criação de uma coleção pode levar de minutos a horas, dependendo do tamanho do índice de origem e da configuração do índice. Use describeCollection para verificar o status de uma coleção.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . deleteCollection ( 'collection-name' ) ; Você pode usar listCollections para confirmar a exclusão.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const describeCollection = await pc . describeCollection ( 'collection3' ) ;
// {
// name: 'collection3',
// size: 3126700,
// status: 'Ready',
// dimension: 3,
// vectorCount: 1234,
// environment: 'us-east1-gcp',
// } O comando listCollections retorna um objeto com uma matriz de modelos de coleção em collections .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const list = await pc . listCollections ( ) ;
// {
// collections: [
// {
// name: 'collection1',
// size: 3089687,
// status: 'Ready',
// dimension: 3,
// vectorCount: 17378,
// environment: 'us-west1-gcp',
// },
// {
// name: 'collection2',
// size: 208309,
// status: 'Ready',
// dimension: 3,
// vectorCount: 1000,
// environment: 'us-east4-gcp',
// },
// ];
// } Índices Pinecone Operações de suporte para trabalhar com dados vetoriais usando operações como UPSERT, consulta, busca e exclusão.
Para executar operações de dados em um índice, você segmentou -o usando o método index .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'test-index' ) ;
// Now perform index operations
await index . fetch ( [ '1' ] ) ; O primeiro argumento é o nome do índice que você está segmentando. Há um segundo argumento opcional para fornecer uma substituição de host de índice. O fornecimento deste segundo argumento permite ignorar o comportamento padrão do SDK de resolver seu host de índice através do nome do índice fornecido. Você pode encontrar seu host de índice no console do Pinecone ou usando as operações describeIndex ou listIndexes .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'test-index' , 'my-index-host-1532-svc.io' ) ;
// Now perform index operations against: https://my-index-host-1532-svc.io
await index . fetch ( [ '1' ] ) ; Se você estiver armazenando metadados juntamente com os valores do vetor, poderá passar um parâmetro de tipo para index() para obter o TypeScript adequado.
import { Pinecone , PineconeRecord } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
type MovieMetadata = {
title : string ,
runtime : number ,
genre : 'comedy' | 'horror' | 'drama' | 'action'
}
// Specify a custom metadata type while targeting the index
const index = pc . index < MovieMetadata > ( 'test-index' ) ;
// Now you get type errors if upserting malformed metadata
await index . upsert ( [ {
id : '1234' ,
values : [
... . // embedding values
] ,
metadata : {
genre : 'Gone with the Wind' ,
runtime : 238 ,
genre : 'drama' ,
// @ts-expect-error because category property not in MovieMetadata
category : 'classic'
}
} ] )
const results = await index . query ( {
vector : [
... // query embedding
] ,
filter : { genre : { '$eq' : 'drama' } }
} )
const movie = results . matches [ 0 ] ;
if ( movie . metadata ) {
// Since we passed the MovieMetadata type parameter above,
// we can interact with metadata fields without having to
// do any typecasting.
const { title , runtime , genre } = movie . metadata ;
console . log ( `The best match in drama was ${ title } ` )
} Por padrão, todas as operações de dados ocorrem dentro do espaço de nome padrão de '' . Se você estiver trabalhando com outros namespaces não padrão, poderá segmentar o espaço para nome da realização de uma chamada para namespace() .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'test-index' ) . namespace ( 'ns1' ) ;
// Now perform index operations in the targeted index and namespace
await index . fetch ( [ '1' ] ) ;Consulte Use os espaços para names para obter mais informações.
Pinecone espera que os registros inseridos nos índices tenham o seguinte formulário:
type PineconeRecord = {
id : string ;
values : Array < number > ;
sparseValues ?: Array < number > ;
metadata ?: object ;
} ;Para melhorar alguns vetores, você pode usar o cliente como assim:
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
// Target an index
const index = pc . index ( 'sample-index' ) ;
// Prepare your data. The length of each array
// of vector values must match the dimension of
// the index where you plan to store them.
const vectors = [
{
id : '1' ,
values : [ 0.236 , 0.971 , 0.559 ] ,
sparseValues : { indices : [ 0 , 1 ] , values : [ 0.236 , 0.34 ] } , // Optional; for hybrid search
} ,
{
id : '2' ,
values : [ 0.685 , 0.111 , 0.857 ] ,
sparseValues : { indices : [ 0 , 1 ] , values : [ 0.345 , 0.98 ] } , // Optional; for hybrid search
} ,
] ;
// Upsert the data into your index
await index . upsert ( vectors ) ; Agora você pode importar vetores em massa do armazenamento de objetos. Import é uma operação assíncrona de longa data que importa um grande número de registros em um índice sem servidor Pinecone.
Para importar vetores do armazenamento de objetos, eles devem ser armazenados em arquivos parquet e aderir ao formato de arquivo necessário. Seu armazenamento de objetos também deve aderir à estrutura de diretório necessária.
O exemplo a seguir importa vetores de um balde Amazon S3 em um índice sem servidor Pinecone:
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const indexName = 'sample-index' ;
await pc . createIndex ( {
name : indexName ,
dimension : 10 ,
spec : {
serverless : {
cloud : 'aws' ,
region : 'eu-west-1' ,
} ,
} ,
} ) ;
const index = pc . Index ( indexName ) ;
const storageURI = 's3://my-bucket/my-directory/' ;
await index . startImport ( storageURI , 'continue' ) ; // "Continue" will avoid aborting the operation if errors are encountered.
// {
// "id": "import-id"
// }Você pode começar, cancelar e verificar o status de todas ou uma operação de importação (s).
Notas:
Import só funciona com índices sem servidorImport está em visualização pública Ao experimentar operações de dados, às vezes é útil saber quantos registros/vetores são armazenados em cada espaço de nome. Nesse caso, direcione o índice e use o comando describeIndexStats() .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'example-index' ) ;
await index . describeIndexStats ( ) ;
// {
// namespaces: {
// '': { recordCount: 10 }
// foo: { recordCount: 2000 },
// bar: { recordCount: 2000 }
// },
// dimension: 1536,
// indexFullness: 0,
// totalRecordCount: 4010
// }O método de consulta aceita um grande número de opções. A dimensão do vetor de consulta deve corresponder à dimensão do seu índice.
type QueryOptions = {
topK : number ; // number of results desired
vector ?: Array < number > ; // must match dimension of index
sparseVector ?: {
indices : Array < integer > ; // indices must fall within index dimension
values : Array < number > ; // indices and values arrays must have same length
} ;
id ?: string ;
includeMetadata : boolean ;
includeValues : boolean ;
} ; Por exemplo, para consultar os valores do vetor, você passaria o param vector na configuração das opções. Para a brevidade, este exemplo de consulta é minúsculo (dimensão 2), mas em um caso de uso mais realista, esse vetor de consulta seria uma incorporação em saída por um modelo. Veja o código de exemplo para ver exemplos mais realistas de como usar query .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'my-index' ) ;
await index . query ( { topK : 3 , vector : [ 0.22 , 0.66 ] } ) ;
// {
// matches: [
// {
// id: '556',
// score: 1.00000012,
// values: [],
// sparseValues: undefined,
// metadata: undefined
// },
// {
// id: '137',
// score: 1.00000012,
// values: [],
// sparseValues: undefined,
// metadata: undefined
// },
// {
// id: '129',
// score: 1.00000012,
// values: [],
// sparseValues: undefined,
// metadata: undefined
// }
// ],
// namespace: '',
// usage: {
// readUnits: 5
// }
// } Você inclui opções para includeMetadata: true ou includeValues: true se precisar dessas informações. Por padrão, eles não são devolvidos para manter a carga útil de resposta pequena.
Lembre -se de que as operações de dados ocorrem no contexto de um namespace ; portanto, se você estiver trabalhando com namespaces e não veja os resultados esperados, verifique se está direcionando o espaço de nome correto com sua consulta.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
// Target the index and namespace
const index = pc . index ( 'my-index' ) . namespace ( 'my-namespace' ) ;
const results = await index . query ( { topK : 3 , vector : [ 0.22 , 0.66 ] } ) ; Você pode consultar usando os valores vetoriais de um registro existente no índice, passando um ID de registro. Observe que o registro com o ID especificado pode estar na resposta desta operação.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'my-index' ) ;
const results = await index . query ( { topK : 10 , id : '1' } ) ; Se você estiver trabalhando com vetores densos esparsos, poderá adicionar valores de vetores esparsos para executar uma pesquisa híbrida.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . createIndex ( {
name : 'hybrid-search-index' ,
metric : 'dotproduct' , // Note: dot product is the only distance metric supported for hybrid search
dimension : 2 ,
spec : {
pod : {
environment : 'us-west4-gcp' ,
podType : 'p2.x1' ,
} ,
} ,
waitUntilReady : true ,
} ) ;
const index = pc . index ( 'hybrid-search-index' ) ;
const hybridRecords = [
{
id : '1' ,
values : [ 0.236 , 0.971 ] , // dense vectors
sparseValues : { indices : [ 0 , 1 ] , values : [ 0.236 , 0.34 ] } , // sparse vectors
} ,
{
id : '2' ,
values : [ 0.685 , 0.111 ] ,
sparseValues : { indices : [ 0 , 1 ] , values : [ 0.887 , 0.243 ] } ,
} ,
] ;
await index . upsert ( hybridRecords ) ;
const query = 'What is the most popular red dress?' ;
// ... send query to dense vector embedding model and save those values in `denseQueryVector`
// ... send query to sparse vector embedding model and save those values in `sparseQueryVector`
const denseQueryVector = [ 0.236 , 0.971 ] ;
const sparseQueryVector = { indices : [ 0 , 1 ] , values : [ 0.0 , 0.34 ] } ;
// Execute a hybrid search
await index . query ( {
topK : 3 ,
vector : denseQueryVector ,
sparseVector : sparseQueryVector ,
} ) ; Você pode atualizar values de vetores, sparseValues ou metadata . Especifique o ID e o valor do atributo que você deseja atualizar.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'imdb-movies' ) ;
await index . update ( {
id : '18593' ,
metadata : { genre : 'romance' } ,
} ) ; O método listPaginated pode ser usado para listar IDs registrados correspondendo a um prefixo de ID específico em um formato paginado. Com uma atribuição inteligente de IDs de registro, isso pode ser usado para ajudar a modelar as relações hierárquicas entre diferentes registros, como quando há incorporações para vários pedaços ou fragmentos relacionados ao mesmo documento.
Notas:
prefix , o prefixo padrão é uma string vazia, que retorna todos os IDs do vetor em seu índice100 IDs de vetor se nenhum limit for especificado. Consequentemente, se houver menos de 100 IDs de vetor que correspondem a um determinado prefix em seu índice e você não especificar um limit , seu paginationToken será undefined O exemplo a seguir mostra como buscar as duas páginas de IDs vetoriais para vetores cujos IDs contêm o prefixo doc1# , assumindo um limit de 3 e documentos doc1 sendo fundidos em 4 vetores.
const pc = new Pinecone ( ) ;
const index = pc . index ( 'my-index' ) . namespace ( 'my-namespace' ) ;
// Fetch the 1st 3 vector IDs matching prefix 'doc1#'
const results = await index . listPaginated ( { limit : 3 , prefix : 'doc1#' } ) ;
console . log ( results ) ;
// {
// vectors: [
// { id: 'doc1#01' }
// { id: 'doc1#02' }
// { id: 'doc1#03' }
// ...
// ],
// pagination: {
// next: 'eyJza2lwX3Bhc3QiOiJwcmVUZXN0LS04MCIsInByZWZpeCI6InByZVRlc3QifQ=='
// },
// namespace: 'my-namespace',
// usage: { readUnits: 1 }
// }
// Fetch the final vector ID matching prefix 'doc1#' using the paginationToken returned by the previous call
const nextResults = await index . listPaginated ( {
prefix : 'doc1#' ,
paginationToken : results . pagination ?. next ,
} ) ;
console . log ( nextResults ) ;
// {
// vectors: [
// { id: 'doc1#04' }
// ],
// pagination: undefined,
// namespace: 'my-namespace',
// usage: { readUnits: 1 }
// } import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'my-index' ) ;
const fetchResult = await index . fetch ( [ 'id-1' , 'id-2' ] ) ; Por conveniência, existem vários métodos relacionados a exclusão. Você pode verificar os resultados de uma operação de exclusão tentando fetch() um registro ou analisando o resumo do índice com describeIndexStats()
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'my-index' ) ;
await index . deleteOne ( 'id-to-delete' ) ; import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'my-index' ) ;
await index . deleteMany ( [ 'id-1' , 'id-2' , 'id-3' ] ) ;Nota: A exclusão pelo filtro de metadados se aplica apenas a índices baseados em POD.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'albums-database' ) ;
await index . deleteMany ( { genre : 'rock' } ) ; OBSERVAÇÃO
Os índices no ambiente de iniciantes do GCP não suportam espaços para nome.
Para destruir tudo no espaço de nome direcionado, use o método deleteAll .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'my-index' ) ;
await index . namespace ( 'foo-namespace' ) . deleteAll ( ) ; Se você não especificar um espaço para nome, os registros no espaço para nome padrão '' serão excluídos.
Interaja com a API de inferência da Pinecone (atualmente em visualização pública). A API de inferência Pinecone é um serviço que oferece acesso a modelos de inferência hospedados na infraestrutura da Pinecone.
Notas:
Modelos suportados:
Envie o texto para a API de inferência da Pinecone para gerar incorporações para documentos e consultas.
import { Pinecone } from '@pinecone-database/pinecone' ;
const client = new Pinecone ( { apiKey : '<Your API key from app.pinecone.io>' } ) ;
const embeddingModel = 'multilingual-e5-large' ;
const documents = [
'Turkey is a classic meat to eat at American Thanksgiving.' ,
'Many people enjoy the beautiful mosques in Turkey.' ,
] ;
const docParameters = {
inputType : 'passage' ,
truncate : 'END' ,
} ;
async function generateDocEmbeddings ( ) {
try {
return await client . inference . embed (
embeddingModel ,
documents ,
docParameters
) ;
} catch ( error ) {
console . error ( 'Error generating embeddings:' , error ) ;
}
}
generateDocEmbeddings ( ) . then ( ( embeddingsResponse ) => {
if ( embeddingsResponse ) {
console . log ( embeddingsResponse ) ;
}
} ) ;
// << Upsert documents into Pinecone >>
const userQuery = [ 'How should I prepare my turkey?' ] ;
const queryParameters = {
inputType : 'query' ,
truncate : 'END' ,
} ;
async function generateQueryEmbeddings ( ) {
try {
return await client . inference . embed (
embeddingModel ,
userQuery ,
queryParameters
) ;
} catch ( error ) {
console . error ( 'Error generating embeddings:' , error ) ;
}
}
generateQueryEmbeddings ( ) . then ( ( embeddingsResponse ) => {
if ( embeddingsResponse ) {
console . log ( embeddingsResponse ) ;
}
} ) ;
// << Send query to Pinecone to retrieve similar documents >> Rerank documenta em ordem de relevância descendente contra uma consulta.
Nota: A score representa a medida absoluta de relevância de uma determinada consulta e par de passagem. Normalizado entre [0, 1], a score representa o quão relevante um item e consulta específicos estão, com as pontuações mais próximas de 1 indicando maior relevância.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const rerankingModel = 'bge-reranker-v2-m3' ;
const myQuery = 'What are some good Turkey dishes for Thanksgiving?' ;
// Option 1: Documents as an array of strings
const myDocsStrings = [
'I love turkey sandwiches with pastrami' ,
'A lemon brined Turkey with apple sausage stuffing is a classic Thanksgiving main' ,
'My favorite Thanksgiving dish is pumpkin pie' ,
'Turkey is a great source of protein' ,
] ;
// Option 1 response
const response = await pc . inference . rerank (
rerankingModel ,
myQuery ,
myDocsStrings
) ;
console . log ( response ) ;
// {
// model: 'bge-reranker-v2-m3',
// data: [
// { index: 1, score: 0.5633179, document: [Object] },
// { index: 2, score: 0.02013874, document: [Object] },
// { index: 3, score: 0.00035419367, document: [Object] },
// { index: 0, score: 0.00021485926, document: [Object] }
// ],
// usage: { rerankUnits: 1 }
// }
// Option 2: Documents as an array of objects
const myDocsObjs = [
{
title : 'Turkey Sandwiches' ,
body : 'I love turkey sandwiches with pastrami' ,
} ,
{
title : 'Lemon Turkey' ,
body : 'A lemon brined Turkey with apple sausage stuffing is a classic Thanksgiving main' ,
} ,
{
title : 'Thanksgiving' ,
body : 'My favorite Thanksgiving dish is pumpkin pie' ,
} ,
{
title : 'Protein Sources' ,
body : 'Turkey is a great source of protein' ,
} ,
] ;
// Option 2: Options object declaring which custom key to rerank on
// Note: If no custom key is passed via `rankFields`, each doc must contain a `text` key, and that will act as the default)
const rerankOptions = {
topN : 3 ,
returnDocuments : false ,
rankFields : [ 'body' ] ,
parameters : {
inputType : 'passage' ,
truncate : 'END' ,
} ,
} ;
// Option 2 response
const response = await pc . inference . rerank (
rerankingModel ,
myQuery ,
myDocsObjs ,
rerankOptions
) ;
console . log ( response ) ;
// {
// model: 'bge-reranker-v2-m3',
// data: [
// { index: 1, score: 0.5633179, document: undefined },
// { index: 2, score: 0.02013874, document: undefined },
// { index: 3, score: 0.00035419367, document: undefined },
// ],
// usage: { rerankUnits: 1 }
//} Todos os testes ocorre automaticamente no IC e são configurados usando ações e fluxos de trabalho do GitHub, localizados no diretório .github deste repositório.
Consulte Contribuindo.md para obter mais informações.
