벡터 저장소

이 가이드는 개발자로서 Rememberizer 벡터 저장소를 사용하는 방법을 이해하는 데 도움이 될 것입니다.

벡터 저장소

Rememberizer 벡터 저장소는 벡터 데이터를 처리하는 과정을 간소화하여 텍스트 입력에 집중하고 검색 및 데이터 분석과 같은 다양한 응용 프로그램을 위해 벡터의 힘을 활용할 수 있도록 합니다.

소개

Rememberizer 벡터 저장소는 벡터 임베딩의 복잡성을 추상화하면서 벡터 데이터를 처리하기 위한 사용하기 쉬운 인터페이스를 제공합니다. pgvector 확장을 사용하는 PostgreSQL로 구동되는 Rememberizer 벡터 저장소는 텍스트와 직접 작업할 수 있게 해줍니다. 이 서비스는 텍스트 데이터를 청크화하고, 벡터화하며, 저장하는 작업을 처리하여 귀하가 핵심 애플리케이션 로직에 집중할 수 있도록 합니다.

벡터 임베딩 및 벡터 데이터베이스 뒤에 있는 이론적 개념에 대한 더 깊은 이해를 원하시면 벡터 임베딩과 벡터 데이터베이스란 무엇인가요?를 참조하세요.

기술 개요

벡터 스토어의 작동 방식

Rememberizer 벡터 스토어는 텍스트를 의미론적 의미를 포착하는 고차원 벡터 표현(임베딩)으로 변환합니다. 이를 통해 다음과 같은 기능이 가능합니다:

1. 의미 기반 검색: 키워드뿐만 아니라 의미에 따라 문서 찾기

2. 유사성 매칭: 개념적으로 관련된 콘텐츠 식별

3. 효율적인 검색: 대규모 데이터셋에서 관련 정보 신속하게 찾기

주요 구성 요소

• 문서 처리: 텍스트는 맥락 보존을 위해 겹치는 경계를 가진 최적 크기의 청크로 분할됩니다.

• 벡터화: 청크는 최첨단 모델을 사용하여 임베딩으로 변환됩니다.

• 인덱싱: 전문 알고리즘이 벡터를 효율적인 유사성 검색을 위해 정리합니다.

• 쿼리 처리: 검색 쿼리는 벡터화되어 저장된 임베딩과 비교됩니다.

아키텍처

Rememberizer는 다음을 사용하여 벡터 저장소를 구현합니다:

• pgvector 확장을 사용하는 PostgreSQL: 효율적인 벡터 저장 및 검색을 위해

• 컬렉션 기반 조직: 각 벡터 저장소는 고유한 격리된 컬렉션을 가집니다

• API 기반 접근: 모든 작업을 위한 간단한 RESTful 엔드포인트

시작하기

벡터 스토어 생성

1. 대시보드에서 벡터 스토어 섹션으로 이동합니다.

2. "새 벡터 스토어 생성"을 클릭합니다:

   • 세부 정보를 입력하라는 양식이 나타납니다.

3. 세부 정보 입력:

   • 이름: 벡터 스토어에 대한 고유한 이름을 제공합니다.

   • 설명: 벡터 스토어에 대한 간략한 설명을 작성합니다.

   • 임베딩 모델: 텍스트를 벡터로 변환하는 모델을 선택합니다.

   • 인덱싱 알고리즘: 검색을 위해 벡터가 어떻게 조직될지를 선택합니다.

   • 검색 메트릭: 벡터 간 유사성이 어떻게 계산되는지를 정의합니다.

   • 벡터 차원: 벡터 임베딩의 크기(일반적으로 768-1536).

4. 양식 제출:

   • "생성" 버튼을 클릭합니다. 성공 알림을 받게 되며, 새 스토어가 벡터 스토어 목록에 나타납니다.

새 벡터 스토어 생성

구성 옵션

임베딩 모델

모델	차원	설명	최적 사용
openai/text-embedding-3-large	1536	OpenAI의 고정밀 임베딩 모델	최대 정확도가 필요한 프로덕션 애플리케이션
openai/text-embedding-3-small	1536	OpenAI의 더 작고 빠른 임베딩 모델	더 높은 처리량 요구 사항이 있는 애플리케이션

인덱싱 알고리즘

알고리즘	설명	트레이드오프
IVFFLAT (기본값)	평면 압축이 적용된 역 파일	속도와 정확도의 좋은 균형; 대부분의 데이터셋에 잘 작동
HNSW	계층적 탐색 가능한 소규모 세계	대규모 데이터셋에 대한 더 나은 정확도; 더 높은 메모리 요구 사항

검색 메트릭

메트릭	설명	최적 사용
코사인 (기본값)	벡터 간의 각도를 측정	일반적인 유사성 매칭
내적 (ip)	벡터 간의 점곱	벡터 크기가 중요한 경우
L2 (유클리드)	벡터 간의 직선 거리	공간적 관계가 중요한 경우

벡터 저장소 관리

1. 벡터 저장소 보기 및 편집:

   • 관리 대시보드에 접근하여 벡터 저장소를 보고, 편집하거나 삭제합니다.

