Vektorlager

Denne guide vil hjælpe dig med at forstå, hvordan du bruger Rememberizer Vector Store som udvikler.

Rememberizer Vektorbutik forenkler processen med at håndtere vektordata, så du kan fokusere på tekstinput og udnytte kraften i vektorer til forskellige applikationer såsom søgning og dataanalyse.

Introduktion

Rememberizer Vector Store tilbyder en brugervenlig grænseflade til håndtering af vektordata, mens kompleksiteten ved vektorindlejringer abstraheres. Drevet af PostgreSQL med pgvector-udvidelsen, giver Rememberizer Vector Store dig mulighed for at arbejde direkte med tekst. Tjenesten håndterer opdeling, vektorisering og lagring af tekstdata, hvilket gør det lettere for dig at fokusere på din kerneapplikationslogik.

For en dybere forståelse af de teoretiske koncepter bag vektorindlejringer og vektordatabaser, se Hvad er vektorindlejringer og vektordatabaser?.

Teknisk Oversigt

Hvordan Vektorbutikker Fungerer

Rememberizer Vektorbutikker konverterer tekst til højdimensionale vektorrepræsentationer (indlejring), der fanger semantisk betydning. Dette muliggør:

  1. Semantisk Søgning: Find dokumenter baseret på betydning snarere end blot nøgleord

  2. Ligheds Matching: Identificer konceptuelt relateret indhold

  3. Effektiv Hentning: Hurtigt finde relevant information fra store datasæt

Nøglekomponenter

  • Dokumentbehandling: Teksten opdeles i optimalt størrelsesdelte bidder med overlappende grænser for at bevare konteksten

  • Vektorisering: Bidder konverteres til indlejringer ved hjælp af state-of-the-art modeller

  • Indeksering: Specialiserede algoritmer organiserer vektorer til effektiv lighedssøgning

  • Forespørgselsbehandling: Søgeforespørgsler vektorisers og sammenlignes med gemte indlejringer

Arkitektur

Rememberizer implementerer vektorbutikker ved hjælp af:

  • PostgreSQL med pgvector-udvidelse: Til effektiv vektoropbevaring og søgning

  • Samling-baseret organisering: Hver vektorbutik har sin egen isolerede samling

  • API-drevet adgang: Enkle RESTful slutpunkter til alle operationer

Kom godt i gang

Oprettelse af en Vektorbutik

  1. Naviger til sektionen for Vektorbutikker i dit dashboard

  2. Klik på "Opret ny Vektorbutik":

    • En formular vises, der beder dig om at indtaste oplysninger.

  3. Udfyld oplysningerne:

    • Navn: Angiv et unikt navn til din vektorbutik.

    • Beskrivelse: Skriv en kort beskrivelse af vektorbutikken.

    • Indlejringsmodel: Vælg den model, der konverterer tekst til vektorer.

    • Indekseringsalgoritme: Vælg, hvordan vektorer vil blive organiseret til søgning.

    • Søgemetrik: Definer, hvordan lighed mellem vektorer beregnes.

    • Vektordimension: Størrelsen på vektorindlejringerne (typisk 768-1536).

  4. Indsend formularen:

    • Klik på "Opret" knappen. Du vil modtage en succesmeddelelse, og den nye butik vil vises i din liste over vektorbutikker.

Opret en ny vektorbutik
Opret en ny vektorbutik

Konfigurationsmuligheder

Indlejringsmodeller

Model
Dimensioner
Beskrivelse
Bedst til

openai/text-embedding-3-large

1536

Højpræcisions indlejringsmodel fra OpenAI

Produktionsapplikationer, der kræver maksimal nøjagtighed

openai/text-embedding-3-small

1536

Mindre, hurtigere indlejringsmodel fra OpenAI

Applikationer med højere gennemstrømningskrav

Indekseringsalgoritmer

Algoritme
Beskrivelse
Afvejninger

IVFFLAT (standard)

Inverteret fil med flad kompression

God balance mellem hastighed og nøjagtighed; fungerer godt for de fleste datasæt

HNSW

Hierarkisk Navigerbar Lille Verden

Bedre nøjagtighed for store datasæt; højere hukommelseskrav

Søgemetrikker

Metode
Beskrivelse
Bedst til

cosine (standard)

Måler vinklen mellem vektorer

Generel formål lighedsmatch

indre produkt (ip)

Punktprodukt mellem vektorer

Når vektormagnituden er vigtig

L2 (Euclidean)

Lige afstand mellem vektorer

