AI-네이티브 데이터베이스 벡터 데이터베이스 - 사용자 문서

SynapCores 벡터 데이터베이스 - 사용자 문서

문서 날짜: 2025년 9월 1일
버전: 1.0 (공개)
상태: 생산 준비 완료

집행 요약

SynapCores는 고급 인덱싱, 유사도 검색, AI로 구동되는 임베딩 생성을 제공하는 클라우드 네이티브 벡터 데이터베이스 기능을 제공합니다. 이 문서는 Semantik 검색, 추천, AI로 구동되는 기능을 위해 SynapCores를 애플리케이션에 통합하는 방법을 설명합니다.

개요

SynapCores는 전통적인 SQL 데이터베이스 기능과 네이티브 벡터 연산을 결합하여 다음과 같은 기능을 제공합니다:

고차원 임베딩 저장 및 검색
의미 유사성 검색 수행
관계형 및 벡터 데이터를 결합한 혼합 쿼리 실행
데이터베이스 내에서 직접 임베딩 생성
백만 개의 벡터에 걸쳐 100밀리초 미만 쿼리 지연으로 확장

주요 기능

벡터 연산

여러 거리 측정값 (코사인, 유클리드, 점곱, 맨해튼)
HNSW를 이용한 고속 근사 검색의 고급 인덱싱
정확하고 근사한 가장 가까운 이웃 검색
고 처리량을 위한 배치 작업

SQL 통합:

원시 벡터 데이터 타입
SQL 쿼리에서 호출 가능한 AI 함수
벡터 및 관계형 데이터를 하나의 쿼리에서 결합
벡터 확장을 사용한 표준 SQL 구문

기업 기능：《

ACID 트랜잭션
자동 데이터 지속
다중 임대자 격리
높은 가용성

시작하기

1. 계정 만들기

회원가입하세요https://synapcores.comAPI 자격 증명을 얻으려면.

2. API 토큰 획득

계정을 생성한 후, 대시보드에서 API 토큰을 생성하세요:

# Your API token will look like this
export SYNAPCORES_TOKEN="sc_live_abc123xyz..."

3. 데이터베이스에 연결하세요

소켓 연결 (SQL 인터페이스):

# Connection via SynapCores native protocol
synapcores://username:password@your-instance.synapcores.com:5433/your_database

REST API:

# Base URL
https://api.synapcores.com/api/v1

연결 방법들:

네이티브 소켓 프로토콜: SQL 쿼리 및 고성능 작업을 위한
REST API: 언어에 독립적인 HTTP 기반 액세스

4. 첫 번째 벡터 공간 만들기

SQL 사용:

SELECT create_vector_space('products', 384, 'cosine');

REST API 사용:

curl -X POST https://api.synapcores.com/api/v1/vectors/collections \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "products",
    "dimensions": 384,
    "distance_metric": "cosine",
    "index_type": "hnsw"
  }'

임베딩 생성

지원 모델

SynapCores는 다양한 모델 옵션으로 내장된 임베딩 생성을 제공합니다:

모델	차원	가장 적합한 대상	속도
MiniLM	384	일반 텍스트, 빠른 처리	⚡⚡⚡ 빠르게
BERT Base	768	고품질의 의미 이해	⚡⚡ 중간
BERT 크기	1024	최대 임베딩 품질	⚡ 더 느림

사용법

SQL에서 임베딩 생성:

-- Use default model (MiniLM)
SELECT EMBED('wireless headphones');

-- Specify model explicitly
SELECT EMBED('wireless headphones', 'minilm');
SELECT EMBED('wireless headphones', 'bert-base');
SELECT EMBED('wireless headphones', 'bert-large');

데이터 삽입 중전체 화면 모드 입력

INSERT INTO products (name, description, embedding)
VALUES (
    'Bluetooth Headphones',
    'Premium wireless audio device',
    EMBED('Bluetooth Headphones Premium wireless audio device')
);