2. 문서 보기:

   • 특정 벡터 저장소 내에서 개별 문서와 그에 연결된 메타데이터를 탐색합니다.

3. 통계:

   • 저장된 벡터 수, 쿼리 성능 및 운영 메트릭과 같은 자세한 통계를 봅니다.

벡터 저장소 세부정보 보기

API 키 관리

API 키는 Rememberizer 벡터 스토어의 API 엔드포인트에 대한 접근을 인증하고 권한을 부여하는 데 사용됩니다. API 키의 적절한 관리는 벡터 스토어의 보안과 무결성을 유지하는 데 필수적입니다.

API 키 생성

1. Vector Store 세부정보 페이지로 이동합니다.

2. API 키 관리 섹션으로 이동합니다:

   • "구성" 탭 내에서 찾을 수 있습니다.

3. **"API 키 추가"**를 클릭합니다:

   • 세부정보를 입력하라는 메시지가 표시되는 양식이 나타납니다.

4. 세부정보 입력:

   • 이름: API 키의 사용 사례를 식별할 수 있도록 이름을 제공합니다.

5. 양식 제출:

   • "생성" 버튼을 클릭합니다. 새로운 API 키가 생성되어 표시됩니다. 반드시 복사하여 안전하게 저장하십시오. 이 키는 특정 벡터 저장소에 대한 요청을 인증하는 데 사용됩니다.

새 API 키 생성

API 키 취소

더 이상 API 키가 필요하지 않은 경우, 잠재적인 오용을 방지하기 위해 삭제할 수 있습니다.

보안상의 이유로, 주기적으로 API 키를 교체하는 것이 좋습니다. 이는 새 키를 생성하고 이전 키를 취소하는 과정을 포함합니다.

벡터 스토어 API 사용하기

벡터 스토어를 생성하고 API 키를 생성한 후, REST API를 사용하여 상호작용할 수 있습니다.

코드 예제

Python

import requests
import json

API_KEY = "your_api_key_here"
VECTOR_STORE_ID = "vs_abc123"  # 벡터 저장소 ID로 교체하세요
BASE_URL = "https://api.rememberizer.ai/api/v1"

벡터 저장소에 문서 업로드

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"문서 '{document_name}'이(가) 성공적으로 업로드되었습니다!")
        return response.json()
    else:
        print(f"문서 업로드 오류: {response.text}")
        return None

벡터 스토어에 텍스트 콘텐츠 업로드

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"텍스트 문서 '{document_name}'가 성공적으로 업로드되었습니다!")
    return response.json()
else:
    print(f"텍스트 업로드 오류: {response.text}")
    return None

벡터 저장소 검색

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"'{query}'에 대한 {len(results['matched_chunks'])}개의 일치 항목을 찾았습니다.")
    
    # 상위 결과 출력
    if results['matched_chunks']:
        top_match = results['matched_chunks'][0]
        print(f"상위 일치 (거리: {top_match['distance']}):")
        print(f"문서: {top_match['document']['name']}")
        print(f"내용: {top_match['matched_content']}")
    
    return results
else:
    print(f"검색 오류: {response.text}")
    return None

예제 사용법

문서 업로드("path/to/document.pdf")

upload_text("이것은 벡터화할 샘플 텍스트입니다", "sample-document.txt")

search_vector_store("벡터 유사성은 어떻게 작동합니까?")

</div>

<div data-gb-custom-block data-tag="tab" data-title='JavaScript'>