Når rumlige forhold betyder noget

Håndtering af Vektorbutikker

  1. Vis og Rediger Vektorbutikker:

    • Få adgang til administrationsdashboardet for at se, redigere eller slette vektorbutikker.

  2. Visning af Dokumenter:

    • Gennemse individuelle dokumenter og deres tilknyttede metadata inden for en specifik vektorbutik.

  3. Statistik:

    • Se detaljerede statistikker såsom antallet af gemte vektorer, forespørgselsydelse og driftsmålinger.

Vis Detaljer om en Vektorbutik
Vis Detaljer om en Vektorbutik

API Nøglehåndtering

API-nøgler bruges til at autentificere og autorisere adgang til Rememberizer Vector Store's API-endepunkter. Korrekt håndtering af API-nøgler er afgørende for at opretholde sikkerheden og integriteten af dine vektorlager.

Oprettelse af API-nøgler

  1. Gå til din Vector Store detaljer side

  2. Naviger til sektionen for API-nøgleadministration:

    • Den kan findes under fanen "Konfiguration"

  3. Klik på "Tilføj API-nøgle":

    • En formular vises, der beder dig om at indtaste oplysninger.

  4. Udfyld oplysningerne:

    • Navn: Angiv et navn til API-nøglen for at hjælpe dig med at identificere dens anvendelsestilfælde.

  5. Indsend formularen:

    • Klik på "Opret" knappen. Den nye API-nøgle vil blive genereret og vist. Sørg for at kopiere og opbevare den sikkert. Denne nøgle bruges til at godkende anmodninger til den specifikke vector store.

Opret en ny API-nøgle
Opret en ny API-nøgle

Tilbagetrækning af API-nøgler

Hvis en API-nøgle ikke længere er nødvendig, kan du slette den for at forhindre potentiel misbrug.

Af sikkerhedsmæssige årsager kan du overveje at rotere dine API-nøgler periodisk. Dette indebærer at generere en ny nøgle og tilbagetrække den gamle.

Brug af Vector Store API

Efter at have oprettet en Vector Store og genereret en API-nøgle, kan du interagere med den ved hjælp af REST API'en.

Kodeeksempler

import requests
import json

API_KEY = "your_api_key_here"
VECTOR_STORE_ID = "vs_abc123"  # Erstat med dit vector store ID
BASE_URL = "https://api.rememberizer.a

# Upload et dokument til vektorbutikken
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"Dokument '{document_name}' uploadet med succes!")
            return response.json()
        else:
            print(f"Fejl ved upload af dokument: {response.text}")
            return None

# Upload tekstindhold til vektorbutikken
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"Tekstdokument '{document_name}' uploadet med succes!")
        return response.json()
    else:
        print(f"Fejl ved upload af tekst: {response.text}")
        return None

# Søg i vektorbutikken
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"Fundet {len(results['matched_chunks'])} match for '{query}'")
        
        # Udskriv det bedste resultat
        if results['matched_chunks']:
            top_match = results['matched_chunks'][0]
            print(f"Bedste match (afstand: {top_match['distance']}):")
            print(f"Dokument: {top_match['document']['name']}")
            print(f"Indhold: {top_match['matched_content']}")
        
        return results
    else:
        print(f"Fejl ved søgning: {response.text}")
        return None

# Eksempel på brug
# upload_document("path/to/document.pdf")
# upload_text("Dette er en prøve tekst, der skal vektorisere", "sample-document.txt")
# search_vector_store("Hvordan fungerer vektorsimilaritet?")

Ydelsesovervejelser

Kommer snart: Vektorbutik Arkitekturdiagram

Dette tekniske arkitekturdiagram vil illustrere:

  • PostgreSQL + pgvector fundamentarkitektur

  • Indekseringsalgoritmestrukturer (IVFFLAT vs. HNSW)

  • Hvordan søgemetrikker fungerer i vektorrum (visuel sammenligning)

  • Dokumentchunking-proces med overlapvisualisering

  • Ydelsesovervejelser visualiseret på tværs af forskellige skalaer

Optimering for Forskellige Datavolumener

Datavolumen
Anbefalet Konfiguration
Noter

Lille (<10k dokumenter)

IVFFLAT, cosinuslighed

Enkel konfiguration giver god ydeevne

Medium (10k-100k dokumenter)

IVFFLAT, sørg for regelmæssig reindeksering

Balance mellem søgehastighed og indeksvedligeholdelse

Stor (>100k dokumenter)

