pinecone ts client
v4.0.0
Este es el node.js SDK oficial para Pinecone, escrito en TypeScript.
v0.x , consulte la guía de migración V1 .v1.x , consulte la guía de migración V2 .Los fragmentos que se muestran en este readme están destinados a ser concisos. Para ejemplos más realistas, explore estos ejemplos:
2.x a 3.x Existe un cambio de ruptura que involucra la operación configureIndex en esta actualización. La estructura del objeto pasada al configurar un índice ha cambiado para incluir deletionProtection . Los campos podType y replicas ahora se pueden actualizar a través del objeto spec.pod . Consulte Configurar índices basados en POD para un ejemplo del código.
2.x : Se hicieron muchos cambios en esta versión para admitir la nueva oferta de índice sin servidor de Pinecone. Los cambios se cubren en detalle en la Guía de migración V2 . Los índices sin servidor solo están disponibles en 2.x versiones de liberación o mayores.1.x : esta versión conmovió oficialmente el SDK de Beta, y hay una serie de cambios de ruptura que deben abordarse al actualizar desde una versión 0.x Consulte la Guía de migración V1 para obtener más detalles. El SDK de Pinecone TypeScript es compatible con TypeScript> = 4.1 y nodo> = 18.x.
npm install @pinecone-database/pinecone
El SDK de Pinecone TypeScript está destinado solo a su uso del lado del servidor . El uso del SDK dentro de un contexto del navegador puede exponer sus clave API . Si ha implementado el SDK en la producción en un navegador, gire sus claves API.
Se requiere una clave API para inicializar el cliente. Se puede pasar utilizando una variable de entorno o en código a través de un objeto de configuración. Obtenga una clave API en la consola.
La variable de entorno utilizada para configurar la tecla API para el cliente es la siguiente:
PINECONE_API_KEY= " your_api_key " PINECONE_API_KEY es la única variable requerida. Cuando se establece esta variable de entorno, el constructor del cliente no requiere ningún argumento adicional.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ; Si prefiere pasar la configuración en el código, el constructor acepta un objeto de configuración que contiene el valor apiKey . Este es el objeto en el que pasaría propiedades como maxRetries (valores predeterminados a 3 ) para las operaciones de Vithermable ( upsert , update y configureIndex ).
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( {
apiKey : 'your_api_key' ,
maxRetries : 5 ,
} ) ; Si su configuración de red requiere que interactúe con Pinecone a través de un proxy, puede pasar un ProxyAgent personalizado desde la biblioteca undici . A continuación se muestra un ejemplo de cómo construir un ProxyAgent undici que enruta el tráfico de la red a través de un servidor proxy mitm mientras presiona el punto final de Pinecone /indexes .
Nota: La siguiente estrategia se basa en la implementación fetch nativa de Node, lanzada en el nodo V16 y estabilizado en el nodo V21. Si está ejecutando las versiones del nodo 18-21, puede experimentar problemas derivados de la inestabilidad de la función. Actualmente no hay problemas conocidos relacionados con la representación en el nodo 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 ) ;
} ) ; Como mínimo, para crear un índice sin servidor, debe especificar un name , dimension y spec . La dimension indica el tamaño de los vectores que tiene la intención de almacenar en el índice. Por ejemplo, si su intención era almacenar y consultar las incrustaciones (vectores) generados con el modelo de texting-ADA-002 de OpenAI, necesitaría crear un índice con la dimensión 1536 para que coincida con la salida de ese modelo.
La spec configura cómo se debe implementar el índice. Para los índices sin servidor, define solo la nube y la región donde el índice debe ser alojado. Para los índices basados en POD, define el entorno donde se debe alojar el índice, el tipo de POD para usar y otras características del índice. Para obtener más información sobre la disponibilidad sin servidor y regional, consulte Índices de comprensión.
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 crear un índice basado en POD, defina pod en el objeto spec que contiene el environment donde se debe alojar el índice y el tamaño de podType y pods para usar. Muchos campos de configuración opcionales permiten un mayor control sobre los recursos de hardware y la disponibilidad. Para obtener más información sobre el propósito de estos campos, consulte la comprensión de los índices e índices de escala basados en POD.
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 ,
} ) ; El método createIndex emite una solicitud de creación a la API que regresa rápidamente, pero el índice resultante no está listo de inmediato para aumentar, consultar o realizar otras operaciones de datos. Puede usar el método describeIndex para averiguar el estado de un índice y ver si está listo para su 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'
// }
// } Si pasa la opción waitUntilReady , el cliente manejará las encuestas para actualizaciones de estado en un índice recién creado. La promesa devuelta por createIndex no se resolverá hasta que el estado del índice indique que está listo para manejar las operaciones de datos. Esto puede ser especialmente útil para las pruebas de integración, donde la creación de índice en un paso de configuración será seguida inmediatamente por las operaciones de datos.
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 ,
} ) ; Nota
Los índices sin servidor y de arranque no admiten colecciones.
A medida que usa Pinecone para más cosas, es posible que desee explorar diferentes configuraciones de índice con los mismos datos vectoriales. Las colecciones proporcionan una manera fácil de hacer esto. Vea otros métodos del cliente para trabajar con colecciones aquí.
Dado que tiene una colección 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 los índices basados en POD, puede especificar una sourceCollection desde la cual crear un índice. La colección debe estar en el mismo entorno que el í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' ,
} ,
} ,
} ) ;Cuando el nuevo índice está listo, debe contener todos los datos que estaban en la recopilación, listos para ser 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
// } Puede configurar los índices sin servidor y POD con deletionProtection . Cualquier índice con esta propiedad establecido en 'enabled' no podrá eliminarse. De forma predeterminada, deletionProtection se establecerá en 'disabled' si no se proporciona como parte de la solicitud createIndex . Para habilitar deletionProtection puede pasar el valor mientras llama 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 deshabilitar la protección de deleción, puede usar la operación configureIndex .
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . configureIndex ( 'deletion-protected-index' , {
deletionProtection : 'disabled' ,
} ) ; Puede crear o configurar los índices sin servidor y POD con etiquetas. Los índices pueden contener un número arbitrario de etiquetas que describen metadatos que desea adjuntos al objeto de índice en sí, como la propiedad del equipo, el proyecto o cualquier otra información 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
} ) ; Puede obtener la descripción de cualquier índice por nombre 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'
// }
// }Nota
Esta sección se aplica solo a los índices basados en POD. Con los índices sin servidor, no configura ningún recurso de cómputo o almacenamiento. En su lugar, los índices sin servidor se escala automáticamente en función del uso.
Puede ajustar el número de réplicas o escala a un tamaño de vaina más grande (especificado con podType ). Ver los índices basados en la cápsula de escala. No puede degradar el tamaño de la vaina o cambiar el tipo de vaina 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'
// }
// }Los índices se eliminan por nombre.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . deleteIndex ( 'sample-index' ) ; El comando listIndexes devuelve un objeto con una matriz de modelos de índice en 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',
// },
// },
// ],
// } Nota
Los índices sin servidor y de arranque no admiten colecciones.
Una colección es una copia estática de un índice basado en POD que puede usarse para crear copias de seguridad, crear copias de índices o realizar experimentos con diferentes configuraciones de índice. Para obtener más información sobre las colecciones de Pinecone, vea la comprensión de las colecciones.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . createCollection ( {
name : 'collection-name' ,
source : 'index-name' ,
} ) ; Esta llamada API debería volver rápidamente, pero la creación de una colección puede tomar de minutos a horas, dependiendo del tamaño del índice de origen y la configuración del índice. Use describeCollection para verificar el estado de una colección.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . deleteCollection ( 'collection-name' ) ; Puede usar listCollections para confirmar la eliminación.
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',
// } El comando listCollections devuelve un objeto con una matriz de modelos de colección en 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',
// },
// ];
// } Pinecone indexa las operaciones de soporte para trabajar con datos vectoriales utilizando operaciones como Upsert, consulta, búsqueda y eliminación.
Para realizar operaciones de datos en un índice, lo ataca utilizando el 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' ] ) ; El primer argumento es el nombre del índice al que se dirige. Hay un segundo argumento opcional para proporcionar una anulación de host índice. Proporcionar este segundo argumento le permite evitar el comportamiento predeterminado del SDK de resolver su host de índice a través del nombre del índice proporcionado. Puede encontrar su host de índice en la consola Pinecone, o utilizando las operaciones describeIndex o 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' ] ) ; Si está almacenando metadatos junto con sus valores vectoriales, puede pasar un parámetro de tipo a index() para obtener la typecking de typeck adecuada.
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 defecto, todas las operaciones de datos tienen lugar dentro del espacio de nombres predeterminado de '' . Si está trabajando con otros espacios de nombres no defensores, puede orientar el espacio de nombres encadenando una llamada al 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 espacios de nombres para obtener más información.
Pinecone espera que los registros insertados en los índices tengan el siguiente formulario:
type PineconeRecord = {
id : string ;
values : Array < number > ;
sparseValues ?: Array < number > ;
metadata ?: object ;
} ;Para aumentar algunos vectores, puede usar el cliente como así:
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 ) ; Ahora puede importar vectores en masa desde el almacenamiento de objetos. Import es una operación asincrónica de larga duración que importa un gran número de registros en un índice sin servidor de Pinecone.
Para importar vectores desde el almacenamiento de objetos, deben almacenarse en archivos parquet y cumplir con el formato de archivo necesario. El almacenamiento de su objeto también debe adherirse a la estructura del directorio necesaria.
El siguiente ejemplo importa vectores de un cubo de Amazon S3 en un índice sin servidor de 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"
// }Puede iniciar, cancelar y verificar el estado de todas o una (s) operación (s) de importación.
Notas:
Import solo funciona con índices sin servidorImport está en vista previa pública Al experimentar con operaciones de datos, a veces es útil saber cuántos registros/vectores se almacenan en cada espacio de nombres. En ese caso, apunte al índice y use el 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
// }El método de consulta acepta una gran cantidad de opciones. La dimensión del vector de consulta debe coincidir con la dimensión de su í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 ejemplo, para consultar por valores vectoriales, pasaría el parámetro vector en la configuración de opciones. Por el bien de la brevedad, este vector de consulta de ejemplo es pequeño (dimensión 2), pero en un caso de uso más realista, este vector de consulta sería una incrustación producida por un modelo. Mire el código de ejemplo para ver ejemplos más realistas de cómo 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
// }
// } Incluye opciones para includeMetadata: true o includeValues: true si necesita esta información. Por defecto, estos no se devuelven para mantener la carga útil de respuesta pequeña.
Recuerde que las operaciones de datos tienen lugar dentro del contexto de un namespace , por lo que si está trabajando con los espacios de nombres y no ve los resultados esperados, debe verificar que se dirige al espacio de nombres correcto con su 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 ] } ) ; Puede consultar utilizando los valores vectoriales de un registro existente en el índice pasando una ID de registro. Tenga en cuenta que el registro con la ID especificada puede estar en la respuesta de esta operación.
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' } ) ; Si está trabajando con vectores densos dispersos, puede agregar valores de vectores dispersos para realizar una búsqueda 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 ,
} ) ; Es posible que desee actualizar values vectoriales, sparseValues o metadata . Especifique la ID y el valor de atributo que desea actualizar.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'imdb-movies' ) ;
await index . update ( {
id : '18593' ,
metadata : { genre : 'romance' } ,
} ) ; El método listPaginated se puede usar para enumerar las ID de registro que coinciden con un prefijo de identificación particular en un formato paginado. Con una asignación inteligente de ID de registro, esto se puede utilizar para ayudar a modelar relaciones jerárquicas entre diferentes registros, como cuando hay incrustaciones para múltiples fragmentos o fragmentos relacionados con el mismo documento.
Notas:
prefix , el prefijo predeterminado es una cadena vacía, que devuelve todas las ID de vectores en su índice100 ID de vectores si no se especifica ningún limit . En consecuencia, si hay menos de 100 ID de vectores que coincidan con un prefix dado en su índice, y usted no especifica un limit , su paginationToken estará undefined El siguiente ejemplo muestra cómo obtener ambas páginas de ID de vectores para vectores cuyas ID contienen el prefijo doc1# , suponiendo que un limit del documento 3 y doc1 se divida en 4 vectores.
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 conveniencia hay varios métodos relacionados con el eliminación. Puede verificar los resultados de una operación de eliminación tratando de fetch() un registro o observando el resumen del índice con 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: La eliminación por filtro de metadatos solo se aplica a los índices basados en POD.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'albums-database' ) ;
await index . deleteMany ( { genre : 'rock' } ) ; NOTA
Los índices en el entorno de GCP-Starter no admiten espacios de nombres.
Para atascar todo en el espacio de nombres dirigido, use el 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 ( ) ; Si no especifica un espacio de nombres, se eliminarán los registros en el espacio de nombres predeterminado '' .
Interactuar con la API de inferencia de Pinecone (actualmente en la vista previa pública). La API de inferencia de Pinecone es un servicio que le brinda acceso a modelos de inferencia alojados en la infraestructura de Pinecone.
Notas:
Modelos compatibles:
Envíe texto a la API de inferencia de Pinecone para generar integridades para documentos y 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 en orden de relevancia descendente contra una consulta.
Nota: La score representa la medida absoluta de relevancia de una consulta y un par de pasaje determinado. Normalizado entre [0, 1], la score representa cuán relevantes están un elemento y una consulta específicos, con puntajes más cercanos a 1 que indican una mayor relevancia.
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 }
//} Todas las pruebas tienen lugar automáticamente en CI y se configuran utilizando acciones y flujos de trabajo de GitHub, ubicado en el directorio .github de este repositorio.
Ver contribuyente.md para obtener más información.