```javascript
// 벡터 저장소 API 클라이언트
class VectorStoreClient {
  constructor(apiKey, vectorStoreId) {
    this.apiKey = apiKey;
    this.vectorStoreId = vectorStoreId;
    this.baseUrl = 'https://api.rememberizer.ai/api/v1';
  }

  // 벡터 저장소 정보 가져오기
  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(`벡터 저장소 정보를 가져오는 데 실패했습니다: ${response.statusText}`);
    }
    
    return response.json();
  }

  // 텍스트 문서 업로드
  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(`텍스트 문서 업로드에 실패했습니다: ${response.statusText}`);
    }
    
    return response.json();
  }

  // 파일 업로드
  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(`파일 업로드에 실패했습니다: ${xhr.statusText}`));
        }
      };
      
      xhr.onerror = () => {
        reject(new Error('파일 업로드 중 네트워크 오류'));
      };
      
      xhr.send(formData);
    });
  }

  // 벡터 저장소에서 문서 검색
  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(`검색 실패: ${response.statusText}`);
    }
    
    return response.json();
  }

  // 벡터 저장소의 모든 문서 목록
  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(`문서 목록을 가져오는 데 실패했습니다: ${response.statusText}`);
    }
    
    return response.json();
  }

  // 문서 삭제
  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(`문서 삭제에 실패했습니다: ${response.statusText}`);
    }
    
    return true;
  }
}

// 사용 예시
/*
const client = new VectorStoreClient('your_api_key', 'vs_abc123');

// 문서 검색
client.searchDocuments('의미론적 검색은 어떻게 작동합니까?')
  .then(results => {
    console.log(`찾은 일치 항목 수: ${results.matched_chunks.length}`);
    results.matched_chunks.forEach(match => {
      console.log(`문서: ${match.document.name}`);
      console.log(`점수: ${match.distance}`);
      console.log(`내용: ${match.matched_content}`);
      console.log('---');
    });
  })
  .catch(error => console.error(error));
*/

require 'net/http'
require 'uri'
require 'json'

class VectorStoreClient
  def initialize(api_key, vector_store_id)
    @api_key = api_key
    @vector_store_id = vector_store_id
    @base_url = 'https://api.rememberizer.ai/api/v1'
  end

  # 벡터 저장소 세부정보 가져오기
  def get_vector_store_info
    uri = URI("#{@base_url}/vector-stores/#{@vector_store_id}")
    request = Net::HTTP::Get.new(uri)
    request['x-api-key'] = @api_key
    
    response = send_request(uri, request)
    JSON.parse(response.body)
  end

  # 텍스트 내용 업로드
  def upload_text(name, content)
    uri = URI("#{@base_url}/vector-stores/#{@vector_store_id}/documents/text")
    request = Net::HTTP::Post.new(uri)
    request['Content-Type'] = 'application/json'
    request['x-api-key'] = @api_key
    
    request.body = {
      name: name,
      content: content
    }.to_json
    
    response = send_request(uri, request)
    JSON.parse(response.body)
  end

  # 문서 검색
  def search(query, num_results: 5, prev_chunks: 1, next_chunks: 1, threshold: nil)
    uri = URI("#{@base_url}/vector-stores/#{@vector_store_id}/documents/search")
    params = {
      q: query,
      n: num_results,
      prev_chunks: prev_chunks,
      next_chunks: next_chunks
    }
    
    params[:t] = threshold if threshold
    
    uri.query = URI.encode_www_form(params)
    request = Net::HTTP::Get.new(uri)
    request['x-api-key'] = @api_key
    
    response = send_request(uri, request)
    JSON.parse(response.body)
  end

  # 문서 목록
  def list_documents
    uri = URI("#{@base_url}/vector-stores/#{@vector_store_id}/documents")
    request = Net::HTTP::Get.new(uri)
    request['x-api-key'] = @api_key
    
    response = send_request(uri, request)
    JSON.parse(response.body)
  end

  # 파일 업로드 (multipart form)
  def upload_file(file_path)
    uri = URI("#{@base_url}/vector-stores/#{@vector_store_id}/documents")
    
    file_name = File.basename(file_path)
    file_content = File.binread(file_path)
    
    boundary = "RememberizerBoundary#{rand(1000000)}"
    
    request = Net::HTTP::Post.new(uri)
    request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
    request['x-api-key'] = @api_key
    
    post_body = []
    post_body << "--#{boundary}\r\n"
    post_body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{file_name}\"\r\n"
    post_body << "Content-Type: application/octet-stream\r\n\r\n"
    post_body << file_content
    post_body << "\r\n--#{boundary}--\r\n"
    
    request.body = post_body.join
    
    response = send_request(uri, request)
    JSON.parse(response.body)
  end

  private

  def send_request(uri, request)
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = (uri.scheme == 'https')
    
    response = http.request(request)
    
    unless response.is_a?(Net::HTTPSuccess)
      raise "API 요청 실패: #{response.code} #{response.message}\n#{response.body}"
    end
    
    response
  end
end

예제 사용법

=begin client = VectorStoreClient.new('your_api_key', 'vs_abc123')

문서 검색

results = client.search('데이터 보안에 대한 모범 사례는 무엇인가요?') puts "발견된 결과 #{results['matched_chunks'].length}개"

상위 결과 표시

if results['matched_chunks'].any? top_match = results['matched_chunks'].first puts "상위 일치 (거리: #{top_match['distance']}):" puts "문서: #{top_match['document']['name']}" puts "내용: #{top_match['matched_content']}" end =end

</div>

<div data-gb-custom-block data-tag="tab" data-title='cURL'>

```bash
# API 키 및 벡터 저장소 ID 설정
API_KEY="your_api_key_here"
VECTOR_STORE_ID="vs_abc123"
BASE_URL="https://api.rememberizer.ai/api/v1"

# 벡터 저장소 정보 가져오기
curl -X GET "${BASE_URL}/vector-stores/${VECTOR_STORE_ID}" \
  -H "x-api-key: ${API_KEY}"

# 텍스트 문서 업로드
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": "이것은 벡터화되어 의미 검색을 위해 벡터 데이터베이스에 저장될 샘플 문서입니다."
  }'

# 파일 업로드
curl -X POST "${BASE_URL}/vector-stores/${VECTOR_STORE_ID}/documents" \
  -H "x-api-key: ${API_KEY}" \
  -F "file=@/path/to/your/document.pdf"

# 문서 검색
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}"

# 모든 문서 목록
curl -X GET "${BASE_URL}/vector-stores/${VECTOR_STORE_ID}/documents" \
  -H "x-api-key: ${API_KEY}"