HNSW, overvej at øge vektordimensioner

Højere hukommelsesforbrug, men opretholder ydeevne i stor skala

Chunking Strategier

Chunking-processen påvirker søgekvaliteten betydeligt:

  • Chunk Størrelse: Rememberizer bruger en standard chunk størrelse på 1024 bytes med en overlapning på 200 bytes

  • Mindre Chunks (512-1024 bytes): Mere præcise matches, bedre til specifikke spørgsmål

  • Større Chunks (1500-2048 bytes): Mere kontekst i hvert match, bedre til bredere emner

  • Overlapning: Sikrer at konteksten ikke går tabt ved chunk-grænser

Forespørgselsoptimering

  • Kontekstvinduer: Brug prev_chunks og next_chunks til at hente omgivende indhold

  • Resultatantal: Start med 3-5 resultater (n parameter) og juster baseret på præcisionsbehov

  • Tærskel: Juster t parameteren for at filtrere resultater efter lighedsscore

Avanceret brug

Reindeksering

Rememberizer udløser automatisk reindeksering, når vektortællinger overstiger foruddefinerede tærskler, men overvej manuel reindeksering efter:

  • Upload af et stort antal dokumenter

  • Ændring af indlejringsmodellen

  • Modifikation af indekseringsalgoritmen

Spørgsmål Forbedring

For bedre søgeresultater:

  1. Vær specifik i søgespørgsmål

  2. Inkluder kontekst når det er muligt

  3. Brug naturligt sprog frem for nøgleord

  4. Justér parametre baseret på resultatkvalitet

Migration fra Andre Vektordatabaser

Hvis du i øjeblikket bruger andre vektordatabase-løsninger og ønsker at migrere til Rememberizer Vector Store, vil de følgende vejledninger hjælpe dig med at overføre dine data effektivt.

Migrering Oversigt

Migrering af vektordata involverer:

  1. Eksportering af data fra din kildevektordatabase

  2. Konvertering af data til et format, der er kompatibelt med Rememberizer

  3. Importering af data til din Rememberizer Vektorbutik

  4. Verificering af, at migreringen var vellykket

Fordele ved at migrere til Rememberizer

  • PostgreSQL Foundation: Bygget på moden databasteknologi med indbygget backup og gendannelse

  • Integreret Økosystem: Problemfri forbindelse med andre Rememberizer-komponenter

  • Forenklet Administration: Unified interface til vektoroperationer

  • Avanceret Sikkerhed: Sikkerhed på række-niveau og detaljerede adgangskontroller

  • Skalerbar Arkitektur: Ydelsesoptimering efterhånden som dine data vokser

Migrering fra Pinecone

import os
import pinecone
import requests
import json
import time

# Opsæt Pinecone-klient
pinecone.init(api_key="PINECONE_API_KEY", environment="PINECONE_ENV")
source_index = pinecone.Index("your-pinecone-index")

# Opsæt Rememberizer Vector Store-klient
REMEMBERIZER_API_KEY = "your_rememberizer_api_key"
VECTOR_STORE_ID = "vs_abc123"  # Dit Rememberizer vector store ID
BASE_URL = "https://api.rememberizer.ai/api/v1"

# 1. Opsæt batchstørrelse til migration (juster baseret på din datastørrelse)
BATCH_SIZE = 100