전체 화면 모드 입력전체 화면 모드 종료

-- Generate embeddings for existing data
UPDATE products
SET embedding = EMBED(name || ' ' || description)
WHERE embedding IS NULL;

적절한 측정법 선택

1. 코사인 유사도 (텍스트에 권장됨)

가장 적합한텍스트 임베딩, 의미 검색, 문서 유사도

범위[-1, 1]으로 1은 가장 유사함

사용 시문서, 제품, 또는 텍스트 기반 콘텐츠 비교 시

SELECT COSINE_SIMILARITY(vector1, vector2) as similarity
FROM comparisons;

예시유사 제품 설명 찾기

2. 유클리드 거리 (L2)

가장 적합한 경우: 공간 데이터, 이미지 임베딩

범위: [0, ∞]에서 0은 동일함

다음과 같이 사용하세요: 공간 좌표나 이미지 특징을 비교할 때

SELECT EUCLIDEAN_DISTANCE(vector1, vector2) as distance
FROM comparisons;

예시: 유사 이미지 찾기

3. 점곱

가장 적합한 경우: 추천 시스템

범위: (-∞, ∞)

다음과 같이 사용: 정규화된 벡터로 관련성 점수 계산

SELECT INNER_PRODUCT(vector1, vector2) as score
FROM comparisons;

예시: 사용자-아이템 추천

4. 맨해튼 거리 (L1)

가장 적합한 경우: 희소 고차원 데이터

범위: [0, ∞]

사용 시: 희소 특징 벡터와 작업할 때

SELECT MANHATTAN_DISTANCE(vector1, vector2) as distance
FROM comparisons;

인덱싱 전략

평평 인덱스 (정확 검색)

특징:

100% 재현율 보장 (정확 결과)
모든 벡터 검색 (무차별 검색)
작은 데이터셋에 적합

사용 시기:

< 10,000 벡터
정확한 결과가 필요할 때
검증 및 벤치마킹

성능: 1-10ms (작은 데이터 세트용)

-- Create with flat index (default)
SELECT create_vector_space('small_collection', 384, 'cosine');

HNSW 인덱스 (빠른 근사 검색)

특징:

그래프 기반 근사 최근접 이웃 검색
평면 인덱스보다 10-100배 빠르게
정확도 대비 속도 조절 가능

사용 시기 :

10K+ 벡터
생산 애플리케이션
100밀리초 미만 지연 시간이 필요할 때

성능 : 수백만 개의 벡터일 때도 5-50밀리초

-- Create with HNSW index
SELECT create_vector_space('large_collection', 384, 'cosine', 'hnsw');

인덱스 선택 가이드

벡터 카운트	추천 지수	예상 지연 시간
<10K	평평한	1-10밀리초
10K - 100K	HNSW	5-20밀리초
100,000 - 1,000,000	HNSW	10-50ms
1M+	HNSW	20-100ms

CRUD 작업

1. 벡터 공간 생성

벡터 컬렉션을 초기화합니다:

SQL:

SELECT create_vector_space(
    'products',     -- Space name
    384,            -- Dimensions
    'cosine'        -- Distance metric
);

REST API:

curl -X POST https://api.synapcores.com/api/v1/vectors/collections \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "products",
    "dimensions": 384,
    "distance_metric": "cosine",
    "index_type": "hnsw"
  }'

응답:

{
  "status": "success",
  "data": {
    "name": "products",
    "dimensions": 384,
    "distance_metric": "cosine",
    "index_type": "hnsw",
    "created_at": "2025-09-01T10:00:00Z"
  }
}

2. 벡터 삽입

자동 생성 ID와 함께 단일 삽입

SQL:

INSERT INTO vector_spaces.products (values, metadata)
VALUES (
    EMBED('Wireless Bluetooth Headphones'),
    '{"product_id": "12345", "category": "electronics"}'::JSON
);

REST API:

curl -X POST https://api.synapcores.com/api/v1/vectors/collections/products/vectors \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "vectors": [{
      "values": [0.1, 0.2, 0.3, ...],
      "metadata": {
        "product_id": "12345",
        "category": "electronics"
      }
    }]
  }'

커스텀 ID로 삽입

SQL:

INSERT INTO vector_spaces.products (id, values, metadata)
VALUES (
    'prod_12345',
    EMBED('Wireless Bluetooth Headphones'),
    '{"category": "electronics"}'::JSON
);

배치 삽입 (대량 데이터에 적합)

SQL:

-- Insert multiple vectors efficiently
INSERT INTO vector_spaces.products (values, metadata)
SELECT
    EMBED(description),
    JSON_BUILD_OBJECT('product_id', product_id, 'category', category)
FROM products
WHERE embedding IS NULL
LIMIT 1000;

REST API:

curl -X POST https://api.synapcores.com/api/v1/vectors/collections/products/vectors \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "vectors": [
      {"values": [0.1, ...], "metadata": {"product_id": "1"}},
      {"values": [0.2, ...], "metadata": {"product_id": "2"}},
      ...
    ]
  }'

성능 팁: 배치 삽입은 개별 삽입보다 10-100배 빠릅니다.

3. 검색 벡터

의미 검색

SQL:

SELECT
    v.id,
    v.metadata->>'product_id' as product_id,
    v.metadata->>'category' as category,
    COSINE_SIMILARITY(v.values, EMBED('wireless headphones')) as similarity
FROM vector_spaces.products v
WHERE COSINE_SIMILARITY(v.values, EMBED('wireless headphones')) > 0.7
ORDER BY similarity DESC
LIMIT 10;

REST API:

curl -X POST https://api.synapcores.com/api/v1/vectors/collections/products/search \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query_text": "wireless headphones",
    "k": 10,
    "threshold": 0.7,
    "include_metadata": true
  }'

응답:

{
  "status": "success",
  "data": [
    {
      "id": "prod_12345",
      "score": 0.95,
      "metadata": {
        "product_id": "12345",
        "category": "electronics"
      }
    },
    {
      "id": "prod_67890",
      "score": 0.87,
      "metadata": {
        "product_id": "67890",
        "category": "electronics"
      }
    }
  ],
  "total_results": 2,
  "query_time_ms": 12
}

하이브리드 검색 (벡터 + 필터)

의미 검색과 전통적인 SQL 필터를 결합합니다.

SELECT
    p.product_id,
    p.name,
    p.price,
    COSINE_SIMILARITY(p.embedding, EMBED('noise cancelling headphones')) as similarity
FROM products p
WHERE
    p.category = 'electronics'
    AND p.price BETWEEN 50 AND 200
    AND p.in_stock = true
    AND COSINE_SIMILARITY(p.embedding, EMBED('noise cancelling headphones')) > 0.7
ORDER BY similarity DESC, p.price ASC
LIMIT 20;

메타데이터 필터와 함께 검색 (REST API)

curl -X POST https://api.synapcores.com/api/v1/vectors/collections/products/search \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query_text": "wireless headphones",
    "k": 20,
    "threshold": 0.7,
    "filter": {
      "category": "electronics",
      "in_stock": true
    }
  }'

4. 벡터 업데이트

SQL :

UPDATE vector_spaces.products
SET
    values = EMBED('Updated product description'),
    metadata = JSON_BUILD_OBJECT(
        'product_id', '12345',
        'category', 'audio',
        'updated_at', CURRENT_TIMESTAMP
    )
WHERE id = 'prod_12345';

REST API :

curl -X PUT https://api.synapcores.com/api/v1/vectors/collections/products/vectors/prod_12345 \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "values": [0.1, 0.2, ...],
    "metadata": {
      "category": "audio",
      "updated_at": "2025-09-01T10:00:00Z"
    }
  }'

5. 벡터 삭제

SQL :

-- Delete by ID
DELETE FROM vector_spaces.products
WHERE id = 'prod_12345';