# 문서 삭제
curl -X DELETE "${BASE_URL}/vector-stores/${VECTOR_STORE_ID}/documents/123" \
  -H "x-api-key: ${API_KEY}"

성능 고려사항

곧 출시: 벡터 스토어 아키텍처 다이어그램

이 기술 아키텍처 다이어그램은 다음을 설명합니다:

• PostgreSQL + pgvector 기반 아키텍처

• 인덱싱 알고리즘 구조 (IVFFLAT vs. HNSW)

• 벡터 공간에서 검색 메트릭이 작동하는 방식 (시각적 비교)

• 중복 시각화가 포함된 문서 청크 처리 과정

• 다양한 규모에서 시각화된 성능 고려사항

다양한 데이터 볼륨 최적화

데이터 볼륨	추천 구성	비고
소형 (<10k 문서)	IVFFLAT, 코사인 유사도	간단한 구성으로 좋은 성능 제공
중형 (10k-100k 문서)	IVFFLAT, 정기적인 재색인 보장	검색 속도와 인덱스 유지 관리 간의 균형
대형 (>100k 문서)	HNSW, 벡터 차원 증가 고려	더 높은 메모리 사용량이지만 대규모에서 성능 유지

청크 전략

청크 프로세스는 검색 품질에 상당한 영향을 미칩니다:

• 청크 크기: Rememberizer는 기본 청크 크기로 1024 바이트와 200 바이트의 중첩을 사용합니다.

• 더 작은 청크 (512-1024 바이트): 더 정확한 일치, 특정 질문에 더 적합합니다.

• 더 큰 청크 (1500-2048 바이트): 각 일치에서 더 많은 컨텍스트, 더 넓은 주제에 더 적합합니다.

• 중첩: 청크 경계에서 컨텍스트가 손실되지 않도록 보장합니다.

쿼리 최적화

• 컨텍스트 윈도우: prev_chunks 및 next_chunks를 사용하여 주변 콘텐츠를 검색합니다.

• 결과 수: 3-5개의 결과(n 매개변수)로 시작하고 정확도 요구에 따라 조정합니다.

• 임계값: 유사성 점수로 결과를 필터링하기 위해 t 매개변수를 조정합니다.

고급 사용법

재색인

Rememberizer는 벡터 수가 미리 정의된 임계값을 초과할 때 자동으로 재색인을 트리거하지만, 다음과 같은 경우 수동 재색인을 고려하십시오:

• 많은 수의 문서를 업로드할 때

• 임베딩 모델을 변경할 때

• 색인 알고리즘을 수정할 때

쿼리 향상

더 나은 검색 결과를 위해:

1. 구체적으로 검색 쿼리를 작성하세요

2. 가능할 경우 맥락을 포함하세요

3. 키워드보다는 자연어를 사용하세요

4. 결과 품질에 따라 매개변수를 조정하세요

다른 벡터 데이터베이스에서 마이그레이션하기

현재 다른 벡터 데이터베이스 솔루션을 사용하고 있고 Rememberizer Vector Store로 마이그레이션하고자 한다면, 다음 가이드가 데이터를 효율적으로 전환하는 데 도움이 될 것입니다.

마이그레이션 개요

벡터 데이터를 마이그레이션하는 과정은 다음과 같습니다:

1. 소스 벡터 데이터베이스에서 데이터 내보내기

2. 데이터를 Rememberizer와 호환되는 형식으로 변환

3. 데이터를 Rememberizer 벡터 저장소로 가져오기

4. 마이그레이션이 성공적으로 완료되었는지 확인

Rememberizer로의 마이그레이션 이점

• PostgreSQL 기반: 내장된 백업 및 복구 기능을 갖춘 성숙한 데이터베이스 기술로 구축

• 통합 생태계: 다른 Rememberizer 구성 요소와의 원활한 연결

• 간소화된 관리: 벡터 작업을 위한 통합 인터페이스

• 고급 보안: 행 수준 보안 및 세분화된 접근 제어

• 확장 가능한 아키텍처: 데이터가 증가함에 따라 성능 최적화

Pinecone에서 마이그레이션

Python

import os
import pinecone
import requests
import json
import time

# 파인콘 클라이언트 설정
pinecone.init(api_key="PINECONE_API_KEY", environment="PINECONE_ENV")
source_index = pinecone.Index("your-pinecone-index")

# Rememberizer 벡터 저장소 클라이언트 설정
REMEMBERIZER_API_KEY = "your_rememberizer_api_key"
VECTOR_STORE_ID = "vs_abc123"  # 귀하의 Rememberizer 벡터 저장소 ID
BASE_URL = "https://api.rememberizer.ai/api/v1"

# 1. 마이그레이션을 위한 배치 크기 설정 (데이터 크기에 따라 조정)
BATCH_SIZE = 100

