Sparse Embeddings API

POST https://kure.kullm.ai/api/v1/sparse-embeddings

{
  "object": "list",
  "model": "kure-sparse-base-20261016",
  "dimension": 280524,
  "data": [
    {
      "object": "sparse_embedding",
      "index": 0,
      "indices": [2118, 2522, 3295, 12849],
      "values": [1.8276, 1.1394, 1.6759, 1.1394],
      "tokens": ["e_university", "e_co", "e_location", "e_ko"]
    }
  ],
  "usage": { "prompt_tokens": 9, "total_tokens": 9 }
}

# pip install qdrant-client
from qdrant_client import QdrantClient, models
 
qdrant = QdrantClient(":memory:")  # 서버라면 QdrantClient(url="http://localhost:6333")
qdrant.create_collection(
    "docs",
    vectors_config={},
    sparse_vectors_config={"kure-sparse": models.SparseVectorParams()},
)
 
 
def sparse(texts, input_type):  # API 응답 → Qdrant SparseVector
    res = requests.post(f"{API}/sparse-embeddings", headers=HEADERS, json={
        "model": "kure-sparse-base", "input": texts, "input_type": input_type,
    })
    res.raise_for_status()
    return [models.SparseVector(indices=d["indices"], values=d["values"]) for d in res.json()["data"]]
 
 
qdrant.upsert("docs", [
    models.PointStruct(id=i, vector={"kure-sparse": v}, payload={"text": t})
    for i, (t, v) in enumerate(zip(docs, sparse(docs, "document")))
])
hits = qdrant.query_points("docs", query=sparse(["한글은 언제 만들어졌나요?"], "query")[0], using="kure-sparse", limit=5)
for p in hits.points:
    print(p.score, p.payload["text"])

CREATE EXTENSION IF NOT EXISTS vector;
CREATE TABLE docs (id bigserial PRIMARY KEY, text text, embedding sparsevec(280524));
CREATE INDEX ON docs USING hnsw (embedding sparsevec_ip_ops);

# pip install "psycopg[binary]"
import psycopg
 
 
def to_sparsevec(d, dim=280524):
    return "{" + ",".join(f"{i + 1}:{v}" for i, v in zip(d["indices"], d["values"])) + f"}}/{dim}"
 
 
def encode_raw(texts, input_type):
    res = requests.post(f"{API}/sparse-embeddings", headers=HEADERS, json={
        "model": "kure-sparse-base", "input": texts, "input_type": input_type, "max_nnz": 1000,
    })
    res.raise_for_status()
    return res.json()["data"]
 
 
with psycopg.connect("postgresql://localhost/mydb") as conn:
    for text, d in zip(docs, encode_raw(docs, "document")):
        conn.execute("INSERT INTO docs (text, embedding) VALUES (%s, %s::sparsevec)", (text, to_sparsevec(d)))
    q = to_sparsevec(encode_raw(["한글은 언제 만들어졌나요?"], "query")[0])
    # <#>는 음의 내적 → 작은 순이 관련도 높은 순
    rows = conn.execute(
        "SELECT text, -(embedding <#> %s::sparsevec) AS score FROM docs ORDER BY embedding <#> %s::sparsevec LIMIT 5",
        (q, q),
    ).fetchall()

import numpy as np
from openai import OpenAI
 
client = OpenAI(base_url=API, api_key=os.environ["KURE_API_KEY"])
 
 
def dense(texts, input_type):
    res = client.embeddings.create(model="kure-v3", input=texts, dimensions=1024,
                                   extra_body={"input_type": input_type})
    return np.array([d.embedding for d in res.data])
 
 
# 색인 (미리 한 번)
dense_docs = dense(docs, "document")
sparse_docs = encode(docs, "document")
 
 
def hybrid_search(query, k=60, n=10):
    dense_scores = dense_docs @ dense([query], "query")[0]
    q = encode([query], "query")[0]
    sparse_scores = np.array([sum(w * d.get(i, 0) for i, w in q.items()) for d in sparse_docs])
    fused = np.zeros(len(docs))
    for scores in (dense_scores, sparse_scores):
        for rank, i in enumerate(np.argsort(-scores)):
            fused[i] += 1 / (k + rank + 1)  # RRF: 각 검색 결과에서의 순위만 쓴다
    return [docs[i] for i in np.argsort(-fused)[:n]]