L'Archivio Vettoriale di Rememberizer semplifica il processo di gestione dei dati vettoriali, consentendoti di concentrarti sull'input di testo e sfruttare la potenza dei vettori per varie applicazioni come la ricerca e l'analisi dei dati.
Introduzione
Il Rememberizer Vector Store fornisce un'interfaccia facile da usare per gestire i dati vettoriali, astrando la complessità delle embedding vettoriali. Alimentato da PostgreSQL con l'estensione pgvector, il Rememberizer Vector Store ti consente di lavorare direttamente con il testo. Il servizio gestisce il chunking, la vettorizzazione e l'archiviazione dei dati testuali, rendendo più facile per te concentrarti sulla logica principale della tua applicazione.
Per una comprensione più profonda dei concetti teorici dietro le embedding vettoriali e i database vettoriali, vedi .
Panoramica Tecnica
Come Funzionano gli Archivi Vettoriali
Gli Archivi Vettoriali di Rememberizer convertono il testo in rappresentazioni vettoriali ad alta dimensione (embedding) che catturano il significato semantico. Questo consente:
Ricerca Semantica: Trovare documenti basati sul significato piuttosto che solo su parole chiave
Corrispondenza di Somiglianza: Identificare contenuti concettualmente correlati
Recupero Efficiente: Localizzare rapidamente informazioni rilevanti da grandi set di dati
Componenti Chiave
Elaborazione dei Documenti: Il testo viene suddiviso in pezzi di dimensioni ottimali con confini sovrapposti per preservare il contesto
Vettorizzazione: I pezzi vengono convertiti in embedding utilizzando modelli all'avanguardia
Indicizzazione: Algoritmi specializzati organizzano i vettori per una ricerca di similarità efficiente
Elaborazione delle Query: Le query di ricerca vengono vettorizzate e confrontate con gli embedding memorizzati
Architettura
Rememberizer implementa i vettori di archiviazione utilizzando:
PostgreSQL con estensione pgvector: Per un'archiviazione e ricerca dei vettori efficiente
Organizzazione basata su collezioni: Ogni vettore di archiviazione ha la propria collezione isolata
Accesso guidato da API: Endpoint RESTful semplici per tutte le operazioni
Iniziare
Creazione di un Negozio di Vettori
Naviga nella Sezione Negozio di Vettori nel tuo pannello di controllo
Clicca su "Crea nuovo Negozio di Vettori":
Apparirà un modulo che ti chiederà di inserire i dettagli.
Compila i Dettagli:
Nome: Fornisci un nome unico per il tuo negozio di vettori.
Descrizione: Scrivi una breve descrizione del negozio di vettori.
Modello di Embedding: Seleziona il modello che converte il testo in vettori.
Algoritmo di Indicizzazione: Scegli come i vettori saranno organizzati per la ricerca.
Metrica di Ricerca: Definisci come viene calcolata la somiglianza tra i vettori.
Dimensione del Vettore: La dimensione degli embedding dei vettori (tipicamente 768-1536).
Invia il Modulo:
Clicca sul pulsante "Crea". Riceverai una notifica di successo e il nuovo negozio apparirà nella tua lista di negozi di vettori.
Opzioni di Configurazione
Modelli di Embedding
Modello
Dimensioni
Descrizione
Migliore per
openai/text-embedding-3-large
1536
Modello di embedding ad alta precisione di OpenAI
Applicazioni di produzione che richiedono la massima precisione
openai/text-embedding-3-small
1536
Modello di embedding più piccolo e veloce di OpenAI
Applicazioni con requisiti di throughput più elevati
Algoritmi di indicizzazione
Algoritmo
Descrizione
Compromessi
IVFFLAT (predefinito)
File invertito con compressione piatta
Buon equilibrio tra velocità e precisione; funziona bene per la maggior parte dei dataset
HNSW
Mondo piccolo navigabile gerarchico
Maggiore precisione per grandi dataset; requisiti di memoria più elevati
Metriche di Ricerca
Metri
Descrizione
Migliore per
coseno (predefinito)
Misura l'angolo tra i vettori
Abbinamento di somiglianza di uso generale
prodotto interno (ip)
Prodotto scalare tra vettori
Quando la magnitudine del vettore è importante
L2 (Euclideo)
Distanza in linea retta tra i vettori
Quando le relazioni spaziali sono importanti
Gestione degli Archivi Vettoriali
Visualizza e Modifica gli Archivi Vettoriali:
Accedi al pannello di gestione per visualizzare, modificare o eliminare gli archivi vettoriali.
Visualizzazione dei Documenti:
Sfoglia i singoli documenti e i loro metadati associati all'interno di un archivio vettoriale specifico.
Statistiche:
Visualizza statistiche dettagliate come il numero di vettori memorizzati, le prestazioni delle query e le metriche operative.
Gestione delle Chiavi API
Le chiavi API vengono utilizzate per autenticare e autorizzare l'accesso agli endpoint API del Rememberizer Vector Store. Una corretta gestione delle chiavi API è essenziale per mantenere la sicurezza e l'integrità dei tuoi vector store.
Creazione di Chiavi API
Vai alla pagina dei dettagli del tuo Vector Store
Naviga alla Sezione di Gestione delle Chiavi API:
Può essere trovata all'interno della scheda "Configurazione"
Clicca su "Aggiungi Chiave API":
Apparirà un modulo che ti chiederà di inserire i dettagli.
Compila i Dettagli:
Nome: Fornisci un nome per la chiave API per aiutarti a identificare il suo caso d'uso.
Invia il Modulo:
Clicca sul pulsante "Crea". La nuova chiave API verrà generata e visualizzata. Assicurati di copiarla e conservarla in modo sicuro. Questa chiave viene utilizzata per autenticare le richieste a quel specifico vector store.
Revoca delle chiavi API
Se una chiave API non è più necessaria, puoi eliminarla per prevenire potenziali abusi.
Per motivi di sicurezza, potresti voler ruotare le tue chiavi API periodicamente. Questo comporta la generazione di una nuova chiave e la revoca della vecchia.
Utilizzo dell'API del Vector Store
Dopo aver creato un Vector Store e generato una chiave API, puoi interagire con esso utilizzando l'API REST.
Esempi di Codice
import requests
import json
API_KEY = "your_api_key_here"
VECTOR_STORE_ID = "vs_abc123" # Sostituisci con il tuo ID del vettore
BASE_URL = "https://api.rememberizer.a
# Carica un documento nello store vettoriale
def upload_document(file_path, document_name=None):
if document_name is None:
document_name = file_path.split("/")[-1]
with open(file_path, "rb") as f:
files = {"file": (document_name, f)}
headers = {"x-api-key": API_KEY}
response = requests.post(
f"{BASE_URL}/vector-stores/{VECTOR_STORE_ID}/documents",
headers=headers,
files=files
)
if response.status_code == 201:
print(f"Documento '{document_name}' caricato con successo!")
return response.json()
else:
print(f"Errore durante il caricamento del documento: {response.text}")
return None
# Carica contenuti testuali nel negozio vettoriale
def upload_text(content, document_name):
headers = {
"x-api-key": API_KEY,
"Content-Type": "application/json"
}
data = {
"name": document_name,
"content": content
}
response = requests.post(
f"{BASE_URL}/vector-stores/{VECTOR_STORE_ID}/documents/text",
headers=headers,
json=data
)
if response.status_code == 201:
print(f"Documento di testo '{document_name}' caricato con successo!")
return response.json()
else:
print(f"Errore durante il caricamento del testo: {response.text}")
return None
# Cerca nel negozio di vettori
def search_vector_store(query, num_results=5, prev_chunks=1, next_chunks=1):
headers = {"x-api-key": API_KEY}
params = {
"q": query,
"n": num_results,
"prev_chunks": prev_chunks,
"next_chunks": next_chunks
}
response = requests.get(
f"{BASE_URL}/vector-stores/{VECTOR_STORE_ID}/documents/search",
headers=headers,
params=params
)
if response.status_code == 200:
results = response.json()
print(f"Trovati {len(results['matched_chunks'])} risultati per '{query}'")
# Stampa il risultato migliore
if results['matched_chunks']:
top_match = results['matched_chunks'][0]
print(f"Miglior risultato (distanza: {top_match['distance']}):")
print(f"Documento: {top_match['document']['name']}")
print(f"Contenuto: {top_match['matched_content']}")
return results
else:
print(f"Errore nella ricerca: {response.text}")
return None
# Esempio di utilizzo
# carica_documento("path/to/document.pdf")
# upload_text("Questo è un testo di esempio da vettorizzare", "sample-document.txt")
# search_vector_store("Come funziona la similarità vettoriale?")
// Client API per il Vector Store
class VectorStoreClient {
constructor(apiKey, vectorStoreId) {
this.apiKey = apiKey;
this.vectorStoreId = vectorStoreId;
this.baseUrl = 'https://api.rememberizer.ai/api/v1';
}
// Ottieni informazioni sul vector store
async getVectorStoreInfo() {
const response = await fetch(`${this.baseUrl}/vector-stores/${this.vectorStoreId}`, {
method: 'GET',
headers: {
'x-api-key': this.apiKey
}
});
if (!response.ok) {
throw new Error(`Impossibile ottenere informazioni sul vector store: ${response.statusText}`);
}
return response.json();
}
// Carica un documento di testo
async uploadTextDocument(name, content) {
const response = await fetch(`${this.baseUrl}/vector-stores/${this.vectorStoreId}/documents/text`, {
method: 'POST',
headers: {
'x-api-key': this.apiKey,
'Content-Type': 'application/json'
},
body: JSON.stringify({
name,
content
})
});
if (!response.ok) {
throw new Error(`Impossibile caricare il documento di testo: ${response.statusText}`);
}
return response.json();
}
// Carica un file
async uploadFile(file, onProgress) {
const formData = new FormData();
formData.append('file', file);
const xhr = new XMLHttpRequest();
return new Promise((resolve, reject) => {
xhr.open('POST', `${this.baseUrl}/vector-stores/${this.vectorStoreId}/documents`);
xhr.setRequestHeader('x-api-key', this.apiKey);
xhr.upload.onprogress = (event) => {
if (event.lengthComputable && onProgress) {
const percentComplete = (event.loaded / event.total) * 100;
onProgress(percentComplete);
}
};
xhr.onload = () => {
if (xhr.status === 201) {
resolve(JSON.parse(xhr.responseText));
} else {
reject(new Error(`Impossibile caricare il file: ${xhr.statusText}`));
}
};
xhr.onerror = () => {
reject(new Error('Errore di rete durante il caricamento del file'));
};
xhr.send(formData);
});
}
// Cerca documenti nel vector store
async searchDocuments(query, options = {}) {
const params = new URLSearchParams({
q: query,
n: options.numResults || 10,
prev_chunks: options.prevChunks || 1,
next_chunks: options.nextChunks || 1
});
if (options.threshold) {
params.append('t', options.threshold);
}
const response = await fetch(
`${this.baseUrl}/vector-stores/${this.vectorStoreId}/documents/search?${params}`,
{
method: 'GET',
headers: {
'x-api-key': this.apiKey
}
}
);
if (!response.ok) {
throw new Error(`La ricerca è fallita: ${response.statusText}`);
}
return response.json();
}
// Elenca tutti i documenti nel vector store
async listDocuments() {
const response = await fetch(
`${this.baseUrl}/vector-stores/${this.vectorStoreId}/documents`,
{
method: 'GET',
headers: {
'x-api-key': this.apiKey
}
}
);
if (!response.ok) {
throw new Error(`Impossibile elencare i documenti: ${response.statusText}`);
}
return response.json();
}
// Elimina un documento
async deleteDocument(documentId) {
const response = await fetch(
`${this.baseUrl}/vector-stores/${this.vectorStoreId}/documents/${documentId}`,
{
method: 'DELETE',
headers: {
'x-api-key': this.apiKey
}
}
);
if (!response.ok) {
throw new Error(`Impossibile eliminare il documento: ${response.statusText}`);
}
return true;
}
}
// Esempio di utilizzo
/*
const client = new VectorStoreClient('your_api_key', 'vs_abc123');
// Cerca documenti
client.searchDocuments('Come funziona la ricerca semantica?')
.then(results => {
console.log(`Trovati ${results.matched_chunks.length} risultati`);
results.matched_chunks.forEach(match => {
console.log(`Documento: ${match.document.name}`);
console.log(`Punteggio: ${match.distance}`);
console.log(`Contenuto: ${match.matched_content}`);
console.log('---');
});
})
.catch(error => console.error(error));
*/
results = client.search('Quali sono le migliori pratiche per la sicurezza dei dati?')
puts "Trovati #{results['matched_chunks'].length} risultati"
Mostra il risultato migliore
if results['matched_chunks'].any?
top_match = results['matched_chunks'].first
puts "Miglior corrispondenza (distanza: #{top_match['distance']}):"
puts "Documento: #{top_match['document']['name']}"
puts "Contenuto: #{top_match['matched_content']}"
end
=end
</div>
<div data-gb-custom-block data-tag="tab" data-title='cURL'>
```bash
# Imposta la tua chiave API e l'ID del Vector Store
API_KEY="your_api_key_here"
VECTOR_STORE_ID="vs_abc123"
BASE_URL="https://api.rememberizer.ai/api/v1"
# Ottieni informazioni sullo store vettoriale
curl -X GET "${BASE_URL}/vector-stores/${VECTOR_STORE_ID}" \
-H "x-api-key: ${API_KEY}"
# Carica un documento di testo
curl -X POST "${BASE_URL}/vector-stores/${VECTOR_STORE_ID}/documents/text" \
-H "x-api-key: ${API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "example-document.txt",
"content": "Questo è un documento di esempio che sarà vettorizzato e memorizzato nel database vettoriale per la ricerca semantica."
}'
# Carica un file
curl -X POST "${BASE_URL}/vector-stores/${VECTOR_STORE_ID}/documents" \
-H "x-api-key: ${API_KEY}" \
-F "file=@/path/to/your/document.pdf"
# Cerca documenti
curl -X GET "${BASE_URL}/vector-stores/${VECTOR_STORE_ID}/documents/search?q=semantic%20search&n=5&prev_chunks=1&next_chunks=1" \
-H "x-api-key: ${API_KEY}"
# Elenca tutti i documenti
curl -X GET "${BASE_URL}/vector-stores/${VECTOR_STORE_ID}/documents" \
-H "x-api-key: ${API_KEY}"
# Elimina un documento
curl -X DELETE "${BASE_URL}/vector-stores/${VECTOR_STORE_ID}/documents/123" \
-H "x-api-key: ${API_KEY}"
Considerazioni sulle Prestazioni
In arrivo: Diagramma dell'Architettura del Vector Store
Questo diagramma dell'architettura tecnica illustrerà:
L'architettura di base PostgreSQL + pgvector
Strutture degli algoritmi di indicizzazione (IVFFLAT vs. HNSW)
Come funzionano le metriche di ricerca nello spazio vettoriale (confronto visivo)
Processo di suddivisione dei documenti con visualizzazione delle sovrapposizioni
Considerazioni sulle prestazioni visualizzate su diverse scale
Ottimizzazione per Diversi Volumi di Dati
Volume di Dati
Configurazione Raccomandata
Note
Piccolo (<10k documenti)
IVFFLAT, similarità coseno
Configurazione semplice che offre buone prestazioni
Medio (10k-100k documenti)
IVFFLAT, assicurarsi di effettuare regolarmente il reindicizzazione
Equilibrio tra velocità di ricerca e manutenzione dell'indice
Grande (>100k documenti)
HNSW, considerare di aumentare le dimensioni del vettore
Maggiore utilizzo di memoria ma mantiene le prestazioni su larga scala
Strategie di Suddivisione
Il processo di suddivisione influisce significativamente sulla qualità della ricerca:
Dimensione del Chunk: Rememberizer utilizza una dimensione di chunk predefinita di 1024 byte con un sovrapposizione di 200 byte
Chunk Più Piccoli (512-1024 byte): Corrispondenze più precise, migliori per domande specifiche
Chunk Più Grandi (1500-2048 byte): Maggiore contesto in ogni corrispondenza, migliori per argomenti più ampi
Sovrapposizione: Garantisce che il contesto non venga perso ai confini dei chunk
Ottimizzazione delle Query
Finestre di Contesto: Usa prev_chunks e next_chunks per recuperare contenuti circostanti
Conteggio dei Risultati: Inizia con 3-5 risultati (n parametro) e adatta in base alle esigenze di precisione
Soglia: Regola il parametro t per filtrare i risultati in base al punteggio di somiglianza
Utilizzo Avanzato
Reindicizzazione
Rememberizer attiva automaticamente la reindicizzazione quando il numero di vettori supera le soglie predefinite, ma considera la reindicizzazione manuale dopo:
Aver caricato un gran numero di documenti
Aver cambiato il modello di embedding
Aver modificato l'algoritmo di indicizzazione
Miglioramento delle Query
Per risultati di ricerca migliori:
Essere specifici nelle query di ricerca
Includere contesto quando possibile
Usare linguaggio naturale piuttosto che parole chiave
Regolare i parametri in base alla qualità dei risultati
Migrazione da Altri Database Vettoriali
Se attualmente stai utilizzando altre soluzioni di database vettoriali e desideri migrare a Rememberizer Vector Store, le seguenti guide ti aiuteranno a trasferire i tuoi dati in modo efficiente.
Panoramica della Migrazione
La migrazione dei dati vettoriali comporta:
Esportare i dati dal tuo database vettoriale di origine
Convertire i dati in un formato compatibile con Rememberizer
Importare i dati nel tuo Rememberizer Vector Store
Verificare che la migrazione sia stata completata con successo
Vantaggi della Migrazione a Rememberizer
Fondazione PostgreSQL: Costruito su una tecnologia di database matura con backup e recupero integrati
Ecosistema Integrato: Connessione senza soluzione di continuità con altri componenti di Rememberizer
Gestione Semplificata: Interfaccia unificata per le operazioni vettoriali
Sicurezza Avanzata: Sicurezza a livello di riga e controlli di accesso dettagliati
Architettura Scalabile: Ottimizzazione delle prestazioni man mano che i tuoi dati crescono
Migrazione da Pinecone
import os
import pinecone
import requests
import json
import time
# Configura il client Pinecone
pinecone.init(api_key="PINECONE_API_KEY", environment="PINECONE_ENV")
source_index = pinecone.Index("your-pinecone-index")
# Configura il client Rememberizer Vector Store
REMEMBERIZER_API_KEY = "your_rememberizer_api_key"
VECTOR_STORE_ID = "vs_abc123" # Il tuo ID del vector store Rememberizer
BASE_URL = "https://api.rememberizer.ai/api/v1"
# 1. Imposta la dimensione del batch per la migrazione (regola in base alle dimensioni dei tuoi dati)
BATCH_SIZE = 100
# 2. Funzione per ottenere vettori da Pinecone
def fetch_vectors_from_pinecone(index_name, batch_size, cursor=None):
# Usa l'operazione di elenco se disponibile nella tua versione di Pinecone
try:
result = source_index.list(limit=batch_size, cursor=cursor)
vectors = result.get("vectors", {})
next_cursor = result.get("cursor")
return vectors, next_cursor
except AttributeError:
# Per versioni più vecchie di Pinecone senza operazione di elenco
# Questo è un approccio semplificato; l'implementazione effettiva dipende dal tuo modello di accesso ai dati
query_response = source_index.query(
vector=[0] * source_index.describe_index_stats()["dimension"],
top_k=batch_size,
include_metadata=True,
include_values=True
)
return {item.id: {"id": item.id, "values": item.values, "metadata": item.metadata}
for item in query_response.matches}, None
# 3. Funzione per caricare vettori su Rememberizer
def upload_to_rememberizer(vectors):
headers = {
"x-api-key": REMEMBERIZER_API_KEY,
"Content-Type": "application/json"
}
for vector_id, vector_data in vectors.items():
# Converti i dati del vettore Pinecone nel formato Rememberizer
document_name = vector_data.get("metadata", {}).get("filename", f"pinecone_doc_{vector_id}")
content = vector_data.get("metadata", {}).get("text", "")
if not content:
print(f"Salto {vector_id} - nessun contenuto testuale trovato nei metadati")
continue
data = {
"name": document_name,
"content": content,
# Facoltativo: includere metadati aggiuntivi
"metadata": vector_data.get("metadata", {})
}
response = requests.post(
f"{BASE_URL}/vector-stores/{VECTOR_STORE_ID}/documents/text",
headers=headers,
json=data
)
if response.status_code == 201:
print(f"Documento '{document_name}' caricato con successo!")
else:
print(f"Errore nel caricamento del documento {document_name}: {response.text}")
# Aggiungi un piccolo ritardo per prevenire il limite di velocità
time.sleep(0.1)
# 4. Funzione principale di migrazione
def migrate_pinecone_to_rememberizer():
cursor = None
total_migrated = 0
print("Inizio della migrazione da Pinecone a Rememberizer...")
while True:
vectors, cursor = fetch_vectors_from_pinecone("your-pinecone-index", BATCH_SIZE, cursor)
if not vectors:
break
print(f"Recuperati {len(vectors)} vettori da Pinecone")
upload_to_rememberizer(vectors)
total_migrated += len(vectors)
print(f"Progresso: {total_migrated} vettori migrati")
if not cursor:
break
print(f"Migrazione completata! {total_migrated} vettori totali migrati a Rememberizer")
# Esegui la migrazione
# migrate_pinecone_to_rememberizer()
const { PineconeClient } = require('@pinecone-database/pinecone');
const axios = require('axios');
// Configurazione di Pinecone
const pineconeApiKey = 'PINECONE_API_KEY';
const pineconeEnvironment = 'PINECONE_ENVIRONMENT';
const pineconeIndexName = 'YOUR_PINECONE_INDEX';
// Configurazione di Rememberizer
const rememberizerApiKey = 'YOUR_REMEMBERIZER_API_KEY';
const vectorStoreId = 'vs_abc123';
const baseUrl = 'https://api.rememberizer.ai/api/v1';
// Configurazione della dimensione del batch
const BATCH_SIZE = 100;
// Inizializza il client di Pinecone
async function initPinecone() {
const pinecone = new PineconeClient();
await pinecone.init({
apiKey: pineconeApiKey,
environment: pineconeEnvironment,
});
return pinecone;
}
// Recupera i vettori da Pinecone
async function fetchVectorsFromPinecone(pinecone, batchSize, paginationToken = null) {
const index = pinecone.Index(pineconeIndexName);
try {
// Per le versioni più recenti di Pinecone
const listResponse = await index.list({
limit: batchSize,
paginationToken: paginationToken
});
return {
vectors: listResponse.vectors || {},
nextToken: listResponse.paginationToken
};
} catch (error) {
// Fallback per le versioni più vecchie di Pinecone
// Questo è semplificato; l'implementazione effettiva dipende dal tuo modello di accesso ai dati
const stats = await index.describeIndexStats();
const dimension = stats.dimension;
const queryResponse = await index.query({
vector: Array(dimension).fill(0),
topK: batchSize,
includeMetadata: true,
includeValues: true
});
const vectors = {};
queryResponse.matches.forEach(match => {
vectors[match.id] = {
id: match.id,
values: match.values,
metadata: match.metadata
};
});
return { vectors, nextToken: null };
}
}
// Carica i vettori su Rememberizer
async function uploadToRememberizer(vectors) {
const headers = {
'x-api-key': rememberizerApiKey,
'Content-Type': 'application/json'
};
const results = [];
for (const [vectorId, vectorData] of Object.entries(vectors)) {
const documentName = vectorData.metadata?.filename || `pinecone_doc_${vectorId}`;
const content = vectorData.metadata?.text || '';
if (!content) {
console.log(`Salto ${vectorId} - nessun contenuto testuale trovato nei metadati`);
continue;
}
const data = {
name: documentName,
content: content,
// Facoltativo: includere metadati aggiuntivi
metadata: vectorData.metadata || {}
};
try {
const response = await axios.post(
`${baseUrl}/vector-stores/${vectorStoreId}/documents/text`,
data,
{ headers }
);
if (response.status === 201) {
console.log(`Documento '${documentName}' caricato con successo!`);
results.push({ id: vectorId, success: true });
} else {
console.error(`Errore durante il caricamento del documento ${documentName}: ${response.statusText}`);
results.push({ id: vectorId, success: false, error: response.statusText });
}
} catch (error) {
console.error(`Errore durante il caricamento del documento ${documentName}: ${error.message}`);
results.push({ id: vectorId, success: false, error: error.message });
}
// Aggiungi un piccolo ritardo per prevenire il limite di velocità
await new Promise(resolve => setTimeout(resolve, 100));
}
return results;
}
// Funzione principale di migrazione
async function migratePineconeToRememberizer() {
try {
console.log('Inizio della migrazione da Pinecone a Rememberizer...');
const pinecone = await initPinecone();
let nextToken = null;
let totalMigrated = 0;
do {
const { vectors, nextToken: token } = await fetchVectorsFromPinecone(
pinecone,
BATCH_SIZE,
nextToken
);
nextToken = token;
if (Object.keys(vectors).length === 0) {
break;
}
console.log(`Recuperati ${Object.keys(vectors).length} vettori da Pinecone`);
const results = await uploadToRememberizer(vectors);
const successCount = results.filter(r => r.success).length;
totalMigrated += successCount;
console.log(`Progresso: ${totalMigrated} vettori migrati con successo`);
} while (nextToken);
console.log(`Migrazione completata! ${totalMigrated} vettori totali migrati su Rememberizer`);
} catch (error) {
console.error('Migrazione fallita:', error);
}
}
// Esegui la migrazione
// migratePineconeToRememberizer();
Migrazione da Qdrant
import requests
import json
import time
from qdrant_client import QdrantClient
from qdrant_client.http import models as rest
# Configura il client Qdrant
QDRANT_URL = "http://localhost:6333" # o il tuo URL Qdrant cloud
QDRANT_API_KEY = "your_qdrant_api_key" # se utilizzi Qdrant Cloud
QDRANT_COLLECTION_NAME = "your_collection"
qdrant_client = QdrantClient(
url=QDRANT_URL,
api_key=QDRANT_API_KEY # Solo per Qdrant Cloud
)
# Configura il client Rememberizer Vector Store
REMEMBERIZER_API_KEY = "your_rememberizer_api_key"
VECTOR_STORE_ID = "vs_abc123" # Il tuo ID del vector store Rememberizer
BASE_URL = "https://api.rememberizer.ai/api/v1"
# Dimensione del batch per l'elaborazione
BATCH_SIZE = 100
# Funzione per recuperare punti da Qdrant
def fetch_points_from_qdrant(collection_name, batch_size, offset=0):
try:
# Ottieni informazioni sulla collezione per determinare la dimensione del vettore
collection_info = qdrant_client.get_collection(collection_name=collection_name)
# Scorri attraverso i punti
scroll_result = qdrant_client.scroll(
collection_name=collection_name,
limit=batch_size,
offset=offset,
with_payload=True,
with_vectors=True
)
points = scroll_result[0] # Tupla di (punti, next_offset)
next_offset = scroll_result[1]
return points, next_offset
except Exception as e:
print(f"Errore nel recupero dei punti da Qdrant: {e}")
return [], None
# Funzione per caricare vettori su Rememberizer
def upload_to_rememberizer(points):
headers = {
"x-api-key": REMEMBERIZER_API_KEY,
"Content-Type": "application/json"
}
results = []
for point in points:
# Estrai dati dal punto Qdrant
point_id = point.id
metadata = point.payload
text_content = metadata.get("text", "")
document_name = metadata.get("filename", f"qdrant_doc_{point_id}")
if not text_content:
print(f"Salto {point_id} - nessun contenuto testuale trovato nel payload")
continue
data = {
"name": document_name,
"content": text_content,
# Facoltativo: includere metadati aggiuntivi
"metadata": metadata
}
try:
response = requests.post(
f"{BASE_URL}/vector-stores/{VECTOR_STORE_ID}/documents/text",
headers=headers,
json=data
)
if response.status_code == 201:
print(f"Documento '{document_name}' caricato con successo!")
results.append({"id": point_id, "success": True})
else:
print(f"Errore nel caricamento del documento {document_name}: {response.text}")
results.append({"id": point_id, "success": False, "error": response.text})
except Exception as e:
print(f"Eccezione nel caricamento del documento {document_name}: {str(e)}")
results.append({"id": point_id, "success": False, "error": str(e)})
# Aggiungi un piccolo ritardo per prevenire il limite di velocità
time.sleep(0.1)
return results
# Funzione principale di migrazione
def migrate_qdrant_to_rememberizer():
offset = None
total_migrated = 0
print("Inizio della migrazione da Qdrant a Rememberizer...")
while True:
points, next_offset = fetch_points_from_qdrant(
QDRANT_COLLECTION_NAME,
BATCH_SIZE,
offset
)
if not points:
break
print(f"Recuperati {len(points)} punti da Qdrant")
results = upload_to_rememberizer(points)
success_count = sum(1 for r in results if r.get("success", False))
total_migrated += success_count
print(f"Progresso: {total_migrated} punti migrati con successo")
if next_offset is None:
break
offset = next_offset
print(f"Migrazione completata! {total_migrated} punti totali migrati a Rememberizer")
# Esegui la migrazione
# migra_qdrant_a_rememberizer()
const { QdrantClient } = require('@qdrant/js-client-rest');
const axios = require('axios');
// Configurazione di Qdrant
const qdrantUrl = 'http://localhost:6333'; // o il tuo URL cloud di Qdrant
const qdrantApiKey = 'your_qdrant_api_key'; // se utilizzi Qdrant Cloud
const qdrantCollectionName = 'your_collection';
// Configurazione di Rememberizer
const rememberizerApiKey = 'YOUR_REMEMBERIZER_API_KEY';
const vectorStoreId = 'vs_abc123';
const baseUrl = 'https://api.rememberizer.ai/api/v1';
// Configurazione della dimensione del batch
const BATCH_SIZE = 100;
// Inizializza il client Qdrant
const qdrantClient = new QdrantClient({
url: qdrantUrl,
apiKey: qdrantApiKey // Solo per Qdrant Cloud
});
// Recupera i punti da Qdrant
async function fetchPointsFromQdrant(collectionName, batchSize, offset = 0) {
try {
// Ottieni informazioni sulla collezione
const collectionInfo = await qdrantClient.getCollection(collectionName);
// Scorri attraverso i punti
const scrollResult = await qdrantClient.scroll(collectionName, {
limit: batchSize,
offset: offset,
with_payload: true,
with_vectors: true
});
return {
points: scrollResult.points,
nextOffset: scrollResult.next_page_offset
};
} catch (error) {
console.error(`Errore nel recupero dei punti da Qdrant: ${error.message}`);
return { points: [], nextOffset: null };
}
}
// Carica i vettori su Rememberizer
async function uploadToRememberizer(points) {
const headers = {
'x-api-key': rememberizerApiKey,
'Content-Type': 'application/json'
};
const results = [];
for (const point of points) {
// Estrai i dati dal punto di Qdrant
const pointId = point.id;
const metadata = point.payload || {};
const textContent = metadata.text || '';
const documentName = metadata.filename || `qdrant_doc_${pointId}`;
if (!textContent) {
console.log(`Salto ${pointId} - nessun contenuto testuale trovato nel payload`);
continue;
}
const data = {
name: documentName,
content: textContent,
// Facoltativo: includi metadati aggiuntivi
metadata: metadata
};
try {
const response = await axios.post(
`${baseUrl}/vector-stores/${vectorStoreId}/documents/text`,
data,
{ headers }
);
if (response.status === 201) {
console.log(`Documento '${documentName}' caricato con successo!`);
results.push({ id: pointId, success: true });
} else {
console.error(`Errore nel caricamento del documento ${documentName}: ${response.statusText}`);
results.push({ id: pointId, success: false, error: response.statusText });
}
} catch (error) {
console.error(`Errore nel caricamento del documento ${documentName}: ${error.message}`);
results.push({ id: pointId, success: false, error: error.message });
}
// Aggiungi un piccolo ritardo per prevenire il rate limiting
await new Promise(resolve => setTimeout(resolve, 100));
}
return results;
}
// Funzione principale di migrazione
async function migrateQdrantToRememberizer() {
try {
console.log('Inizio migrazione da Qdrant a Rememberizer...');
let offset = null;
let totalMigrated = 0;
do {
const { points, nextOffset } = await fetchPointsFromQdrant(
qdrantCollectionName,
BATCH_SIZE,
offset
);
offset = nextOffset;
if (points.length === 0) {
break;
}
console.log(`Recuperati ${points.length} punti da Qdrant`);
const results = await uploadToRememberizer(points);
const successCount = results.filter(r => r.success).length;
totalMigrated += successCount;
console.log(`Progresso: ${totalMigrated} punti migrati con successo`);
} while (offset !== null);
console.log(`Migrazione completata! ${totalMigrated} punti totali migrati a Rememberizer`);
} catch (error) {
console.error('Migrazione fallita:', error);
}
}
// Esegui la migrazione
// migrateQdrantToRememberizer();
Migrazione da Supabase pgvector
Se stai già utilizzando Supabase con pgvector, la migrazione a Rememberizer è particolarmente semplice poiché entrambi utilizzano PostgreSQL con l'estensione pgvector.
import psycopg2
import requests
import json
import time
import os
from dotenv import load_dotenv
# Carica le variabili d'ambiente
load_dotenv()
# Configurazione PostgreSQL di Supabase
SUPABASE_DB_HOST = os.getenv("SUPABASE_DB_HOST")
SUPABASE_DB_PORT = os.getenv("SUPABASE_DB_PORT", "5432")
SUPABASE_DB_NAME = os.getenv("SUPABASE_DB_NAME")
SUPABASE_DB_USER = os.getenv("SUPABASE_DB_USER")
SUPABASE_DB_PASSWORD = os.getenv("SUPABASE_DB_PASSWORD")
SUPABASE_VECTOR_TABLE = os.getenv("SUPABASE_VECTOR_TABLE", "documents")
# Configurazione di Rememberizer
REMEMBERIZER_API_KEY = os.getenv("REMEMBERIZER_API_KEY")
VECTOR_STORE_ID = os.getenv("VECTOR_STORE_ID") # ad esempio, "vs_abc123"
BASE_URL = "https://api.rememberizer.ai/api/v1"
# Dimensione del batch per l'elaborazione
BATCH_SIZE = 100
# Connettersi a Supabase PostgreSQL
def connect_to_supabase():
try:
conn = psycopg2.connect(
host=SUPABASE_DB_HOST,
port=SUPABASE_DB_PORT,
dbname=SUPABASE_DB_NAME,
user=SUPABASE_DB_USER,
password=SUPABASE_DB_PASSWORD
)
return conn
except Exception as e:
print(f"Errore nella connessione a Supabase PostgreSQL: {e}")
return None
# Recupera documenti da Supabase pgvector
def fetch_documents_from_supabase(conn, batch_size, offset=0):
try:
cursor = conn.cursor()
# Regola questa query in base alla struttura della tua tabella
query = f"""
SELECT id, content, metadata, embedding
FROM {SUPABASE_VECTOR_TABLE}
ORDER BY id
LIMIT %s OFFSET %s
"""
cursor.execute(query, (batch_size, offset))
documents = cursor.fetchall()
cursor.close()
return documents
except Exception as e:
print(f"Errore durante il recupero dei documenti da Supabase: {e}")
return []
# Carica documenti su Rememberizer
def upload_to_rememberizer(documents):
headers = {
"x-api-key": REMEMBERIZER_API_KEY,
"Content-Type": "application/json"
}
results = []
for doc in documents:
doc_id, content, metadata, embedding = doc
# Analizza i metadati se sono memorizzati come stringa JSON
if isinstance(metadata, str):
try:
metadata = json.loads(metadata)
except:
metadata = {}
elif metadata is None:
metadata = {}
document_name = metadata.get("filename", f"supabase_doc_{doc_id}")
if not content:
print(f"Salto {doc_id} - nessun contenuto trovato")
continue
data = {
"name": document_name,
"content": content,
"metadata": metadata
}
try:
response = requests.post(
f"{BASE_URL}/vector-stores/{VECTOR_STORE_ID}/documents/text",
headers=headers,
json=data
)
if response.status_code == 201:
print(f"Documento '{document_name}' caricato con successo!")
results.append({"id": doc_id, "success": True})
else:
print(f"Errore durante il caricamento del documento {document_name}: {response.text}")
results.append({"id": doc_id, "success": False, "error": response.text})
except Exception as e:
print(f"Eccezione durante il caricamento del documento {document_name}: {str(e)}")
results.append({"id": doc_id, "success": False, "error": str(e)})
# Aggiungi un piccolo ritardo per prevenire il limite di velocità
time.sleep(0.1)
return results
# Funzione principale di migrazione
def migrate_supabase_to_rememberizer():
conn = connect_to_supabase()
if not conn:
print("Impossibile connettersi a Supabase. Interruzione della migrazione.")
return
offset = 0
total_migrated = 0
print("Inizio della migrazione da Supabase pgvector a Rememberizer...")
try:
while True:
documents = fetch_documents_from_supabase(conn, BATCH_SIZE, offset)
if not documents:
break
print(f"Recuperati {len(documents)} documenti da Supabase")
results = upload_to_rememberizer(documents)
success_count = sum(1 for r in results if r.get("success", False))
total_migrated += success_count
print(f"Progresso: {total_migrated} documenti migrati con successo")
offset += BATCH_SIZE
finally:
conn.close()
print(f"Migrazione completata! {total_migrated} documenti totali migrati a Rememberizer")
# Esegui la migrazione
# migrate_supabase_to_rememberizer()
const { Pool } = require('pg');
const axios = require('axios');
require('dotenv').config();
// Configurazione PostgreSQL di Supabase
const supabasePool = new Pool({
host: process.env.SUPABASE_DB_HOST,
port: process.env.SUPABASE_DB_PORT || 5432,
database: process.env.SUPABASE_DB_NAME,
user: process.env.SUPABASE_DB_USER,
password: process.env.SUPABASE_DB_PASSWORD,
ssl: {
rejectUnauthorized: false
}
});
const supabaseVectorTable = process.env.SUPABASE_VECTOR_TABLE || 'documents';
// Configurazione di Rememberizer
const rememberizerApiKey = process.env.REMEMBERIZER_API_KEY;
const vectorStoreId = process.env.VECTOR_STORE_ID; // e.g., "vs_abc123"
const baseUrl = 'https://api.rememberizer.ai/api/v1';
// Configurazione della dimensione del batch
const BATCH_SIZE = 100;
// Recupera documenti da Supabase pgvector
async function fetchDocumentsFromSupabase(batchSize, offset = 0) {
try {
// Modifica questa query in base alla struttura della tua tabella
const query = `
SELECT id, content, metadata, embedding
FROM ${supabaseVectorTable}
ORDER BY id
LIMIT $1 OFFSET $2
`;
const result = await supabasePool.query(query, [batchSize, offset]);
return result.rows;
} catch (error) {
console.error(`Errore nel recupero dei documenti da Supabase: ${error.message}`);
return [];
}
}
// Carica documenti su Rememberizer
async function uploadToRememberizer(documents) {
const headers = {
'x-api-key': rememberizerApiKey,
'Content-Type': 'application/json'
};
const results = [];
for (const doc of documents) {
// Analizza i metadati se sono memorizzati come stringa JSON
let metadata = doc.metadata;
if (typeof metadata === 'string') {
try {
metadata = JSON.parse(metadata);
} catch (e) {
metadata = {};
}
} else if (metadata === null) {
metadata = {};
}
const documentName = metadata.filename || `supabase_doc_${doc.id}`;
if (!doc.content) {
console.log(`Salto ${doc.id} - nessun contenuto trovato`);
continue;
}
const data = {
name: documentName,
content: doc.content,
metadata: metadata
};
try {
const response = await axios.post(
`${baseUrl}/vector-stores/${vectorStoreId}/documents/text`,
data,
{ headers }
);
if (response.status === 201) {
console.log(`Documento '${documentName}' caricato con successo!`);
results.push({ id: doc.id, success: true });
} else {
console.error(`Errore nel caricamento del documento ${documentName}: ${response.statusText}`);
results.push({ id: doc.id, success: false, error: response.statusText });
}
} catch (error) {
console.error(`Errore nel caricamento del documento ${documentName}: ${error.message}`);
results.push({ id: doc.id, success: false, error: error.message });
}
// Aggiungi un piccolo ritardo per prevenire il limite di velocità
await new Promise(resolve => setTimeout(resolve, 100));
}
return results;
}
// Funzione principale di migrazione
async function migrateSupabaseToRememberizer() {
try {
console.log('Inizio migrazione da Supabase pgvector a Rememberizer...');
let offset = 0;
let totalMigrated = 0;
while (true) {
const documents = await fetchDocumentsFromSupabase(BATCH_SIZE, offset);
if (documents.length === 0) {
break;
}
console.log(`Recuperati ${documents.length} documenti da Supabase`);
const results = await uploadToRememberizer(documents);
const successCount = results.filter(r => r.success).length;
totalMigrated += successCount;
console.log(`Progresso: ${totalMigrated} documenti migrati con successo`);
offset += BATCH_SIZE;
}
console.log(`Migrazione completata! ${totalMigrated} documenti totali migrati su Rememberizer`);
} catch (error) {
console.error('Migrazione fallita:', error);
} finally {
await supabasePool.end();
}
}
// Esegui la migrazione
// migrateSupabaseToRememberizer();
Migliori Pratiche per la Migrazione
Segui queste raccomandazioni per una migrazione di successo:
Pianifica in Anticipo:
Stima il volume dei dati e il tempo necessario per la migrazione
Pianifica la migrazione durante i periodi di bassa affluenza
Aumenta lo spazio su disco prima di iniziare grandi migrazioni
Testa Prima:
Crea un archivio vettoriale di prova in Rememberizer
Migra un piccolo sottoinsieme di dati (100-1000 vettori)
Verifica la funzionalità di ricerca con query chiave
Validazione dei Dati:
Confronta i conteggi dei documenti prima e dopo la migrazione
Esegui query di benchmark per garantire risultati simili
Valida che i metadati siano correttamente preservati
Ottimizza per le Prestazioni:
Usa operazioni in batch per efficienza
Considera la collocazione geografica dei database sorgente e di destinazione
Monitora i limiti di velocità dell'API e regola le dimensioni dei batch di conseguenza
Passi Post-Migrazione:
Verifica la creazione dell'indice in Rememberizer
Aggiorna le configurazioni dell'applicazione per puntare al nuovo archivio vettoriale
Tieni il database sorgente come backup fino a quando la migrazione non è verificata