# 2. Pinecone에서 벡터를 가져오는 함수
def fetch_vectors_from_pinecone(index_name, batch_size, cursor=None):
    # 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:
        # 목록 작업이 없는 이전 Pinecone 버전용
        # 이는 단순화된 접근 방식이며, 실제 구현은 데이터 접근 패턴에 따라 다릅니다.
        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. 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():
        # Pinecone 벡터 데이터를 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"건너뜁니다 {vector_id} - 메타데이터에서 텍스트 콘텐츠를 찾을 수 없습니다")
            continue
            
        data = {
            "name": document_name,
            "content": content,
            # 선택 사항: 추가 메타데이터 포함
            "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"문서 '{document_name}'가 성공적으로 업로드되었습니다!")
        else:
            print(f"문서 {document_name} 업로드 중 오류 발생: {response.text}")
        
        # 속도 제한을 방지하기 위해 약간의 지연 추가
        time.sleep(0.1)

# 4. 주요 마이그레이션 함수
def migrate_pinecone_to_rememberizer():
    cursor = None
    total_migrated = 0
    
    print("Pinecone에서 Rememberizer로 마이그레이션 시작...")
    
    while True:
        vectors, cursor = fetch_vectors_from_pinecone("your-pinecone-index", BATCH_SIZE, cursor)
        
        if not vectors:
            break
            
        print(f"Pinecone에서 {len(vectors)}개의 벡터를 가져왔습니다.")
        upload_to_rememberizer(vectors)
        
        total_migrated += len(vectors)
        print(f"진행 상황: {total_migrated}개의 벡터가 마이그레이션되었습니다.")
        
        if not cursor:
            break
    
    print(f"마이그레이션 완료! 총 {total_migrated}개의 벡터가 Rememberizer로 마이그레이션되었습니다.")

# 마이그레이션 실행
# migrate_pinecone_to_rememberizer()

Node.js

const { PineconeClient } = require('@pinecone-database/pinecone');
const axios = require('axios');

// Pinecone 구성
const pineconeApiKey = 'PINECONE_API_KEY';
const pineconeEnvironment = 'PINECONE_ENVIRONMENT';
const pineconeIndexName = 'YOUR_PINECONE_INDEX';

// Rememberizer 구성
const rememberizerApiKey = 'YOUR_REMEMBERIZER_API_KEY';
const vectorStoreId = 'vs_abc123';
const baseUrl = 'https://api.rememberizer.ai/api/v1';

// 배치 크기 구성
const BATCH_SIZE = 100;

// Pinecone 클라이언트 초기화
async function initPinecone() {
  const pinecone = new PineconeClient();
  await pinecone.init({
    apiKey: pineconeApiKey,
    environment: pineconeEnvironment,
  });
  return pinecone;
}

// Pinecone에서 벡터 가져오기
async function fetchVectorsFromPinecone(pinecone, batchSize, paginationToken = null) {
  const index = pinecone.Index(pineconeIndexName);
  
  try {
    // 최신 Pinecone 버전용
    const listResponse = await index.list({
      limit: batchSize,
      paginationToken: paginationToken
    });
    
    return {
      vectors: listResponse.vectors || {},
      nextToken: listResponse.paginationToken
    };
  } catch (error) {
    // 이전 Pinecone 버전용 대체
    // 이는 단순화된 것이며, 실제 구현은 데이터 접근 패턴에 따라 다릅니다.
    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 };
  }
}

// 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(`건너뜁니다 ${vectorId} - 메타데이터에서 텍스트 콘텐츠를 찾을 수 없습니다`);
      continue;
    }
    
    const data = {
      name: documentName,
      content: content,
      // 선택 사항: 추가 메타데이터 포함
      metadata: vectorData.metadata || {}
    };
    
    try {
      const response = await axios.post(
        `${baseUrl}/vector-stores/${vectorStoreId}/documents/text`,
        data,
        { headers }
      );
      
      if (response.status === 201) {
        console.log(`문서 '${documentName}'가 성공적으로 업로드되었습니다!`);
        results.push({ id: vectorId, success: true });
      } else {
        console.error(`문서 ${documentName} 업로드 오류: ${response.statusText}`);
        results.push({ id: vectorId, success: false, error: response.statusText });
      }
    } catch (error) {
      console.error(`문서 ${documentName} 업로드 오류: ${error.message}`);
      results.push({ id: vectorId, success: false, error: error.message });
    }
    
    // 속도 제한을 방지하기 위해 약간의 지연 추가
    await new Promise(resolve => setTimeout(resolve, 100));
  }
  
  return results;
}

// 주요 마이그레이션 함수
async function migratePineconeToRememberizer() {
  try {
    console.log('Pinecone에서 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(`Pinecone에서 ${Object.keys(vectors).length} 벡터를 가져왔습니다`);
      
      const results = await uploadToRememberizer(vectors);
      const successCount = results.filter(r => r.success).length;
      
      totalMigrated += successCount;
      console.log(`진행 상황: ${totalMigrated} 벡터가 성공적으로 마이그레이션되었습니다`);
      
    } while (nextToken);
    
    console.log(`마이그레이션 완료! 총 ${totalMigrated} 벡터가 Rememberizer로 마이그레이션되었습니다`);
    
  } catch (error) {
    console.error('마이그레이션 실패:', error);
  }
}

// 마이그레이션 실행
// migratePineconeToRememberizer();

Qdrant에서 마이그레이션하기

Python

