pinecone scala Download - pinecone scala Source Code Download

Tinecone Scala Client

Dies ist ein intuitiver Async-vollwertiger Scala-Client für die Pinecone-API, das alle verfügbaren Index-, Vektor-, Sammlung-, Inferenz- und Assistenzvorgänge/-endpunkte unterstützt, die in zwei praktischen Diensten, die PineConeVectorService und PineConeIndexService bezeichnet werden, bereitgestellt werden. Die unterstützten Anrufe sind:

Vektoroperationen : Beschreiben SieIndexstats, Abfrage, Löschen, Abrufen, Update und Upsert
Sammlungsoperationen : ListCollections, CreateCollection, Beschreibung und DeleteCollection
Indexoperationen : ListIndexes, createIndex, beschreibendex, deleteIndex und configureIndex
Inferenzoperationen : Einbettungsmittel, Umrangern und Evaluieren
Assistentenoperationen : Listenassistente, Createassistant, Beschreibung, DeleteAssistant, Listfiles, Uploadfile, Beschreibung, DeleteFile, ChatWithassistant
- Diese Operationen werden von zwei Diensten bereitgestellt: PineconeAssistantService und PineconeAssistantFileService

Beachten Sie, dass die Service -Funktionsnamen genau den API -Endpunkttiteln/-beschreibungen mit Camelcase übereinstimmen, um mit der Pinecone -API -Benennungsnamen übereinzustimmen. Außerdem zielten wir an play-ws-standalone-json dass die LIB mit den wenigsten Abhängigkeiten in sich geschlossen ist play-ahc-ws-standalone

✔️ WICHTIG : Dies ist eine "in der Gemeinschaft gepflegte" Bibliothek und hat als solche keinen Zusammenhang mit Tinecone Company.

Schauen Sie sich einen Artikel über den LIB/Client auf Medium an. Wenn Sie sofort praktische Beispiele sehen möchten, gehen Sie zu den Pinecone-Beispielen oder zu OpenAI + Pinecone-Beispielen Modulen.

Installation

Die derzeit unterstützten Scala -Versionen sind 2,12, 2,13 und 3 .

Um die Bibliothek zu ziehen, müssen Sie Ihrem Build die folgende Abhängigkeit hinzufügen.

 "io.cequence" %% "pinecone-scala-client" % "1.2.2"

oder pom.xml (wenn Sie Maven verwenden)

 <dependency>
    <groupId>io.cequence</groupId>
    <artifactId>pinecone-scala-client_2.12</artifactId>
    <version>1.2.2</version>
</dependency>

Konfiguration

Env. Variablen: PINECONE_SCALA_CLIENT_API_KEY und PINECONE_SCALA_CLIENT_ENV wenn POD-basierter Dienst verwendet wird
Dateikonfiguration (Standard): Pnecone-scala-client.conf

Verwendung? ‍?

Ia. PineconeIndexService erhalten

Zuerst müssen Sie einen implizite Ausführungskontext sowie Akka Materializer, z. B. AS, bereitstellen

  implicit val ec = ExecutionContext .global
  implicit val materializer = Materializer ( ActorSystem ())

Anschließend können Sie auf eine der folgenden Arten einen Dienst (POD oder serverless basieren) erhalten.

Standardkonfiguration (erwartet, dass Env. Variable (en) gemäß den im Abschnitt Config definierten Variablen festgelegt wird)

  import io . cequence . pineconescala . service . PineconeIndexServiceFactory . FactoryImplicits

  val service = PineconeIndexServiceFactory ().asOne

Benutzerdefinierte Konfiguration

  val config = ConfigFactory .load( " path_to_my_custom_config " )
  val service = PineconeIndexServiceFactory (config).asOne

Ohne Konfiguration für POD -basierte Dienst (mit ENV) - erstellt eine Instanz von PineconePodBasedIndexService

  val service  = PineconeIndexServiceFactory (
    apiKey = " your_api_key " ,
    environment = " your_env " // e.g. "northamerica-northeast1-gcp
  )

Ohne Konfiguration für serverlosen Dienst - erstellt eine Instanz von PineconeServerlessIndexService

  val service = PineconeIndexServiceFactory (
    apiKey = " your_api_key "
  )

Ib. Erhalten von PineconeVectorService

Wie bei PineconeIndexService müssen Sie zunächst implizite Ausführungskontext und Akka Materializer bereitstellen. Dann können Sie einen Dienst auf eine der folgenden Arten erhalten.