-- Delete by criteria
DELETE FROM vector_spaces.products
WHERE metadata->>'category' = 'discontinued';

REST API:

# Delete single vector
curl -X DELETE https://api.synapcores.com/api/v1/vectors/collections/products/vectors/prod_12345 \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN"

# Batch delete
curl -X POST https://api.synapcores.com/api/v1/vectors/collections/products/delete_batch \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"ids": ["prod_12345", "prod_67890"]}'

6. ID로 벡터 가져오기

SQL:

SELECT id, values, metadata
FROM vector_spaces.products
WHERE id = 'prod_12345';

REST API:

curl -X GET https://api.synapcores.com/api/v1/vectors/collections/products/vectors/prod_12345 \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN"

SQL 통합

벡터 데이터 타입

원생 벡터 열을 가진 테이블을 만드세요:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    description TEXT,
    price DECIMAL(10,2),
    category TEXT,
    embedding VECTOR(384)  -- 384-dimensional vector
);

AI 함수

EMBED() - 임베딩 생성

-- Default model (MiniLM, 384 dimensions)
SELECT EMBED('wireless headphones');

-- Specify model
SELECT EMBED('wireless headphones', 'minilm');    -- 384d
SELECT EMBED('wireless headphones', 'bert-base'); -- 768d
SELECT EMBED('wireless headphones', 'bert-large'); -- 1024d

-- Use in INSERT
INSERT INTO products (name, description, embedding)
VALUES (
    'Bluetooth Headphones',
    'Premium wireless audio device',
    EMBED('Bluetooth Headphones Premium wireless audio device')
);

벡터 유사도 함수

COSINE_SIMILARITY():

SELECT
    product_id,
    name,
    COSINE_SIMILARITY(embedding, EMBED('wireless bluetooth headphones')) as similarity_score
FROM products
WHERE COSINE_SIMILARITY(embedding, EMBED('wireless bluetooth headphones')) > 0.7
ORDER BY similarity_score DESC
LIMIT 10;

EUCLIDEAN_DISTANCE():

SELECT
    id,
    EUCLIDEAN_DISTANCE(embedding, :query_vector) as distance
FROM image_embeddings
ORDER BY distance ASC
LIMIT 5;

내적():

SELECT
    user_id,
    item_id,
    INNER_PRODUCT(user_embedding, item_embedding) as relevance_score
FROM recommendations
WHERE relevance_score > 0.5
ORDER BY relevance_score DESC;

고급 SQL 패턴

조인을 사용한 의미 검색

-- Find customers who purchased similar products
SELECT
    c.customer_id,
    c.customer_name,
    p.product_name,
    o.order_date,
    COSINE_SIMILARITY(p.embedding, EMBED('premium headphones')) as relevance
FROM customers c
JOIN orders o ON c.customer_id = o.customer_id
JOIN order_items oi ON o.order_id = oi.order_id
JOIN products p ON oi.product_id = p.product_id
WHERE
    o.order_date > CURRENT_DATE - INTERVAL '90 days'
    AND COSINE_SIMILARITY(p.embedding, EMBED('premium headphones')) > 0.75
ORDER BY relevance DESC, o.order_date DESC
LIMIT 50;

벡터를 사용한 집계

-- Average similarity by category
SELECT
    category,
    COUNT(*) as product_count,
    AVG(COSINE_SIMILARITY(embedding, EMBED('premium quality'))) as avg_relevance
FROM products
GROUP BY category
HAVING avg_relevance > 0.6
ORDER BY avg_relevance DESC;

벡터를 사용한 서브쿼리

-- Find products similar to top sellers
WITH top_products AS (
    SELECT product_id, embedding
    FROM products p
    JOIN order_items oi ON p.product_id = oi.product_id
    GROUP BY p.product_id, p.embedding
    ORDER BY SUM(oi.quantity) DESC
    LIMIT 10
)
SELECT DISTINCT
    p.product_id,
    p.name,
    MAX(COSINE_SIMILARITY(p.embedding, tp.embedding)) as max_similarity