# 2. Funktion til at hente vektorer fra Pinecone
def fetch_vectors_from_pinecone(index_name, batch_size, cursor=None):
    # Brug listeoperationen, hvis den er tilgængelig i din Pinecone-version
    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:
        # For ældre Pinecone-versioner uden listeoperation
        # Dette er en forenklet tilgang; den faktiske implementering afhænger af dit dataadgangsmønster
        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. Funktion til at uploade vektorer til 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():
        # Konverter Pinecone vektordata til Rememberizer format
        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"Springer {vector_id} over - ingen tekstindhold fundet i metadata")
            continue
            
        data = {
            "name": document_name,
            "content": content,
            # Valgfrit: inkluder yderligere metadata
            "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"Dokument '{document_name}' uploadet med succes!")
        else:
            print(f"Fejl ved upload af dokument {document_name}: {response.text}")
        
        # Tilføj en lille forsinkelse for at forhindre rate limiting
        time.sleep(0.1)

# 4. Hoved migrationsfunktion
def migrate_pinecone_to_rememberizer():
    cursor = None
    total_migrated = 0
    
    print("Starter migration fra Pinecone til Rememberizer...")
    
    while True:
        vectors, cursor = fetch_vectors_from_pinecone("your-pinecone-index", BATCH_SIZE, cursor)
        
        if not vectors:
            break
            
        print(f"Hentet {len(vectors)} vektorer fra Pinecone")
        upload_to_rememberizer(vectors)
        
        total_migrated += len(vectors)
        print(f"Fremdrift: {total_migrated} vektorer migreret")
        
        if not cursor:
            break
    
    print(f"Migrering fuldført! {total_migrated} samlede vektorer migreret til Rememberizer")

# Kør migrationen
# migrate_pinecone_to_rememberizer()

Migrering fra Qdrant

import requests
import json
import time
from qdrant_client import QdrantClient
from qdrant_client.http import models as rest

# Opsæt Qdrant-klient
QDRANT_URL = "http://localhost:6333"  # eller din Qdrant cloud URL
QDRANT_API_KEY = "your_qdrant_api_key"  # hvis du bruger Qdrant Cloud
QDRANT_COLLECTION_NAME = "your_collection"

qdrant_client = QdrantClient(
    url=QDRANT_URL,
    api_key=QDRANT_API_KEY  # Kun for Qdrant Cloud
)

# Opsæt Rememberizer Vector Store-klient
REMEMBERIZER_API_KEY = "your_rememberizer_api_key"
VECTOR_STORE_ID = "vs_abc123"  # Dit Rememberizer vector store ID
BASE_URL = "https://api.rememberizer.ai/api/v1"

# Batch størrelse til behandling
BATCH_SIZE = 100

# Funktion til at hente punkter fra Qdrant
def fetch_points_from_qdrant(collection_name, batch_size, offset=0):
    try:
        # Hent kollektionsinfo for at bestemme vektordimension
        collection_info = qdrant_client.get_collection(collection_name=collection_name)
        
        # Rul gennem punkter
        scroll_result = qdrant_client.scroll(
            collection_name=collection_name,
            limit=batch_size,
            offset=offset,
            with_payload=True,
            with_vectors=True
        )
        
        points = scroll_result[0]  # Tuple af (punkter, næste_offset)
        next_offset = scroll_result[1]
        
        return points, next_offset
    except Exception as e:
        print(f"Fejl ved hentning af punkter fra Qdrant: {e}")
        return [], None

# Funktion til at uploade vektorer til Rememberizer
def upload_to_rememberizer(points):
    headers = {
        "x-api-key": REMEMBERIZER_API_KEY,
        "Content-Type": "application/json"
    }
    
    results = []
    
    for point in points:
        # Uddrag data fra Qdrant punkt
        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"Springer over {point_id} - ingen tekstindhold fundet i payload")
            continue
            
        data = {
            "name": document_name,
            "content": text_content,
            # Valgfrit: inkluder yderligere metadata
            "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"Dokument '{document_name}' uploadet med succes!")
                results.append({"id": point_id, "success": True})
            else:
                print(f"Fejl ved upload af dokument {document_name}: {response.text}")
                results.append({"id": point_id, "success": False, "error": response.text})
        except Exception as e:
            print(f"Undtagelse ved upload af dokument {document_name}: {str(e)}")
            results.append({"id": point_id, "success": False, "error": str(e)})
        
        # Tilføj en lille forsinkelse for at forhindre rate limiting
        time.sleep(0.1)
    
    return results

# Hoved migrationsfunktion
def migrate_qdrant_to_rememberizer():
    offset = None
    total_migrated = 0
    
    print("Starter migration fra Qdrant til Rememberizer...")
    
    while True:
        points, next_offset = fetch_points_from_qdrant(
            QDRANT_COLLECTION_NAME, 
            BATCH_SIZE,
            offset
        )
        
        if not points:
            break
            
        print(f"Hentet {len(points)} punkter fra 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"Fremdrift: {total_migrated} punkter migreret med succes")
        
        if next_offset is None:
            break
            
        offset = next_offset
    
    print(f"Migrering fuldført! {total_migrated} samlede punkter migreret til Rememberizer")

# Kør migrationen
# migrate_qdrant_to_rememberizer()

Migration fra Supabase pgvector

Hvis du allerede bruger Supabase med pgvector, er migrationen til Rememberizer særligt ligetil, da begge bruger PostgreSQL med pgvector-udvidelsen.

import psycopg2
import requests
import json
import time
import os
from dotenv import load_dotenv

# Indlæs miljøvariabler
load_dotenv()

# Supabase PostgreSQL konfiguration
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")

# Rememberizer konfiguration
REMEMBERIZER_API_KEY = os.getenv("REMEMBERIZER_API_KEY")
VECTOR_STORE_ID = os.getenv("VECTOR_STORE_ID")  # f.eks. "vs_abc123"
BASE_URL = "https://api.rememberizer.ai/api/v1"

# Batch størrelse til behandling
BATCH_SIZE = 100

# Forbind til 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"Fejl ved forbindelse til Supabase PostgreSQL: {e}")
        return None

# Hent dokumenter fra Supabase pgvector
def fetch_documents_from_supabase(conn, batch_size, offset=0):
    try:
        cursor = conn.cursor()
        
        # Juster denne forespørgsel baseret på din tabelstruktur
        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"Fejl ved hentning af dokumenter fra Supabase: {e}")
        return []

# Upload dokumenter til Rememberizer
def upload_to_rememberizer(dokumenter):
    headers = {
        "x-api-key": REMEMBERIZER_API_KEY,
        "Content-Type": "application/json"
    }
    
    resultater = []
    
    for doc in dokumenter:
        doc_id, indhold, metadata, embedding = doc
        
        # Parse metadata hvis det er gemt som JSON-streng
        if isinstance(metadata, str):
            try:
                metadata = json.loads(metadata)
            except:
                metadata = {}
        elif metadata is None:
            metadata = {}
        
        dokument_navn = metadata.get("filename", f"supabase_doc_{doc_id}")
        
        if not indhold:
            print(f"Springer {doc_id} over - ingen indhold fundet")
            continue
            
        data = {
            "name": dokument_navn,
            "content": indhold,
            "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"Dokument '{dokument_navn}' uploadet med succes!")
                resultater.append({"id": doc_id, "success": True})
            else:
                print(f"Fejl ved upload af dokument {dokument_navn}: {response.text}")
                resultater.append({"id": doc_id, "success": False, "error": response.text})
        except Exception as e:
            print(f"Undtagelse ved upload af dokument {dokument_navn}: {str(e)}")
            resultater.append({"id": doc_id, "success": False, "error": str(e)})
        
        # Tilføj en lille forsinkelse for at forhindre rate limiting
        time.sleep(0.1)
    
    return resultater

# Hoved migrationsfunktion
def migrate_supabase_to_rememberizer():
    conn = connect_to_supabase()
    if not conn:
        print("Mislykkedes at oprette forbindelse til Supabase. Afbryder migration.")
        return
    
    offset = 0
    total_migrated = 0
    
    print("Starter migration fra Supabase pgvector til Rememberizer...")
    
    try:
        while True:
            documents = fetch_documents_from_supabase(conn, BATCH_SIZE, offset)
            
            if not documents:
                break
                
            print(f"Hentede {len(documents)} dokumenter fra 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"Fremdrift: {total_migrated} dokumenter migreret med succes")
            
            offset += BATCH_SIZE
            
    finally:
        conn.close()
    
    print(f"Migrering fuldført! {total_migrated} samlede dokumenter migreret til Rememberizer")

# Kør migrationen
# migrate_supabase_to_rememberizer()

Migrerings bedste praksis

Følg disse anbefalinger for en vellykket migrering:

  1. Planlæg på forhånd:

    • Estimér datamængden og den tid, der kræves til migrering

    • Planlæg migrering i perioder med lav trafik

    • Øg diskpladsen før du starter store migreringer

  2. Test først:

    • Opret et testvektorlager i Rememberizer

    • Migrer et lille udsnit af data (100-1000 vektorer)

    • Bekræft søgefunktionaliteten med nøglespørgsmål

  3. Datavalidering:

    • Sammenlign dokumenttællinger før og efter migrering

    • Kør benchmark-spørgsmål for at sikre lignende resultater

    • Valider at metadata er korrekt bevaret

  4. Optimer for ydeevne:

    • Brug batchoperationer for effektivitet

    • Overvej geografisk kolokation af kilde- og mål-databaser

    • Overvåg API-hastighedsgrænser og juster batchstørrelserne derefter

  5. Post-migrerings trin:

    • Bekræft indeksoprettelse i Rememberizer

    • Opdater applikationskonfigurationer til at pege på det nye vektorlager

    • Behold kilde-databasen som backup, indtil migreringen er bekræftet

For detaljeret API-referencer og endpoint-dokumentation, besøg Vektorbutik Dokumentation siden.


Sørg for at håndtere API-nøgler sikkert og følge bedste praksis for API-nøglehåndtering.

Last updated