pinecone scala Download - pinecone scala Source Code Download

Client Pinecone Scala

Il s'agit d'un client Scala à part entière intuitif à part entière pour l'API PineCone prenant en charge tous les opérations / points de terminaison index, vecteur, collection, inférence et assistant, fourni dans deux services pratiques appelés pineconevectorService et pineConeIndexservice. Les appels pris en charge sont:

Opérations vectorielles : décrire les indexstats, requérir, supprimer, récupérer, mettre à jour et upsert
Opérations de collecte : Listcollections, CreateCollection, décrivage et délécollection
Opérations d'index : ListIndexes, CreateIndex, décrireIndex, DeleteIndex et ConfigureIndex
Opérations d'inférence : EmbedData, Rerank et évaluer
Opérations assistantes : listassistants, créatiSSistants, décrites, de déléaison, listfiles, uploadfile, décrivant, deletefile, chatwithassistant
- Ces opérations sont fournies par deux services: PineconeAssistantService et PineconeAssistantFileService

Notez que pour être cohérent avec la dénomination de l'API de Pinecone, les noms de fonction de service correspondent exactement aux titres / descriptions des points de terminaison de l'API avec CamelCase. De plus, nous avons visé la LIB à être autonome avec le moins de dépendances possible, nous avons fini par utiliser seulement deux libs play-ahc-ws-standalone et play-ws-standalone-json (au niveau supérieur).

✔️ IMPORTANT : Il s'agit d'une bibliothèque «entretenue par la communauté» et, en tant que telle, n'a aucun rapport avec PineCone Company.

Consultez un article sur la lib / client sur Medium. De plus, si vous souhaitez voir des exemples pratiques immédiatement, accédez aux exemples de pinone ou les modules d'exemples d'Openai + Pinecone.

Installation

Les versions Scala actuellement prises en charge sont 2.12, 2.13 et 3 .

Pour tirer la bibliothèque, vous devez ajouter la dépendance suivante à votre build.sbt

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

ou à pom.xml (si vous utilisez maven)

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

Configurer

Env. Variables: PINECONE_SCALA_CLIENT_API_KEY et PINECONE_SCALA_CLIENT_ENV si le service basé sur les pods est utilisé
Fichier Config (par défaut): PineCone-Scala-Client.conf

Usage? ‍?

Ia Obtention de PineconeIndexService

Vous devez d'abord fournir un contexte d'exécution implicite ainsi que matérialiser Akka, par exemple, comme

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

Ensuite, vous pouvez obtenir un service (POD ou sans serveur) de l'une des manières suivantes.

Configage par défaut (s'attend à Config variables env.

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

  val service = PineconeIndexServiceFactory ().asOne

Configuration personnalisée

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

Sans config pour le service basé sur des pods (avec Env) - crée une instance de PineconePodBasedIndexService

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

Sans configuration pour le service sans serveur - crée une instance de PineconeServerlessIndexService

  val service = PineconeIndexServiceFactory (
    apiKey = " your_api_key "
  )

Ib. Obtention de PineconeVectorService

Identique à PineconeIndexService , vous devez d'abord fournir un contexte d'exécution implicite et une matérialisation Akka. Ensuite, vous pouvez obtenir un service de l'une des manières suivantes.

La configuration par défaut (s'attend à ce que les variables env. Sont définies comme définies dans la section Config ). Notez que si l'index avec un prénom n'est pas disponible, l'usine ne le rendra None .

  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. Obtention de PineconeInferenceService

Configuration par défaut

  val service = PineconeInferenceServiceFactory ()

Configuration personnalisée

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

Directement avec la clé API

  val service = PineconeInferenceServiceFactory (
    apiKey = " your_api_key "
  )

Identifiant. Obtention PineconeAssistantService

Configuration par défaut

  val service = PineconeAssistantServiceFactory ()

Configuration personnalisée

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

Directement avec la clé API

  val service = PineconeAssistantServiceFactory (
    apiKey = " your_api "
  )

C'est-à-dire Obtention PineconeAssistantFileService

Configuration par défaut

  val service = PineconeAssistantFileServiceFactory ()

Configuration personnalisée

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

Directement avec la clé API

  val service = PineconeAssistantFileServiceFactory (
    apiKey = " your_api "
  )

Ii Fonctions d'appel

Une documentation complète de chaque appel avec ses entrées et paramètres respectifs est fournie dans PineConevectorService et PineConeIndexService. Étant donné que tous les appels sont asynchrones, ils renvoient des réponses enveloppées à Future .

Exemples:

Opérations d'index

Index de liste

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

Créer un index (avec des paramètres par défaut)

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

Décrire l'index

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

Supprimer l'index

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

Configurer l'index

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

Opérations de collecte

LISTER LES COLLECTIONS

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

Créer une collection

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

Décrire la collection

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

Supprimer la collection

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

Opérations vectorielles

Ascension

  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. " )
  )

Mise à jour

  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. " )
  )

Requête avec paramètres par défaut

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

Requête avec des paramètres personnalisés

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

Aller chercher

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

Supprimer par id (s)

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

Supprimer tout

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

Décrire les statistiques de l'index

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

Opérations d'inférence

Générer des intérêts

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

RERANK DOCUMENTS / CHUNKS

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

Évaluer les questions et réponses

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

** Opérations assistantes **

Lister les assistants

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

Créer un assistant

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

Décrire l'assistant

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

Supprimer l'assistant

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

Liste des fichiers assistants

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

Télécharger le fichier assistant

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

Décrire le fichier assistant

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

Discuter avec un assistant

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

Démo

Pour les démos prêtes à l'emploi pls. Reportez-vous aux modules distincts:

Demo Pinecone Scala - montre comment utiliser les opérations de vecteur de pince, d'index et de collecte
Pincone + Openai Scala Demo - montre comment générer et stocker des incorporations Openai dans Pinecone et les interroger par la suite

FAQ?

J'ai eu une exception de temps mort. Comment puis-je modifier le paramètre de délai d'expiration?
Vous pouvez le faire soit en passant les timeouts mort à Pinecone{Vector,Index}ServiceFactory ou, si vous utilisez votre propre fichier de configuration, vous pouvez simplement l'ajouter en tant que:

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

J'ai une exception comme 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} . Que dois-je faire?
Définissez l'env. variable PINECONE_SCALA_CLIENT_API_KEY . Si vous n'avez pas un registre ici.
Tout a l'air cool. Je veux discuter avec vous de votre recherche et développement?
Il suffit de nous envoyer un e-mail à [email protected].