Standardkonfiguration (erwartet, dass Env. Variable (en) im Abschnitt Config festgelegt wird). Beachten Sie, dass die Fabrik None zurückgibt, wenn der Index mit einem angegebenen Namen nicht verfügbar ist.

  PineconeVectorServiceFactory ( " index_name " ).map { serviceOption =>
    val service = serviceOption.getOrElse(
      throw new Exception ( s " Index with a given name does not exist. " )
    )
    // do something with the service
  }

IC. Erhalten von PineconeInferenceService

Wie bei PineconeIndexService müssen Sie zunächst implizite Ausführungskontext und Akka Materializer bereitstellen. Dann können Sie einen Dienst auf eine der folgenden Arten erhalten.

Standardkonfiguration

  val service = PineconeInferenceServiceFactory ()

Benutzerdefinierte Konfiguration

  val config = ConfigFactory .load( " path_to_my_custom_config " )
  val service = PineconeInferenceServiceFactory (config)

Direkt mit Api-Key

  val service = PineconeInferenceServiceFactory (
    apiKey = " your_api_key "
  )

Ausweis. Erhalten von PineconeAssistantService

Standardkonfiguration

  val service = PineconeAssistantServiceFactory ()

Benutzerdefinierte Konfiguration

  val config = ConfigFactory .load( " path_to_my_custom_config " )
  val service = PineconeAssistantServiceFactory (config)

Direkt mit Api-Key

  val service = PineconeAssistantServiceFactory (
    apiKey = " your_api "
  )

Dh. Erhalten von PineconeAssistantFileService

Standardkonfiguration

  val service = PineconeAssistantFileServiceFactory ()

Benutzerdefinierte Konfiguration

  val config = ConfigFactory .load( " path_to_my_custom_config " )
  val service = PineconeAssistantFileServiceFactory (config)

Direkt mit Api-Key

  val service = PineconeAssistantFileServiceFactory (
    apiKey = " your_api "
  )

Ii. Aufrufen von Funktionen

Die vollständige Dokumentation jedes Anrufs mit seinen jeweiligen Eingängen und Einstellungen finden Sie in PineConeVectorService und PineconeIndexService. Da alle Anrufe asynchronisiert sind, geben sie Antworten zurück, die in Future eingepackt sind.

Beispiele:

Indexoperationen

Listenindizes

  pineconeIndexService.listIndexes.map(indexes =>
    indexes.foreach(println)
  )

Index erstellen (mit Standardeinstellungen)

  import io . cequence . pineconescala . domain . response . CreateResponse

  pineconeIndexService.createIndex(
    name = " auto-gpt-test " ,
    dimension = 1536
  ).map {
    case CreateResponse . Created => println( " Index successfully created. " )
    case CreateResponse . BadRequest => println( " Index creation failed. Request exceeds quota or an invalid index name. " )
    case CreateResponse . AlreadyExists => println( " Index with a given name already exists. " )
  }

Beschreiben Sie den Index

  pineconeIndexService.describeIndex( " index_name " ).map(indexInfo =>
    // if not found, indexInfo will be None    
    println(indexInfo)
  )

Index löschen

  import io . cequence . pineconescala . domain . response . DeleteResponse

  pineconeIndexService.deleteIndex( " index_name " ).map {
    case DeleteResponse . Deleted => println( " Index successfully deleted. " )
    case DeleteResponse . NotFound => println( " Index with a given name not found. " )
  }

Index konfigurieren

  import io . cequence . pineconescala . domain . response . ConfigureIndexResponse

  pineconeIndexService.configureIndex(
    name = " index_name " ,
    replicas = Some ( 2 ),
    pod_type = Some ( PodType .p1_x2)
  ).map { 
    case ConfigureIndexResponse . Updated => println( " Index successfully updated. " )
    case ConfigureIndexResponse . BadRequestNotEnoughQuota => println( " Index update failed. Not enough quota. " )
    case ConfigureIndexResponse . NotFound => println( " Index with a given name not found. " )
  }

Sammeloperationen

Auflistungssammlungen

  pineconeIndexService.listCollections.map(collectionNames =>
    println(collectionNames.mkString( " , " ))
  )

Sammlung erstellen

  import io . cequence . pineconescala . domain . response . CreateResponse

  pineconeIndexService.createCollection(
    name = " collection_name " ,
    source = " index_name "
  ).map {
    case CreateResponse . Created => println( " Collection successfully created. " )
    case CreateResponse . BadRequest => println( " Collection creation failed. Request exceeds quota or an invalid collection name. " )
    case CreateResponse . AlreadyExists => println( " Collection with a given name already exists. " )
  }