import requests
import json
import time
from qdrant_client import QdrantClient
from qdrant_client.http import model

# Qdrant 클라이언트 설정
QDRANT_URL = "http://localhost:6333"  # 또는 Qdrant 클라우드 URL
QDRANT_API_KEY = "your_qdrant_api_key"  # Qdrant Cloud를 사용하는 경우
QDRANT_COLLECTION_NAME = "your_collection"

qdrant_client = QdrantClient(
    url=QDRANT_URL,
    api_key=QDRANT_API_KEY  # Qdrant Cloud 전용
)

# Rememberizer 벡터 저장소 클라이언트 설정
REMEMBERIZER_API_KEY = "your_rememberizer_api_key"
VECTOR_STORE_ID = "vs_abc123"  # 귀하의 Rememberizer 벡터 저장소 ID
BASE_URL = "https://api.rememberizer.ai/api/v1"

# 처리 배치 크기
BATCH_SIZE = 100

# Qdrant에서 포인트를 가져오는 함수
def fetch_points_from_qdrant(collection_name, batch_size, offset=0):
    try:
        # 벡터 차원을 결정하기 위해 컬렉션 정보 가져오기
        collection_info = qdrant_client.get_collection(collection_name=collection_name)
        
        # 포인트 스크롤
        scroll_result = qdrant_client.scroll(
            collection_name=collection_name,
            limit=batch_size,
            offset=offset,
            with_payload=True,
            with_vectors=True
        )
        
        points = scroll_result[0]  # (points, next_offset)의 튜플
        next_offset = scroll_result[1]
        
        return points, next_offset
    except Exception as e:
        print(f"Qdrant에서 포인트를 가져오는 중 오류 발생: {e}")
        return [], None

# Rememberizer에 벡터를 업로드하는 함수
def upload_to_rememberizer(points):
    headers = {
        "x-api-key": REMEMBERIZER_API_KEY,
        "Content-Type": "application/json"
    }
    
    results = []
    
    for point in points:
        # 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"건너뜁니다 {point_id} - 페이로드에서 텍스트 콘텐츠를 찾을 수 없습니다")
            continue
            
        data = {
            "name": document_name,
            "content": text_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"문서 '{document_name}'이(가) 성공적으로 업로드되었습니다!")
                results.append({"id": point_id, "success": True})
            else:
                print(f"문서 {document_name} 업로드 중 오류: {response.text}")
                results.append({"id": point_id, "success": False, "error": response.text})
        except Exception as e:
            print(f"문서 {document_name} 업로드 중 예외 발생: {str(e)}")
            results.append({"id": point_id, "success": False, "error": str(e)})
        
        # 속도 제한을 방지하기 위해 약간의 지연 추가
        time.sleep(0.1)
    
    return results

# 주요 마이그레이션 함수
def migrate_qdrant_to_rememberizer():
    offset = None
    total_migrated = 0
    
    print("Qdrant에서 Rememberizer로 마이그레이션 시작 중...")
    
    while True:
        points, next_offset = fetch_points_from_qdrant(
            QDRANT_COLLECTION_NAME, 
            BATCH_SIZE,
            offset
        )
        
        if not points:
            break
            
        print(f"Qdrant에서 {len(points)} 포인트를 가져왔습니다.")
        
        results = upload_to_rememberizer(points)
        success_count = sum(1 for r in results if r.get("success", False))
        
        total_migrated += success_count
        print(f"진행 상황: {total_migrated} 포인트가 성공적으로 마이그레이션되었습니다.")
        
        if next_offset is None:
            break
            
        offset = next_offset
    
    print(f"마이그레이션 완료! 총 {total_migrated} 포인트가 Rememberizer로 마이그레이션되었습니다.")

# 마이그레이션 실행
# migrate_qdrant_to_rememberizer()

Node.js

const { QdrantClient } = require('@qdrant/js-client-rest');
const axios = require('axios');

// Qdrant 구성
const qdrantUrl = 'http://localhost:6333'; // 또는 Qdrant 클라우드 URL
const qdrantApiKey = 'your_qdrant_api_key'; // Qdrant Cloud를 사용하는 경우
const qdrantCollectionName = 'your_collection';

// Rememberizer 구성
const rememberizerApiKey = 'YOUR_REMEMBERIZER_API_KEY';
const vectorStoreId = 'vs_abc123';
const baseUrl = 'https://api.rememberizer.ai/api/v1';

// 배치 크기 구성
const BATCH_SIZE = 100;

// Qdrant 클라이언트 초기화
const qdrantClient = new QdrantClient({ 
  url: qdrantUrl,
  apiKey: qdrantApiKey // Qdrant Cloud 전용
});

// Qdrant에서 포인트 가져오기
async function fetchPointsFromQdrant(collectionName, batchSize, offset = 0) {
  try {
    // 컬렉션 정보 가져오기
    const collectionInfo = await qdrantClient.getCollection(collectionName);
    
    // 포인트 스크롤
    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(`Qdrant에서 포인트 가져오기 오류: ${error.message}`);
    return { points: [], nextOffset: null };
  }
}