FROM products p
CROSS JOIN top_products tp
WHERE p.product_id NOT IN (SELECT product_id FROM top_products)
GROUP BY p.product_id, p.name
HAVING MAX(COSINE_SIMILARITY(p.embedding, tp.embedding)) > 0.8
ORDER BY max_similarity DESC
LIMIT 20;

REST API

기본 URL

https://api.synapcores.com/api/v1

인증

모든 요청은 Bearer 토큰 인증이 필요합니다:

Authorization: Bearer <your_api_token>

엔드포인트

메소드	엔드포인트	목적
GET	`/vectors/collections`	모든 컬렉션 목록 보기
POST	`/vectors/collections`	컬렉션 생성
GET	`/vectors/collections/:name`	컬렉션 정보 가져오기
DELETE	`/vectors/collections/:name`	컬렉션 삭제
POST	`/vectors/collections/:name/vectors`	벡터 삽입
GET	`/vectors/collections/:name/vectors/:id`	ID로 벡터 가져오기
PUT	`/vectors/collections/:name/vectors/:id`	벡터 업데이트
DELETE	`/vectors/collections/:name/vectors/:id`	벡터 삭제
POST	`/vectors/collections/:name/search`	벡터 검색
POST	`/vectors/collections/:name/search/batch`	배치 검색

완전한 워크플로우 예제

# 1. Create collection
curl -X POST https://api.synapcores.com/api/v1/vectors/collections \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "documents",
    "dimensions": 384,
    "distance_metric": "cosine",
    "index_type": "hnsw"
  }'

# 2. Insert documents
curl -X POST https://api.synapcores.com/api/v1/vectors/collections/documents/vectors \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "vectors": [{
      "id": "doc_001",
      "values": [0.1, 0.2, ...],
      "metadata": {"title": "Getting Started", "type": "guide"}
    }]
  }'

# 3. Search documents
curl -X POST https://api.synapcores.com/api/v1/vectors/collections/documents/search \
  -H "Authorization: Bearer $SYNAPCORES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query_text": "how to get started",
    "k": 10,
    "threshold": 0.7
  }'

제한 사항

작업	제한	참고
한 번의 삽입당 벡터 수	1,000	큰 데이터 세트의 경우 배치 작업을 사용하세요
한 번의 배치 검색당 쿼리 수	100	큰 배치를 여러 요청으로 나누기
분당 API 요청 수	1,000	더 높은 한도를 위해 지원팀에 문의하기

최선의 관행

1. 임베딩 차원 선택

차원	모델	사용 사례	トレ이드오프
384	MiniLM	일반용, 비용 효율적	가장 균형 잡힌
768	BERT Base	더 높은 품질의 의미 이해	2배 저장 비용
1024	BERT Large	중요 애플리케이션에 최고의 품질	3배 저장 비용

추천: 대부분의 경우 384 차원 (MiniLM)으로 시작하세요.

2. 배치 작업

항상를 위해 배치 작업을 사용하세요.

대량 데이터 가져오기
주기적인 재색인
데이터 이전

성능 향상:

개별 작업보다 10-100배 빠르게
API 호출 오버헤드 감소
더 나은 투자량

최적의 배치 크기요청당 100-1000개 벡터

3. 쿼리 최적화

필터를 효과적으로 사용:

-- Good: Filter before vector search
SELECT *
FROM products
WHERE
    category = 'electronics'  -- Traditional filter first
    AND price < 200
    AND COSINE_SIMILARITY(embedding, EMBED('headphones')) > 0.7

캐시 빈번한 쿼리:

애플리케이션에서 인기 검색 임베딩 캐시
동일한 쿼리에 대해 임베딩 재사용
임베딩 생성 오버헤드 감소

4. 오류 처리

재시도 로직 구현:

import time
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