Beschreiben Sie die Sammlung

  pineconeIndexService.describeCollection( " collection_name " ).map(collectionInfo =>
    // if not found, collectionInfo will be None
    println(collectionInfo)
  )

Sammlung löschen

  import io . cequence . pineconescala . domain . response . DeleteResponse

  pineconeIndexService.deleteCollection( " collection_name " ).map {
    case DeleteResponse . Deleted => println( " Collection successfully deleted. " )
    case DeleteResponse . NotFound => println( " Collection with a given name not found. " )
  }

Vektoroperationen

Steifter

  val dimension = 1536

  pineconeVectorService.upsert(
    vectors = Seq (
      PVector (
        id = " 666 " ,
        values = Seq .fill(dimension)( Random .nextDouble),
        metadata = Map (
          " is_relevant " -> " not really but for testing it's ok, you know " ,
          " food_quality " -> " brunches are perfect but don't go there before closing time "
        )
      ),
      PVector (
        id = " 777 " ,
        values = Seq .fill(dimension)( Random .nextDouble),
        metadata = Map (
          " is_relevant " -> " very much so " ,
          " food_quality " -> " burritos are the best! "
        )
      )
    ),
    namespace = " my_namespace " ,
  ).map(vectorUpsertedCount =>
    println( s " Upserted $vectorUpsertedCount vectors. " )
  )

Aktualisieren

  val fetchedValues = ... // vectors fetched from somewhere 

  pineconeVectorService.update(
    id = " 777 " ,
    namespace = " my_namespace " ,
    values = fetchedValues.map(_ / 100 ), // divide fetched values by 100
    sparseValues = Some ( SparseVector (
      indices = Seq ( 1 , 2 , 3 ),
      values = Seq ( 8.8 , 7.7 , 2.2 )
    )),
    setMetaData = Map (
      " solid_info " -> " this is the source of the truth "
    )
  ).map(_ =>
    println( s " Vectors updated. " )
  )

Abfragen mit Standardeinstellungen

  pineconeVectorService.query(
    vector = Seq .fill( 1536 )( Random .nextDouble), // some values/embeddings
    namespace = " my_namespace "
  ).map { queryResponse =>
    queryResponse.matches.foreach { matchInfo =>
      println( s " Matched vector id: ${matchInfo.id} " )
      println( s " Matched vector values: ${matchInfo.values.take( 20 ).mkString( " , " )} .. " )
      println( s " Matched vector score: ${matchInfo.score} " )
      println( s " Matched vector metadata: ${matchInfo.metadata} " )
    }
  }

Abfragen mit benutzerdefinierten Einstellungen

  pineconeVectorService.query(
    vector = Seq .fill( 1536 )( Random .nextDouble), // some values/embeddings
    namespace = " my_namespace " ,
    settings = QuerySettings (
      topK = 5 ,
      includeValues = true ,
      includeMetadata = true
    )
  ).map { queryResponse =>
    queryResponse.matches.foreach { matchInfo =>
      println( s " Matched vector id: ${matchInfo.id} " )
      println( s " Matched vector values: ${matchInfo.values.take( 20 ).mkString( " , " )} .. " )
      println( s " Matched vector score: ${matchInfo.score} " )
      println( s " Matched vector metadata: ${matchInfo.metadata} " )
    }
  }

Bringen

  pineconeVectorService.fetch(
    ids = Seq ( " 666 " , " 777 " ),
    namespace = " my_namespace "
  ).map { fetchResponse =>
    fetchResponse.vectors.values.map { pVector =>
      println( s " Fetched vector id: ${pVector.id} " )
      println( s " Fetched vector values: ${pVector.values.take( 20 ).mkString( " , " )} .. " )
      println( s " Fetched vector metadata: ${pVector.metadata} " )
   }
}

Durch ID (s) löschen

  pineconeVectorService.delete(
    ids = Seq ( " 666 " , " 777 " ),
    namespace = " my_namespace "
  ).map(_ =>
    println( " Vectors deleted " )
  )

Alle löschen

  pineconeVectorService.deleteAll(
    namespace = " my_namespace "
  ).map(_ =>
    println( " All vectors deleted " )
  )

Beschreiben Sie Indexstatistiken

  pineconeVectorService.describeIndexStats.map(stats =>
    println(stats)      
  )

Inferenzvorgänge

Einbettung erzeugen

  pineconeInferenceService.createEmbeddings(
    Seq ( " The quick brown fox jumped over the lazy dog " )
  ).map { embeddings =>
    println(embeddings.data.mkString( " n " ))
  }

