Archivi vettoriali
Questa guida ti aiuterà a capire come utilizzare il Rememberizer Vector Store come sviluppatore.
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 Cosa sono le embedding vettoriali e i database vettoriali?.
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
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
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
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?")
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
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
enext_chunks
per recuperare contenuti circostantiConteggio dei Risultati: Inizia con 3-5 risultati (
n
parametro) e adatta in base alle esigenze di precisioneSoglia: 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()
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()
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()
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
Per un riferimento API dettagliato e documentazione sugli endpoint, visita la pagina Documentazione dell'Archiviazione Vettoriale.
Assicurati di gestire le chiavi API in modo sicuro e segui le migliori pratiche per la gestione delle chiavi API.
Last updated