session = requests.Session()
retry = Retry(
    total=3,
    backoff_factor=0.3,
    status_forcelist=[429, 500, 502, 503, 504]
)
adapter = HTTPAdapter(max_retries=retry)
session.mount('https://', adapter)

요청 제한 처리:

응답 헤더에서 요청 제한 정보 확인
지수적 백오프 구현
고 트래픽 시 요청 큐에 저장

5. 모니터링 및 관찰성

애플리케이션에서 주요 메트릭 추적:

쿼리 지연 시간 (p50, p95, p99)
검색 정확도/관련성
임베딩 생성 시간
API 오류율

중요 이벤트 기록:

실패한 임베딩 생성
느린 쿼리 (> 100ms)
요청 제한 도달

일반 사용 사례

E-Commerce 의미 검색 사용 사례

-- Create product table with embeddings
CREATE TABLE products (
    product_id SERIAL PRIMARY KEY,
    name TEXT,
    description TEXT,
    category TEXT,
    price DECIMAL(10,2),
    embedding VECTOR(384)
);

-- Index products
INSERT INTO products (name, description, category, price, embedding)
SELECT
    name,
    description,
    category,
    price,
    EMBED(name || ' ' || description)
FROM product_catalog;

-- Search by semantic meaning
SELECT
    product_id,
    name,
    price,
    COSINE_SIMILARITY(embedding, EMBED('wireless headphones')) as relevance
FROM products
WHERE relevance > 0.7
ORDER BY relevance DESC
LIMIT 20;

사용 사례 2: 콘텐츠 추천

-- Find similar articles based on user reading history
WITH user_interests AS (
    SELECT AVG(a.embedding) as avg_embedding
    FROM user_reading_history urh
    JOIN articles a ON urh.article_id = a.article_id
    WHERE urh.user_id = :user_id
)
SELECT
    a.article_id,
    a.title,
    COSINE_SIMILARITY(a.embedding, ui.avg_embedding) as relevance
FROM articles a
CROSS JOIN user_interests ui
WHERE a.article_id NOT IN (
    SELECT article_id FROM user_reading_history WHERE user_id = :user_id
)
AND relevance > 0.6
ORDER BY relevance DESC
LIMIT 10;

사용 사례 3: 중복 검출

-- Find near-duplicate documents
SELECT
    d1.document_id as doc1_id,
    d2.document_id as doc2_id,
    COSINE_SIMILARITY(d1.embedding, d2.embedding) as similarity
FROM documents d1
JOIN documents d2 ON d1.document_id < d2.document_id
WHERE COSINE_SIMILARITY(d1.embedding, d2.embedding) > 0.95
ORDER BY similarity DESC;

사용 사례 4: 고객 지원 라우팅

-- Find similar resolved tickets
SELECT
    t.ticket_id,
    t.subject,
    t.resolution,
    COSINE_SIMILARITY(t.embedding, EMBED(:new_ticket_text)) as similarity
FROM support_tickets t
WHERE
    t.status = 'resolved'
    AND similarity > 0.8
ORDER BY similarity DESC
LIMIT 5;

문제 해결

느린 쿼리 성능

증상: 쿼리가 > 100밀리초

솔루션:

HNSW 인덱스가 사용 중인지 확인 (쿼리 계획 확인)
요청 결과 수를 줄이기 (k 값을 낮추기)
메타데이터 필터를 사용하여 검색 공간 좁히기
낮은 차원의 임베딩을 사용하는 것을 고려하기 (384 대신 768 사용)

높은 API 오류율

증상: 자주 429 (율 제한) 또는 5xx 오류 발생

솔루션:

지수적 백오프 재시도 로직을 구현
개별 요청 대신 배치 작업을 사용
지원팀에 연락하여 요청 제한을 늘리기
자주 사용되는 임베딩을 캐싱

예상치 못한 검색 결과

증상: 의미적 검색에서 관련 없는 결과

해결 방법:

유사도 임계값을 증가시키세요 (0.7 대신 0.8을 시도해 보세요)
입력 텍스트가 올바르게 내장되고 있는지 확인하십시오
올바른 임베딩 모델이 사용 중인지 확인하세요
메타데이터 필터를 정확성을 검토하십시오

임베딩 생성 실패

증상들: EMBED() 함수 오류 또는 타임아웃

솔루션:

텍스트 길이가 512 토큰 미만인지 확인
특수 문자 또는 인코딩 문제 확인
지수적 백오프로 다시 시도
오류가 지속되면 지원팀에 문의

클라이언트 라이브러리

파이썬

import requests

class SynapCoresClient:
    def __init__(self, api_token):
        self.base_url = "https://api.synapcores.com/api/v1"
        self.headers = {
            "Authorization": f"Bearer {api_token}",
            "Content-Type": "application/json"
        }

    def search(self, collection, query_text, k=10, threshold=0.7):
        response = requests.post(
            f"{self.base_url}/vectors/collections/{collection}/search",
            headers=self.headers,
            json={
                "query_text": query_text,
                "k": k,
                "threshold": threshold
            }
        )
        return response.json()

# Usage
client = SynapCoresClient("your_api_token")
results = client.search("products", "wireless headphones", k=10)

JavaScript/TypeScript

class SynapCoresClient {
    constructor(apiToken) {
        this.baseUrl = 'https://api.synapcores.com/api/v1';
        this.headers = {
            'Authorization': `Bearer ${apiToken}`,
            'Content-Type': 'application/json'
        };
    }

    async search(collection, queryText, k = 10, threshold = 0.7) {
        const response = await fetch(
            `${this.baseUrl}/vectors/collections/${collection}/search`,
            {
                method: 'POST',
                headers: this.headers,
                body: JSON.stringify({
                    query_text: queryText,
                    k,
                    threshold
                })
            }
        );
        return await response.json();
    }
}

// Usage
const client = new SynapCoresClient('your_api_token');
const results = await client.search('products', 'wireless headphones', 10);

성능 기대치

쿼리 지연 시간

데이터셋 크기	인덱스 유형	보통 지연 시간
< 10K 벡터	플랫	1-5밀리초
10K-100K 벡터	HNSW	5-20ms
100K-1M 벡터	HNSW	10-50ms
1M+ 벡터	HNSW	20-100ms

SynapCores 서버에서 측정된 지연 시간입니다. 총 클라이언트 응답 시간에 네트워크 지연 시간을 추가하세요.

처리량

작업	예상 처리량
단일 삽입	~1,000 ops/초
배치 삽입 (100 벡터)	~10,000 벡터/초
검색 쿼리	~5,000 쿼리/초

확장성 한계

자원	제한	참고사항
공간당 벡터	10M+	테스트 와 생산 준비 완료
최대 차원	4096	고 차원 = 느린 검색
배치 크기	1,000 벡터	API 요청당
API 요청 제한	1,000 요청/분	지원팀에 연락하여 증가를 요청하세요

지원 및 자원

문서

개발자 문서: https://docs.synapcores.com
API 참조: https://docs.synapcores.com/api
SQL 가이드: https://docs.synapcores.com/sql

커뮤니티

커뮤니티 포럼: https://community.synapcores.com
Discord: https://discord.gg/synapcores
Stack Overflow: 질문에 태그를 부착하세요synapcores

지원

이메일: support@synapcores.com
채팅: 대시보드에서 사용 가능
상태 페이지: https://status.synapcores.com

튜토리얼

시작하기: 15분 안에 첫 번째 의미 검색 만들기
운영 환경 배포: 생산 환경으로 확장하는 최선의 방법
고급 패턴: 하이브리드 검색, RAG, 그리고 멀티 모달 애플리케이션

가격

현재 가격 세부 정보를 확인하려면 https://synapcores.com/pricing를 방문하세요.

무료 계층:

