pinecone ts client
v4.0.0
Dies ist der offizielle Node.js SDK für PineCone, der in TypeScript geschrieben wurde.
v0.x aktualisieren, lesen Sie den V1 -Migrationshandbuch .v1.x aktualisieren, lesen Sie den V2 -Migrationshandbuch .Die in diesem Readme gezeigten Ausschnitte sollen präzise sein. Realistischere Beispiele finden Sie in folgenden Beispielen:
2.x auf 3.x In diesem Update gibt es eine Breaking -Änderung, bei der der Vorgang der configureIndex beteiligt ist. Die Struktur des Objekts, das bei der Konfiguration eines Index übergeben wurde, hat sich geändert, um deletionProtection einzuschließen. Die podType und replicas -Felder können jetzt über das spec.pod -Objekt aktualisiert werden. Eine Beispiel für den Code finden Sie auf POD-basierte Indizes.
2.x : In dieser Version wurden viele Änderungen vorgenommen, um das neue serverlose Indexangebot von PineCone zu unterstützen. Die Änderungen werden im V2 -Migrationshandbuch ausführlich behandelt. Serverlose Indizes sind nur in 2.x Release -Versionen oder mehr verfügbar.1.x : Diese Veröffentlichung hat den SDK offiziell aus der Beta herausgezogen, und es gibt eine Reihe von Bruchänderungen, die beim Upgrade von einer 0.x -Version angegangen werden müssen. Weitere Informationen finden Sie im V1 -Migrationshandbuch . Das Pinecone TypeScript SDK ist mit TypeScript> = 4.1 und Knoten> = 18.x kompatibel.
npm install @pinecone-database/pinecone
Das Pnecone TypeScript-SDK ist nur für die Verwendung von Server-Seite vorgesehen. Wenn Sie den SDK innerhalb eines Browser -Kontexts verwenden, können Sie Ihre API -Schlüssel (en) freilegen . Wenn Sie das SDK für die Produktion in einem Browser eingesetzt haben, drehen Sie bitte Ihre API -Schlüssel.
Ein API -Schlüssel ist erforderlich, um den Client zu initialisieren. Es kann über eine Umgebungsvariable oder in Code über ein Konfigurationsobjekt übergeben werden. Holen Sie sich einen API -Schlüssel in der Konsole.
Die Umgebungsvariable, die zur Konfiguration des API -Schlüssels für den Client verwendet wird, ist Folgendes:
PINECONE_API_KEY= " your_api_key " PINECONE_API_KEY ist die einzige erforderliche Variable. Wenn diese Umgebungsvariable festgelegt ist, benötigt der Client -Konstruktor keine zusätzlichen Argumente.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ; Wenn Sie es vorziehen, die Konfiguration in Code zu übergeben, akzeptiert der Konstruktor ein Konfigurationsobjekt, das den apiKey -Wert enthält. Dies ist das Objekt, in dem Sie Eigenschaften wie maxRetries (Standardeinstellungen an 3 ) für Wiederholungsvorgänge ( upsert , update und configureIndex ) übergeben würden.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( {
apiKey : 'your_api_key' ,
maxRetries : 5 ,
} ) ; Wenn für Ihr Netzwerk -Setup Sie über einen Proxy mit PineCone interagieren müssen, können Sie einen benutzerdefinierten ProxyAgent aus der undici -Bibliothek übergeben. Im Folgenden finden Sie ein Beispiel dafür, wie ein undici ProxyAgent erstellt wird, das den Netzwerkverkehr über einen mitm -Proxy -Server leitet, während Sie den Endpunkt von PineCone /indexes treffen.
HINWEIS: Die folgende Strategie basiert auf der nativen fetch -Implementierung des Knotens, die in Node V16 freigegeben und in Node V21 stabilisiert wurde. Wenn Sie Knotenversionen 18-21 ausführen, können Sie Probleme haben, die sich aus der Instabilität der Funktion ergeben. Derzeit sind keine Probleme im Zusammenhang mit dem Proxying im Knoten V18+bekannt.
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 ) ;
} ) ; Um einen serverlosen Index zu erstellen, müssen Sie einen name , dimension und spec angeben. Die dimension zeigt die Größe der Vektoren an, die Sie im Index speichern möchten. Wenn Ihre Absicht beispielsweise darin bestand, Einbettungen (Vektoren) zu speichern und zu abfragen, das mit dem openAi-Modell von textembedding-ada-ada-002 generiert wurde, müssten Sie einen Index mit der Dimension 1536 erstellen, die mit der Ausgabe dieses Modells übereinstimmt.
Die spec konfiguriert, wie der Index bereitgestellt werden soll. Für serverlose Indizes definieren Sie nur die Cloud und Region, in der der Index gehostet werden sollte. Für POD-basierte Indizes definieren Sie die Umgebung, in der der Index gehostet werden soll, die zu verwendende Pod-Typ und die zu verwendende Größe und andere Indexeigenschaften. Weitere Informationen zur serverlosen und regionalen Verfügbarkeit finden Sie unter Verständnis -Indizes.
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' } ,
} ) ; Um einen podbasierten Index zu erstellen, definieren Sie pod im spec , das die environment enthält, in der der Index gehostet werden soll, sowie die zu verwendende podType und pods -Größe. Viele optionale Konfigurationsfelder ermöglichen eine höhere Kontrolle über Hardwareressourcen und Verfügbarkeit. Weitere Informationen zum Zweck dieser Felder finden Sie unter Verständnis von Indizes und Skala pod-basierten Indizes.
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 ,
} ) ; Die createIndex -Methode gibt eine Anforderung für die Erstellung der API aus, die schnell zurückgibt. Der resultierende Index ist jedoch nicht sofort bereit, andere Datenvorgänge zu verlangen, abzufragen oder auszuführen. Sie können mit der describeIndex den Status eines Index herausfinden und feststellen, ob sie zur Verwendung bereit ist.
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'
// }
// } Wenn Sie die Option waitUntilReady übergeben, wird der Kunde die Umfragen für Statusaktualisierungen in einem neu erstellten Index behandeln. Das von createIndex zurückgegebene Versprechen wird erst dann aufgelöst, wenn der Indexstatus angibt, dass es bereit ist, Datenvorgänge zu verarbeiten. Dies kann besonders für Integrationstests nützlich sein, bei denen die Indexerstellung in einem Setup -Schritt sofort von Datenvorgängen folgt.
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 ,
} ) ; Notiz
Serverlose und Starterindizes unterstützen keine Sammlungen.
Wenn Sie PineCone für weitere Dinge verwenden, möchten Sie möglicherweise verschiedene Indexkonfigurationen mit denselben Vektordaten untersuchen. Sammlungen bieten eine einfache Möglichkeit, dies zu tun. Weitere Kundenmethoden finden Sie hier mit Sammlungen.
Da Sie eine vorhandene Sammlung haben:
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'
// } Hinweis: Für POD-basierte Indizes können Sie eine sourceCollection angeben, aus der ein Index erstellt werden kann. Die Sammlung muss in der gleichen Umgebung wie der Index sein.
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' ,
} ,
} ,
} ) ;Wenn der neue Index fertig ist, sollte er alle Daten enthalten, die in der Sammlung enthalten waren, bereit, abfragt zu werden.
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
// } Sie können sowohl serverlose als auch POD -Indizes mit deletionProtection konfigurieren. Jeder Index mit dieser Eigenschaft, die auf 'enabled' eingestellt ist, kann nicht gelöscht werden. Standardmäßig wird deletionProtection auf 'disabled' festgelegt, wenn sie nicht als Teil der createIndex -Anforderung angegeben sind. So können Sie den Wert deletionProtection , während Sie den Wert beim Aufrufen createIndex übergeben können.
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' ,
} ,
} ,
} ) ; Um den Löschschutz zu deaktivieren, können Sie die configureIndex -Operation verwenden.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . configureIndex ( 'deletion-protected-index' , {
deletionProtection : 'disabled' ,
} ) ; Sie können serverlose und POD -Indizes mit Tags erstellen oder konfigurieren. Indizes können eine willkürliche Anzahl von Tags enthalten, die Metadaten beschreiben, die Sie dem Indexobjekt selbst beigefügt würden, wie z. B. Teambesitz, Projekt oder andere relevante Informationen.
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
} ) ; Sie können die Beschreibung eines beliebigen Index mit Namen unter Verwendung von describeIndex abrufen.
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'
// }
// }Notiz
Dieser Abschnitt gilt nur für POD-basierte Indizes. Mit serverlosen Indizes konfigurieren Sie keine Rechen- oder Speicherressourcen. Stattdessen basiert die Serverless Indizes Scale automatisch basierend auf der Nutzung.
Sie können die Anzahl der Repliken oder die Skalierung an eine größere Pod -Größe (angegeben mit podType ) anpassen. Siehe skalische POD-basierte Indizes. Sie können die SchOD -Größe nicht herabstufen oder den Basistyp des Basis ändern.
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'
// }
// }Indizes werden namentlich gelöscht.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . deleteIndex ( 'sample-index' ) ; Der Befehl listIndexes gibt ein Objekt mit einem Array von Indexmodellen unter indexes zurück.
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',
// },
// },
// ],
// } Notiz
Serverlose und Starterindizes unterstützen keine Sammlungen.
Eine Sammlung ist eine statische Kopie eines POD-basierten Index, mit dem Backups erstellt, Kopien von Indizes erstellt oder Experimente mit unterschiedlichen Indexkonfigurationen durchgeführt werden können. Weitere Informationen zu Pinecone -Sammlungen finden Sie unter Verständniskollektionen.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . createCollection ( {
name : 'collection-name' ,
source : 'index-name' ,
} ) ; Dieser API -Anruf sollte schnell zurückkehren, aber die Erstellung einer Sammlung kann je nach Größe des Quellindex und der Konfiguration des Index von Minuten bis Stunden dauern. Verwenden Sie describeCollection , um den Status einer Sammlung zu überprüfen.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
await pc . deleteCollection ( 'collection-name' ) ; Sie können listCollections verwenden, um die Löschung zu bestätigen.
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',
// } Der Befehl listCollections gibt ein Objekt mit einer Reihe von Sammelmodellen unter collections zurück.
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 -Indizes unterstützen Vorgänge für die Arbeit mit Vektordaten unter Verwendung von Vorgängen wie Upsert, Abfrage, Abrufen und Löschen.
Um Datenoperationen in einem Index durchzuführen, zielen Sie mit der index an.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'test-index' ) ;
// Now perform index operations
await index . fetch ( [ '1' ] ) ; Das erste Argument ist der Name des Index, den Sie abzielen. Es gibt ein optionales zweites Argument für die Bereitstellung eines Index -Host -Override. Durch die Bereitstellung dieses zweiten Arguments können Sie das Standardverhalten des SDK über den angegebenen Indexnamen umgehen. Sie finden Ihren Index -Host in der Pinecone -Konsole oder mithilfe der Operationen describeIndex oder 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' ] ) ; Wenn Sie Metadaten neben Ihren Vektorwerten speichern, können Sie einen Typ -Parameter an index() übergeben, um ordnungsgemäße TypeScript -Typen zu erhalten.
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 } ` )
} Standardmäßig finden alle Datenoperationen im Standard -Namespace von '' statt. Wenn Sie mit anderen nicht defekten Namespaces zusammenarbeiten, können Sie den Namespace ansprechen, indem Sie einen Anruf an namespace() verkettet.
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' ] ) ;Weitere Informationen finden Sie unter Namensspaces.
PineCone erwartet, dass Datensätze, die in die Indizes eingefügt wurden, das folgende Formular aufweisen:
type PineconeRecord = {
id : string ;
values : Array < number > ;
sparseValues ?: Array < number > ;
metadata ?: object ;
} ;Um einige Vektoren zu verbessern, können Sie den Kunden wie SO verwenden:
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 ) ; Sie können jetzt Vektoren und massenhaft aus dem Objektspeicher importieren. Import ist ein langjähriger asynchroner Vorgang, der eine große Anzahl von Datensätzen in einen serverlosen Pnecone-Index importiert.
Um Vektoren aus dem Objektspeicher zu importieren, müssen sie in Parkettdateien gespeichert und das erforderliche Dateiformat einhalten. Ihr Objektspeicher muss auch an die erforderliche Verzeichnisstruktur einhalten.
Das folgende Beispiel importiert Vektoren aus einem Amazon S3 -Bucket in einen serverlosen Pinecone -Index:
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"
// }Sie können den Status aller oder ein Importvorgang (en) starten, abbrechen und überprüfen.
Anmerkungen:
Import nur mit serverlosen IndizesImport ist in der öffentlichen Vorschau Beim Experimentieren mit Datenoperationen ist es manchmal hilfreich zu wissen, wie viele Datensätze/Vektoren in jedem Namespace gespeichert sind. In diesem Fall zielen Sie auf den Index und verwenden Sie den Befehl 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
// }Die Abfragemethode akzeptiert eine große Anzahl von Optionen. Die Dimension des Abfragevektors muss mit der Dimension Ihres Index übereinstimmen.
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 ;
} ; Um beispielsweise nach Vektorwerten abzufragen, würden Sie den vector in der Optionskonfiguration übergeben. Aus Kürze ist dieser Beispiel -Abfragevektor winzig (Dimension 2), aber in einem realistischeren Anwendungsfall wäre dieser Abfragevektor eine Einbettung, die von einem Modell ausgegeben wurde. Sehen Sie sich den Beispielcode an, um realistischere Beispiele für die Verwendung query zu sehen.
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
// }
// } Sie geben Optionen ein, die includeMetadata: true oder includeValues: true wenn Sie diese Informationen benötigen, einbeziehen. Standardmäßig werden diese nicht zurückgegeben, um die Antwortnutzlast gering zu halten.
Denken Sie daran, dass Datenoperationen im Kontext eines namespace stattfinden. Wenn Sie also mit Namespaces arbeiten und keine erwarteten Ergebnisse sehen, sollten Sie überprüfen, ob Sie den richtigen Namespace mit Ihrer Abfrage ansprechen.
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 ] } ) ; Sie können die Vektorwerte eines vorhandenen Datensatzes im Index abfragen, indem Sie eine Datensatz -ID übergeben. Bitte beachten Sie, dass der Datensatz mit der angegebenen ID in der Antwort dieser Operation möglicherweise enthalten ist.
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' } ) ; Wenn Sie mit spärlichen Vektoren arbeiten, können Sie spärliche Vektorwerte hinzufügen, um eine Hybridsuche durchzuführen.
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 ,
} ) ; Möglicherweise möchten Sie die values , sparseValues oder metadata aktualisieren. Geben Sie die ID und den Attributwert an, den Sie aktualisieren möchten.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'imdb-movies' ) ;
await index . update ( {
id : '18593' ,
metadata : { genre : 'romance' } ,
} ) ; Die listPaginated -Methode kann verwendet werden, um Datensatz -IDs zu listen, die mit einem bestimmten ID -Präfix in einem paginierten Format übereinstimmen. Mit der cleveren Zuordnung von Datensatz -IDs kann dies verwendet werden, um hierarchische Beziehungen zwischen verschiedenen Datensätzen zu unterstützen, z.
Anmerkungen:
prefix angeben, ist das Standardpräfix eine leere Zeichenfolge, die alle Vektor -IDs in Ihrem Index zurückgibt100 Vektor -IDs, wenn keine limit angegeben ist. Wenn es weniger als 100 Vektor -IDs gibt, die einem bestimmten prefix in Ihrem Index entsprechen und Sie keine limit angeben, wird Ihr paginationToken undefined sein Das folgende Beispiel zeigt, wie beide Seiten von Vektor -IDs für Vektoren abgerufen werden, deren IDs das Präfix doc1# enthalten, wobei ein limit von 3 und doc1 -Dokument in 4 Vektoren eingestuft wird.
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' ] ) ; Zur Bequemlichkeit gibt es mehrere Methoden im Zusammenhang mit Delete. Sie können die Ergebnisse eines Löschvorgangs überprüfen, indem Sie versuchen, einen Datensatz fetch() oder die Indexzusammenfassung mit describeIndexStats() zu betrachten, oder die Indexzusammenfassung anzusehen.
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' ] ) ;HINWEIS: Das Löschen nach Metadatenfilter gilt nur für POD-basierte Indizes.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'albums-database' ) ;
await index . deleteMany ( { genre : 'rock' } ) ; NOTIZ
Indizes in der GCP-Starter-Umgebung unterstützen keine Namenspaces.
Verwenden Sie die deleteAll -Methode, um alles im gezielten Namespace zu erfassen.
import { Pinecone } from '@pinecone-database/pinecone' ;
const pc = new Pinecone ( ) ;
const index = pc . index ( 'my-index' ) ;
await index . namespace ( 'foo-namespace' ) . deleteAll ( ) ; Wenn Sie keinen Namespace angeben, werden die Datensätze im Standard -Namespace '' gelöscht.
Interagieren Sie mit der Inferenz -API von Pinecone (derzeit in der öffentlichen Vorschau). Die Pinecone -Inferenz -API ist ein Dienst, mit dem Sie Zugriff auf Inferenzmodelle erhalten, die auf der Infrastruktur von Pinecone gehostet werden.
Anmerkungen:
Unterstützte Modelle:
Senden Sie den Text an die Inferenz -API von PineCone, um Einbettungen für Dokumente und Abfragen zu generieren.
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 >> Dokumente in absteigender Relevanzverordnung gegen eine Frage.
Hinweis: Die score repräsentiert das absolute Maß für die Relevanz eines bestimmten Abfrage- und Passagepaars. Die zwischen [0, 1] normalisierte score stellt dar, wie eng relevant ein bestimmtes Element und eine bestimmte Abfrage sind, wobei die Werte näher an 1 eine höhere Relevanz anzeigen.
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 }
//} Alle Tests erfolgen automatisch in CI und werden mit GitHub -Aktionen und Workflows konfiguriert, die sich im .github -Verzeichnis dieses Repo befinden.
Weitere Informationen finden Sie unter Beitrags.md.