Dokumente / Stücke noch einmal

  pineconeInferenceService.rerank(
    query = " The tech company Apple is known for its innovative products like the iPhone. " ,
    documents = Seq (...)  
  ).map(
    _.data.foreach(println)
  )

Q & A bewerten

  pineconeInferenceService.evaluate(
    question = " What are the capital cities of France, England and Spain? " ,
    answer = " Paris is a city of France and Barcelona of Spain " ,
    groundTruthAnswer = " Paris is the capital city of France, London of England and Madrid of Spain "
  ).map { response =>
    println(response)
  }

** Assistentenbetrieb **

Assistenten auflisten

  pineconeAssistantService.listAssistants.map(assistants =>
    println(assistants.mkString( " , " ))
  )

Assistent erstellen

  import io . cequence . pineconescala . domain . response . CreateResponse

  pineconeAssistantService.createAssistant(
    name = " assistant_name " ,
    description = " assistant_description " ,
    assistantType = " assistant_type "
  ).map {
    case CreateResponse . Created => println( " Assistant successfully created. " )
    case CreateResponse . BadRequest => println( " Assistant creation failed. Request exceeds quota or an invalid assistant name. " )
    case CreateResponse . AlreadyExists => println( " Assistant with a given name already exists. " )
  }

Beschreiben Sie Assistent

  pineconeAssistantService.describeAssistant( " assistant_name " ).map(assistant =>
    // if not found, assistant will be None
    println(assistant)
  )

Assistent löschen

  import io . cequence . pineconescala . domain . response . DeleteResponse

  pineconeAssistantService.deleteAssistant( " assistant_name " ).map {
    case DeleteResponse . Deleted => println( " Assistant successfully deleted. " )
    case DeleteResponse . NotFound => println( " Assistant with a given name not found. " )
  }

Listen Sie Assistant -Dateien auf

  pineconeAssistantService.listFiles( " assistant_name " ).map(files =>
    println(files.mkString( " , " ))
  )

Assistentendatei hochladen

  import io . cequence . pineconescala . domain . response . CreateResponse

  pineconeAssistantService.uploadFile(
    assistantName = " assistant_name " ,
    filePath = " path_to_file "
  ).map {
    case CreateResponse . Created => println( " File successfully uploaded. " )
    case CreateResponse . BadRequest => println( " File upload failed. Request exceeds quota or an invalid file path. " )
    case CreateResponse . AlreadyExists => println( " File with a given name already exists. " )
  }

Beschreiben Sie die Assistenzdatei

  pineconeAssistantService.describeFile( " assistant_name " , " file_name " ).map(file =>
    // if not found, file will be None
    println(file)
  )

Chatten Sie mit einem Assistenten

  pineconeAssistantService.chatWithAssistant(
    " assistant_name " ,
    " What is the maximum height of a red pine? "
  ).map(response =>
    println(response)
  )

Demo

Für bereitgestellte Demos pls. Siehe separate Module:

Pinecone Scala Demo - zeigt, wie man Pinecone -Vektor-, Index- und Sammeloperationen verwendet
Pinecone + OpenAI Scala Demo - zeigt, wie man OpenAI -Einbettung in Tinecone erzeugt und speichert und anschließend befragt

FAQ?

Ich habe eine Ausnahme in der Zeitüberschreitung. Wie kann ich die Timeout -Einstellung ändern?
Sie können dies entweder durch die timeouts -Param an Pinecone{Vector,Index}ServiceFactory oder, wenn Sie Ihre eigene Konfigurationsdatei verwenden, übergeben, können Sie sie einfach als:

 pinecone-scala-client {
    timeouts {
        requestTimeoutSec = 200
        readTimeoutSec = 200
        connectTimeoutSec = 5
        pooledConnectionIdleTimeoutSec = 60
    }
}

Ich habe eine Ausnahme wie com.typesafe.config.ConfigException$UnresolvedSubstitution: pinecone-scala-client.conf @ jar:file:.../io/cequence/pinecone-scala-client_2.13/1.2.2/pinecone-scala-client_2.13-1.2.2.jar!/pinecone-scala-client.conf: 4: Could not resolve substitution to a value: ${PINECONE_SCALA_CLIENT_API_KEY} . Was soll ich tun?
Setzen Sie die env. Variable PINECONE_SCALA_CLIENT_API_KEY . Wenn Sie hier kein Register haben.
Es sieht alles cool aus. Ich möchte mit Ihnen über Ihre Forschung und Entwicklung chatten?
Schicken Sie uns einfach eine E-Mail unter [email protected].