100K 벡터
1M API 요청/월
커뮤니티 지원

프로 계층:

10M 벡터
무제한 API 요청
이메일 지원
99.9% SLA

기업 레벨:_

무제한 벡터
개별 지원
커스텀 SLA
온프레미스 배포 옵션

한계

현재 한계

차원 변경: 생성 후 벡터 공간 차원을 변경할 수 없습니다
미터리크 변경: 공간 생성 후 거리 미터리크를 변경할 수 없습니다
최대 차원: 최대 4096 차원
배치 크기: 요청당 최대 1,000 개의 벡터

계획된 기능

정량화를 통한 저장 공간 비용 절감
GPU 가속된 검색
문서당 다중 벡터 지원
고급 필터링 검색 최적화
실시간 인덱스 업데이트

결론

SynapCores는 생산용, 클라우드 네이티브 벡터 데이터베이스를 제공하며:

✅ 의미 검색 - 의미로 유사한 콘텐츠를 찾아서, 키워드가 아닙니다
✅ SQL 통합 - 벡터 및 관계형 쿼리를 결합합니다
✅ 사용하기 쉽습니다 - 간단한 API 및 SQL 함수
✅ 고 성능 - 규모에 관계없이 100밀리초 미만 쿼리
✅전체 관리 - 유지보수할 인프라 없음

오늘 AI 기반 애플리케이션 개발을 시작하세요https://synapcores.com

문서 버전: 1.0 (공개)
최종 업데이트: 2025년 9월 1일
기술 지원:support@synapcores.com

원래 게시된 곳은 synapcores.com — SynapCores는 무료, 단일 바이너리 AI 전용 데이터베이스(벡터 + 그래프 + SQL + LLM)입니다.

추천 피드

DEV Community

SynapCores 벡터 데이터베이스 - 사용자 문서

집행 요약

목차

개요

주요 기능

시작하기

1. 계정 만들기

2. API 토큰 획득

3. 데이터베이스에 연결하세요

4. 첫 번째 벡터 공간 만들기

임베딩 생성

지원 모델

사용법

적절한 측정법 선택

1. 코사인 유사도 (텍스트에 권장됨)

2. 유클리드 거리 (L2)

3. 점곱

4. 맨해튼 거리 (L1)

인덱싱 전략

평평 인덱스 (정확 검색)

HNSW 인덱스 (빠른 근사 검색)

인덱스 선택 가이드

CRUD 작업

1. 벡터 공간 생성

2. 벡터 삽입

자동 생성 ID와 함께 단일 삽입

커스텀 ID로 삽입

배치 삽입 (대량 데이터에 적합)

3. 검색 벡터

의미 검색

하이브리드 검색 (벡터 + 필터)

메타데이터 필터와 함께 검색 (REST API)

4. 벡터 업데이트

5. 벡터 삭제

6. ID로 벡터 가져오기

SQL 통합

벡터 데이터 타입

AI 함수

EMBED() - 임베딩 생성

벡터 유사도 함수

고급 SQL 패턴

조인을 사용한 의미 검색

벡터를 사용한 집계

벡터를 사용한 서브쿼리

REST API

기본 URL

인증

엔드포인트

완전한 워크플로우 예제

제한 사항

최선의 관행

1. 임베딩 차원 선택

2. 배치 작업

3. 쿼리 최적화

4. 오류 처리

5. 모니터링 및 관찰성

일반 사용 사례

E-Commerce 의미 검색 사용 사례

사용 사례 2: 콘텐츠 추천

사용 사례 3: 중복 검출

사용 사례 4: 고객 지원 라우팅

문제 해결

느린 쿼리 성능

높은 API 오류율

예상치 못한 검색 결과

임베딩 생성 실패

클라이언트 라이브러리

파이썬

JavaScript/TypeScript

성능 기대치

쿼리 지연 시간

처리량

확장성 한계

지원 및 자원

문서

커뮤니티

지원

튜토리얼