Classificatore vLLMCompatible with Milvus 2.6.x

Il vLLM Ranker sfrutta il framework di inferenza vLLM per migliorare la rilevanza della ricerca attraverso il reranking semantico. Rappresenta un approccio avanzato all'ordinamento dei risultati di ricerca che va oltre la tradizionale somiglianza vettoriale.

vLLM Ranker è particolarmente utile per le applicazioni in cui la precisione e il contesto sono fondamentali, come ad esempio:

• Ricerca di documentazione tecnica che richiede una comprensione profonda dei concetti

• Database di ricerca in cui le relazioni semantiche superano la corrispondenza delle parole chiave

• Sistemi di assistenza clienti che devono far coincidere i problemi degli utenti con le relative soluzioni

• Ricerca nel commercio elettronico che deve comprendere gli attributi del prodotto e l'intento dell'utente.

Prerequisiti

Prima di implementare vLLM Ranker in Milvus, assicurarsi di disporre di:

• Una raccolta Milvus con un campo VARCHAR contenente il testo da rerankizzare

• Un servizio vLLM funzionante con funzionalità di reranking. Per istruzioni dettagliate sulla configurazione di un servizio vLLM, consultare la documentazione ufficiale di vLLM. Per verificare la disponibilità del servizio vLLM:

  # Replace YOUR_VLLM_ENDPOINT_URL with the actual URL (e.g., http://<service-ip>:<port>/v1/rerank)
  # Replace 'BAAI/bge-reranker-base' if you deployed a different model
  
  curl -X 'POST' \
    'YOUR_VLLM_ENDPOINT_URL' \
    -H 'accept: application/json' \
    -H 'Content-Type: application/json' \
    -d '{
    "model": "BAAI/bge-reranker-base",
    "query": "What is the capital of France?",
    "documents": [
      "The capital of Brazil is Brasilia.",
      "The capital of France is Paris.",
      "Horses and cows are both animals"
    ]
  }'
  

  Una risposta corretta dovrebbe restituire i documenti classificati in base ai punteggi di rilevanza, in modo simile alla risposta dell'API OpenAI rerank.

  Per ulteriori argomenti e opzioni del server, consultare la documentazione del server compatibile OpenAI di vLLM.

Creare una funzione vLLM ranker

Per utilizzare vLLM Ranker nella vostra applicazione Milvus, create un oggetto Function che specifichi come deve funzionare il reranking. Questa funzione verrà passata alle operazioni di ricerca di Milvus per migliorare la classificazione dei risultati.

from pymilvus import MilvusClient, Function, FunctionType

# Connect to your Milvus server
client = MilvusClient(
    uri="http://localhost:19530"  # Replace with your Milvus server URI
)

# Create a vLLM Ranker function
vllm_ranker = Function(
    name="vllm_semantic_ranker",    # Choose a descriptive name
    input_field_names=["document"],  # Field containing text to rerank
    function_type=FunctionType.RERANK,  # Must be RERANK
    params={
        "reranker": "model",        # Specifies model-based reranking
        "provider": "vllm",         # Specifies vLLM service
        "queries": ["renewable energy developments"],  # Query text
        "endpoint": "http://localhost:8080",  # vLLM service address
        "max_client_batch_size": 32,              # Optional: batch size
        "truncate_prompt_tokens": 256,  # Optional: Use last 256 tokens
    }
)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.common.clientenum.FunctionType;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build());

CreateCollectionReq.Function ranker = CreateCollectionReq.Function.builder()
                       .functionType(FunctionType.RERANK)
                       .name("vllm_semantic_ranker")
                       .inputFieldNames(Collections.singletonList("document"))
                       .param("reranker", "model")
                       .param("provider", "vllm")
                       .param("queries", "[\"renewable energy developments\"]")
                       .param("endpoint", "http://localhost:8080")
                       .param("max_client_batch_size", "32")
                       .param("truncate_prompt_tokens", "256")
                       .build();

// nodejs

// go

# restful

Parametri specifici del ranker vLLM

I seguenti parametri sono specifici del ranker vLLM:

Parametro	Richiesto?	Descrizione	Valore / Esempio
reranker	Sì	Deve essere impostato su "model" per abilitare il reranking del modello.	"model"
provider	Sì	Il fornitore di servizi del modello da usare per il reranking.	"vllm"
queries	Sì	Elenco delle stringhe di query utilizzate dal modello di reranking per calcolare i punteggi di rilevanza. Il numero di stringhe di query deve corrispondere esattamente al numero di query dell'operazione di ricerca (anche quando si usano vettori di query al posto del testo), altrimenti verrà segnalato un errore.	["query di ricerca"]
endpoint	Sì	Indirizzo del servizio vLLM.	"http://localhost:8080"
max_client_batch_size	No	Poiché i servizi modello potrebbero non elaborare tutti i dati in una volta sola, questo parametro imposta la dimensione del batch per l'accesso al servizio modello in più richieste.	32 (predefinito)
truncate_prompt_tokens	No	Se impostato su un numero intero k, utilizzerà solo gli ultimi k token della richiesta (cioè, troncamento a sinistra). Il valore predefinito è Nessuno (cioè nessun troncamento).	256

Applicare alla ricerca vettoriale standard

Per applicare vLLM Ranker a una ricerca vettoriale standard:

# Execute search with vLLM reranking
results = client.search(
    collection_name="your_collection",
    data=[your_query_vector],  # Replace with your query vector
    anns_field="dense_vector",                   # Vector field to search
    limit=5,                                     # Number of results to return
    output_fields=["document"],                  # Include text field for reranking
    ranker=vllm_ranker,                         # Apply vLLM reranking
    consistency_level="Bounded"
)

import io.milvus.v2.common.ConsistencyLevel;
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.response.SearchResp;
import io.milvus.v2.service.vector.request.data.EmbeddedText;

SearchReq searchReq = SearchReq.builder()
        .collectionName("your_collection")
        .data(Arrays.asList(new EmbeddedText("AI Research Progress"), new EmbeddedText("What is AI")))
        .annsField("vector_field")
        .limit(10)
        .outputFields(Collections.singletonList("document"))
        .functionScore(FunctionScore.builder()
                .addFunction(ranker)
                .build())
        .consistencyLevel(ConsistencyLevel.BOUNDED)
        .build();
SearchResp searchResp = client.search(searchReq);

// nodejs

// go

# restful