// Rememberizer에 벡터 업로드
async function uploadToRememberizer(points) {
  const headers = {
    'x-api-key': rememberizerApiKey,
    'Content-Type': 'application/json'
  };
  
  const results = [];
  
  for (const point of points) {
    // Qdrant 포인트에서 데이터 추출
    const pointId = point.id;
    const metadata = point.payload || {};
    const textContent = metadata.text || '';
    const documentName = metadata.filename || `qdrant_doc_${pointId}`;
    
    if (!textContent) {
      console.log(`건너뜀 ${pointId} - 페이로드에 텍스트 내용이 없음`);
      continue;
    }
    
    const data = {
      name: documentName,
      content: textContent,
      // 선택 사항: 추가 메타데이터 포함
      metadata: metadata
    };
    
    try {
      const response = await axios.post(
        `${baseUrl}/vector-stores/${vectorStoreId}/documents/text`,
        data,
        { headers }
      );
      
      if (response.status === 201) {
        console.log(`문서 '${documentName}'가 성공적으로 업로드되었습니다!`);
        results.push({ id: pointId, success: true });
      } else {
        console.error(`문서 ${documentName} 업로드 오류: ${response.statusText}`);
        results.push({ id: pointId, success: false, error: response.statusText });
      }
    } catch (error) {
      console.error(`문서 ${documentName} 업로드 오류: ${error.message}`);
      results.push({ id: pointId, success: false, error: error.message });
    }
    
    // 속도 제한을 방지하기 위해 약간의 지연 추가
    await new Promise(resolve => setTimeout(resolve, 100));
  }
  
  return results;
}

// 주요 마이그레이션 함수
async function migrateQdrantToRememberizer() {
  try {
    console.log('Qdrant에서 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(`Qdrant에서 ${points.length} 포인트를 가져왔습니다`);
      
      const results = await uploadToRememberizer(points);
      const successCount = results.filter(r => r.success).length;
      
      totalMigrated += successCount;
      console.log(`진행 상황: ${totalMigrated} 포인트가 성공적으로 마이그레이션되었습니다`);
      
    } while (offset !== null);
    
    console.log(`마이그레이션 완료! 총 ${totalMigrated} 포인트가 Rememberizer로 마이그레이션되었습니다`);
    
  } catch (error) {
    console.error('마이그레이션 실패:', error);
  }
}

// 마이그레이션 실행
// migrateQdrantToRememberizer();

Supabase pgvector에서 마이그레이션하기

이미 Supabase와 pgvector를 사용하고 있다면, Rememberizer로의 마이그레이션은 두 가지 모두 pgvector 확장을 사용하는 PostgreSQL을 기반으로 하기 때문에 특히 간단합니다.

Python

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

# 환경 변수를 로드합니다
load_dotenv()

# Supabase PostgreSQL 구성
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 구성
REMEMBERIZER_API_KEY = os.getenv("REMEMBERIZER_API_KEY")
VECTOR_STORE_ID = os.getenv("VECTOR_STORE_ID")  # 예: "vs_abc123"
BASE_URL = "https://api.rememberizer.ai/api/v1"

# 처리 배치 크기
BATCH_SIZE = 100

# 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"Supabase PostgreSQL에 연결하는 중 오류 발생: {e}")
        return None

# Supabase pgvector에서 문서 가져오기
def fetch_documents_from_supabase(conn, batch_size, offset=0):
    try:
        cursor = conn.cursor()
        
        # 테이블 구조에 따라 이 쿼리를 조정하세요
        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"Supabase에서 문서를 가져오는 중 오류 발생: {e}")
        return []

# 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
        
        # 메타데이터가 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"{doc_id} 건너뜀 - 내용이 없습니다")
            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"문서 '{document_name}'가 성공적으로 업로드되었습니다!")
                results.append({"id": doc_id, "success": True})
            else:
                print(f"문서 {document_name} 업로드 오류: {response.text}")
                results.append({"id": doc_id, "success": False, "error": response.text})
        except Exception as e:
            print(f"문서 {document_name} 업로드 중 예외 발생: {str(e)}")
            results.append({"id": doc_id, "success": False, "error": str(e)})
        
        # 속도 제한을 방지하기 위해 약간의 지연 추가
        time.sleep(0.1)
    
    return results

# 주요 마이그레이션 함수
def migrate_supabase_to_rememberizer():
    conn = connect_to_supabase()
    if not conn:
        print("Supabase에 연결하지 못했습니다. 마이그레이션을 중단합니다.")
        return
    
    offset = 0
    total_migrated = 0
    
    print("Supabase pgvector에서 Rememberizer로 마이그레이션 시작 중...")
    
    try:
        while True:
            documents = fetch_documents_from_supabase(conn, BATCH_SIZE, offset)
            
            if not documents:
                break
                
            print(f"Supabase에서 {len(documents)}개의 문서를 가져왔습니다.")
            
            results = upload_to_rememberizer(documents)
            success_count = sum(1 for r in results if r.get("success", False))
            
            total_migrated += success_count
            print(f"진행 상황: {total_migrated}개의 문서가 성공적으로 마이그레이션되었습니다.")
            
            offset += BATCH_SIZE
            
    finally:
        conn.close()
    
    print(f"마이그레이션 완료! 총 {total_migrated}개의 문서가 Rememberizer로 마이그레이션되었습니다.")

# 마이그레이션 실행
# migrate_supabase_to_rememberizer()

Node.js

const { Pool } = require('pg');
const axios = require('axios');
require('dotenv').config();

// Supabase PostgreSQL 구성
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';

// Rememberizer 구성
const rememberizerApiKey = process.env.REMEMBERIZER_API_KEY;
const vectorStoreId = process.env.VECTOR_STORE_ID; // 예: "vs_abc123"
const baseUrl = 'https://api.rememberizer.ai/api/v1';

// 배치 크기 구성
const BATCH_SIZE = 100;

// Supabase pgvector에서 문서 가져오기
async function fetchDocumentsFromSupabase(batchSize, offset = 0) {
  try {
    // 테이블 구조에 따라 이 쿼리를 조정하세요
    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(`Supabase에서 문서를 가져오는 중 오류 발생: ${error.message}`);
    return [];
  }
}

// Rememberizer에 문서 업로드
async function uploadToRememberizer(documents) {
  const headers = {
    'x-api-key': rememberizerApiKey,
    'Content-Type': 'application/json'
  };
  
  const results = [];
  
  for (const doc of documents) {
    // 메타데이터가 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(`건너뜁니다 ${doc.id} - 내용이 없습니다`);
      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(`문서 '${documentName}'가 성공적으로 업로드되었습니다!`);
        results.push({ id: doc.id, success: true });
      } else {
        console.error(`문서 ${documentName} 업로드 중 오류 발생: ${response.statusText}`);
        results.push({ id: doc.id, success: false, error: response.statusText });
      }
    } catch (error) {
      console.error(`문서 ${documentName} 업로드 중 오류 발생: ${error.message}`);
      results.push({ id: doc.id, success: false, error: error.message });
    }
    
    // 속도 제한을 방지하기 위해 약간의 지연 추가
    await new Promise(resolve => setTimeout(resolve, 100));
  }
  
  return results;
}

// 주요 마이그레이션 함수
async function migrateSupabaseToRememberizer() {
  try {
    console.log('Supabase pgvector에서 Rememberizer로 마이그레이션 시작...');
    
    let offset = 0;
    let totalMigrated = 0;
    
    while (true) {
      const documents = await fetchDocumentsFromSupabase(BATCH_SIZE, offset);
      
      if (documents.length === 0) {
        break;
      }
      
      console.log(`Supabase에서 ${documents.length} 문서를 가져왔습니다`);
      
      const results = await uploadToRememberizer(documents);
      const successCount = results.filter(r => r.success).length;
      
      totalMigrated += successCount;
      console.log(`진행 상황: ${totalMigrated} 문서가 성공적으로 마이그레이션되었습니다`);
      
      offset += BATCH_SIZE;
    }
    
    console.log(`마이그레이션 완료! 총 ${totalMigrated} 문서가 Rememberizer로 마이그레이션되었습니다`);
    
  } catch (error) {
    console.error('마이그레이션 실패:', error);
  } finally {
    await supabasePool.end();
  }
}

// 마이그레이션 실행
// migrateSupabaseToRememberizer();

마이그레이션 모범 사례

성공적인 마이그레이션을 위해 다음 권장 사항을 따르십시오:

1. 미리 계획하기:

   • 마이그레이션에 필요한 데이터 양과 시간을 추정합니다.

   • 트래픽이 적은 시간에 마이그레이션을 예약합니다.

   • 대규모 마이그레이션을 시작하기 전에 디스크 공간을 늘립니다.

2. 먼저 테스트하기:

   • Rememberizer에서 테스트 벡터 저장소를 생성합니다.

   • 데이터의 작은 하위 집합(100-1000 벡터)을 마이그레이션합니다.

   • 주요 쿼리를 사용하여 검색 기능을 확인합니다.

3. 데이터 검증:

   • 마이그레이션 전후의 문서 수를 비교합니다.

   • 유사한 결과를 보장하기 위해 벤치마크 쿼리를 실행합니다.

   • 메타데이터가 올바르게 보존되었는지 검증합니다.

4. 성능 최적화:

   • 효율성을 위해 배치 작업을 사용합니다.

   • 소스 및 대상 데이터베이스의 지리적 공동 위치를 고려합니다.

   • API 속도 제한을 모니터링하고 배치 크기를 조정합니다.

5. 마이그레이션 후 단계:

   • Rememberizer에서 인덱스 생성 여부를 확인합니다.

   • 애플리케이션 구성을 업데이트하여 새로운 벡터 저장소를 가리키도록 합니다.

   • 마이그레이션이 확인될 때까지 소스 데이터베이스를 백업으로 유지합니다.

자세한 API 참조 및 엔드포인트 문서는 벡터 저장소 문서 페이지를 방문하십시오.

---

API 키를 안전하게 처리하고 API 키 관리에 대한 모범 사례를 따르십시오.