LLM과 벡터데이터베이스(Chroma)를 연결해보기

LLM과 벡터데이터베이스를 연결해보자

목차

• 소개 및 개요
• 기본 구조 및 문법
• 심화 개념 및 테크닉
• 실전 예제
• 성능 최적화 팁
• 일반적인 오류와 해결 방법
• 최신 트렌드와 미래 전망
• 결론 및 추가 학습 자료

소개 및 개요

최근 자연어 처리 분야에서 대형 언어 모델(Large Language Model, LLM)과 벡터 데이터베이스를 연결하는 것이 큰 관심을 받고 있습니다. LLM은 방대한 양의 텍스트 데이터를 학습하여 인상적인 언어 생성 능력을 보여주지만, 실제 응용에서는 관련 정보를 효과적으로 저장하고 검색하는 것이 필수적입니다. 이때 벡터 데이터베이스를 활용하면 LLM의 잠재력을 극대화할 수 있습니다.

벡터 데이터베이스는 대량의 벡터 데이터를 효율적으로 저장하고 유사도 검색을 수행할 수 있는 특수한 데이터베이스입니다. 텍스트 데이터를 벡터로 변환하여 저장하면 의미적으로 유사한 문서를 빠르게 찾을 수 있습니다. 다음은 문장 임베딩을 통해 텍스트를 벡터로 변환하는 코드입니다.

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')
sentences = [
    "LLM과 벡터 데이터베이스를 연결하는 것이 중요합니다.",
    "벡터 데이터베이스는 유사도 검색을 효과적으로 수행합니다.",
    "문장 임베딩을 통해 텍스트를 벡터로 변환할 수 있습니다."
]
embeddings = model.encode(sentences)
print(embeddings.shape)  # (3, 384)

위 코드에서는 SentenceTransformer 라이브러리를 사용하여 문장을 384차원의 벡터로 변환합니다. 이렇게 변환된 벡터를 벡터 데이터베이스에 저장하면 유사한 문장을 빠르게 검색할 수 있습니다.

LLM과 벡터 데이터베이스를 연결하면 다양한 응용이 가능합니다. 예를 들어, 질의응답 시스템에서 사용자의 질문과 유사한 문서를 검색하여 보다 정확한 답변을 생성할 수 있습니다. 다음은 벡터 데이터베이스를 활용한 질의응답 시스템의 예시 코드입니다.

from transformers import pipeline
from vectordb import VectorDB

# 질의응답 파이프라인 생성
qa_pipeline = pipeline("question-answering", model="bert-large-uncased-whole-word-masking-finetuned-squad")

# 벡터 데이터베이스 초기화
db = VectorDB("my_database")

# 사용자 질문
question = "LLM과 벡터 데이터베이스를 연결하는 것이 왜 중요한가요?"

# 벡터 데이터베이스에서 유사 문서 검색
similar_docs = db.search(question, top_k=3)

# 검색된 문서를 기반으로 질문에 답변
for doc in similar_docs:
    result = qa_pipeline(question=question, context=doc)
    print(f"Answer: {result['answer']}")
    print(f"Score: {result['score']:.2f}")
    print("---")

위 코드에서는 VectorDB라는 가상의 벡터 데이터베이스를 사용하여 사용자 질문과 유사한 문서를 검색합니다. 그 후 BERT 기반의 질의응답 모델을 활용하여 검색된 문서를 기반으로 질문에 답변을 생성합니다. 실행 결과는 다음과 같습니다.

Answer: LLM과 벡터 데이터베이스를 연결하면 의미적으로 유사한 문서를 빠르게 검색하여 보다 정확한 답변을 생성할 수 있기 때문입니다.
Score: 0.87
---
Answer: 벡터 데이터베이스는 대량의 벡터 데이터를 효율적으로 저장하고 유사도 검색을 수행할 수 있어 LLM의 잠재력을 극대화할 수 있습니다.
Score: 0.82
---
Answer: 문장 임베딩을 통해 텍스트를 벡터로 변환하여 벡터 데이터베이스에 저장하면 유사한 문장을 빠르게 검색할 수 있습니다.
Score: 0.79
---

이처럼 LLM과 벡터 데이터베이스를 연결하면 방대한 양의 데이터 속에서 필요한 정보를 신속하게 찾아 활용할 수 있습니다. 이는 chatbot, 추천 시스템, 문서 검색 등 다양한 분야에서 큰 가치를 발휘할 것으로 기대됩니다.

그렇다면 실제로 LLM과 벡터 데이터베이스를 연결하려면 어떤 과정을 거쳐야 할까요? 다음 섹션에서는 구체적인 구현 방법과 고려 사항에 대해 알아보겠습니다.

기본 구조 및 문법

LLM과 벡터데이터베이스를 연결하는 기본 구조와 문법을 살펴보겠습니다. 먼저, LLM 모델을 로드하고 벡터데이터베이스에 연결하는 방법을 알아보겠습니다.

from transformers import AutoModelForCausalLM, AutoTokenizer
from pymilvus import connections, Collection

# LLM 모델 로드
model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 벡터데이터베이스 연결
connections.connect("default", host="localhost", port="19530")

위 코드에서는 Hugging Face의 AutoModelForCausalLM과 AutoTokenizer를 사용하여 GPT-2 모델을 로드하고, Milvus의 pymilvus 라이브러리를 사용하여 벡터데이터베이스에 연결합니다. connections.connect() 함수를 사용하여 로컬호스트의 Milvus 서버에 연결합니다.

다음으로, 벡터데이터베이스에 텍스트 임베딩을 저장하는 방법을 살펴보겠습니다.

from sentence_transformers import SentenceTransformer

# 텍스트 임베딩 모델 로드
embedding_model = SentenceTransformer('all-MiniLM-L6-v2')

# 텍스트 임베딩 생성
text = "This is a sample text."
embedding = embedding_model.encode(text)

# 벡터데이터베이스에 임베딩 저장
collection_name = "embeddings"
collection = Collection(collection_name)
collection.insert([[embedding.tolist()]])

위 코드에서는 Sentence Transformers 라이브러리의 SentenceTransformer를 사용하여 텍스트 임베딩 모델을 로드합니다. encode() 함수를 사용하여 텍스트를 임베딩으로 변환한 후, Milvus의 Collection을 사용하여 임베딩을 벡터데이터베이스에 저장합니다.

마지막으로, 벡터데이터베이스에서 유사한 텍스트를 검색하는 방법을 알아보겠습니다.

# 쿼리 텍스트 임베딩 생성
query_text = "This is a similar text."
query_embedding = embedding_model.encode(query_text)

# 벡터데이터베이스에서 유사한 텍스트 검색
search_params = {"metric_type": "L2", "params": {"nprobe": 10}}
results = collection.search([query_embedding.tolist()], anns_field="embedding", param=search_params, limit=5)

# 검색 결과 출력
for result in results:
    print(f"Score: {result.distance}, Text: {texts[result.id]}")

위 코드에서는 쿼리 텍스트를 임베딩으로 변환한 후, Milvus의 search() 함수를 사용하여 벡터데이터베이스에서 유사한 텍스트를 검색합니다. 검색 결과는 유사도 점수와 함께 출력됩니다.

출력 결과 예시:

Score: 0.1234, Text: This is a sample text.
Score: 0.2345, Text: This is another similar text.

이제 LLM과 벡터데이터베이스를 연결하는 기본 구조와 문법에 대해 알아보았습니다. 다음 섹션에서는 이를 활용하여 실제 애플리케이션을 구현하는 방법에 대해 자세히 살펴보겠습니다.

심화 개념 및 테크닉

LLM과 벡터 데이터베이스를 연결하는 고급 사용법과 패턴에 대해 더 알아보겠습니다. 다음은 몇 가지 코드 예제와 함께 심화 개념 및 테크닉을 소개합니다.

1. 벡터 데이터베이스에서 유사도 검색 수행하기:

from pymilvus import connections, Collection

connections.connect("default", host='localhost', port='19530')

collection = Collection("my_collection")

query_embedding = model.encode("What is the capital of France?")
search_params = {"metric_type": "L2", "params": {"nprobe": 10}}
results = collection.search([query_embedding], "embeddings", param=search_params, limit=5, output_fields=["id", "text"])

for result in results:
    print(f"ID: {result.id}, Text: {result.text}, Distance: {result.distance}")

위 코드는 Milvus 벡터 데이터베이스에 연결하여 저장된 임베딩 벡터와 유사한 벡터를 검색하는 예제입니다. search() 메서드를 사용하여 쿼리 임베딩과 유사한 벡터를 검색하고, 검색 결과를 출력합니다.

2. 벡터 데이터베이스에 임베딩 벡터 추가하기:

from pymilvus import connections, FieldSchema, CollectionSchema, DataType, Collection

connections.connect("default", host='localhost', port='19530')

fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
    FieldSchema(name="text", dtype=DataType.VARCHAR, max_length=65535),
    FieldSchema(name="embeddings", dtype=DataType.FLOAT_VECTOR, dim=768)
]
schema = CollectionSchema(fields)

collection = Collection("my_collection", schema)

texts = ["This is a sample text", "Another example sentence", "One more text data"]
embeddings = [model.encode(text) for text in texts]

collection.insert([
    [text for text in texts], 
    [embedding for embedding in embeddings]
])

이 코드는 Milvus 벡터 데이터베이스에 새로운 컬렉션을 생성하고, 텍스트 데이터와 해당 텍스트의 임베딩 벡터를 추가하는 예제입니다. FieldSchema를 사용하여 컬렉션의 필드를 정의하고, insert() 메서드로 데이터를 삽입합니다.

3. 벡터 데이터베이스에서 데이터 삭제하기:

from pymilvus import connections, Collection

connections.connect("default", host='localhost', port='19530')

collection = Collection("my_collection")

ids_to_delete = [1, 3, 5]
collection.delete(ids_to_delete)

위 코드는 Milvus 벡터 데이터베이스에서 특정 데이터를 삭제하는 예제입니다. delete() 메서드를 사용하여 삭제할 데이터의 ID를 전달합니다.

이처럼 LLM과 벡터 데이터베이스를 연결하면 다양한 고급 기능을 활용할 수 있습니다. 벡터 데이터베이스의 강력한 유사도 검색과 LLM의 자연어 처리 능력을 결합하여 더욱 정교한 애플리케이션을 개발할 수 있습니다.

이제 LLM과 벡터 데이터베이스를 연결하는 방법에 대해 알아보았으니, 실제로 이를 활용하여 어떤 흥미로운 프로젝트를 만들 수 있을지 생각해보겠습니다.

실전 예제

이제 LLM과 벡터데이터베이스를 연결하여 실제 프로젝트에 적용해보겠습니다. 아래는 단계별 예시와 코드입니다.

1. 필요한 라이브러리를 설치하고 임포트합니다.

!pip install langchain
!pip install openai
!pip install tiktoken
!pip install pinecone-client

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Pinecone
from langchain.text_splitter import CharacterTextSplitter
from langchain.llms import OpenAI
from langchain.chains.question_answering import load_qa_chain
import pinecone

필요한 라이브러리를 설치하고 임포트하여 LLM, 벡터데이터베이스, 텍스트 분할, 질문-답변 체인 등의 기능을 사용할 수 있도록 준비합니다.

2. OpenAI API 키와 Pinecone 환경 변수를 설정합니다.

import os
os.environ["OPENAI_API_KEY"] = "your_openai_api_key"
os.environ["PINECONE_API_KEY"] = "your_pinecone_api_key"
os.environ["PINECONE_ENV"] = "your_pinecone_environment"

OpenAI API와 Pinecone을 사용하기 위해 필요한 API 키와 환경 변수를 설정합니다.

3. Pinecone 인덱스를 초기화하고 OpenAI 임베딩을 생성합니다.

pinecone.init(
    api_key=os.environ["PINECONE_API_KEY"],
    environment=os.environ["PINECONE_ENV"]
)

index_name = "your_index_name"
embeddings = OpenAIEmbeddings()

Pinecone 인덱스를 초기화하고 OpenAI 임베딩을 생성하여 텍스트를 벡터로 변환할 준비를 합니다.

4. 텍스트 데이터를 로드하고 분할합니다.

with open("your_text_file.txt") as f:
    text = f.read()

text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_text(text)

텍스트 파일을 로드하고 CharacterTextSplitter를 사용하여 텍스트를 1000자 단위로 분할합니다.

5. Pinecone에 텍스트 벡터를 저장합니다.

docsearch = Pinecone.from_texts(texts, embeddings, index_name=index_name)

Pinecone.from_texts() 메서드를 사용하여 텍스트를 벡터로 변환하고 Pinecone 인덱스에 저장합니다.

6. 질문-답변 체인을 로드하고 질문에 답변합니다.

llm = OpenAI(temperature=0, max_tokens=512)
chain = load_qa_chain(llm, chain_type="stuff")

query = "your_question_here"
docs = docsearch.similarity_search(query)

result = chain.run(input_documents=docs, question=query)
print(result)

OpenAI LLM을 로드하고 질문-답변 체인을 생성합니다. 사용자의 질문을 입력받아 Pinecone에서 유사한 벡터를 검색하고, 검색된 문서를 기반으로 LLM이 질문에 답변합니다.

위 코드를 실행하면 아래와 같은 결과를 얻을 수 있습니다.

Query: What is the capital of France?
Answer: The capital of France is Paris.

이렇게 LLM과 벡터데이터베이스를 연결하여 텍스트 데이터에 대한 질문-답변 시스템을 구축할 수 있습니다. 다음 섹션에서는 이를 더욱 발전시켜 실제 애플리케이션에 적용하는 방법에 대해 알아보겠습니다.

성능 최적화 팁

LLM과 벡터데이터베이스를 연결하여 사용할 때 성능을 최적화하기 위해 다음과 같은 방법을 적용할 수 있습니다.

1. 벡터 차원 수 조정:

벡터의 차원 수를 줄이면 메모리 사용량과 검색 시간을 개선할 수 있습니다. 다음은 벡터 차원 수를 조정하는 예시 코드입니다.

# Before: 벡터 차원 수가 높은 경우
embeddings = model.encode(texts, convert_to_tensor=True)  # 차원 수: 768

# After: 벡터 차원 수를 줄인 경우
embeddings = model.encode(texts, convert_to_tensor=True, normalize_embeddings=True)  # 차원 수: 128

위 코드에서 normalize_embeddings 파라미터를 True로 설정하면 벡터의 차원 수를 줄일 수 있습니다. 이렇게 하면 메모리 사용량과 검색 속도가 개선됩니다.

2. 벡터 인덱싱 사용:

벡터데이터베이스에서 인덱싱을 사용하면 검색 성능을 크게 향상시킬 수 있습니다. 다음은 Faiss 라이브러리를 사용하여 벡터 인덱싱을 적용하는 예시 코드입니다.

import faiss

# Before: 인덱싱 없이 검색
index = faiss.IndexFlatL2(embeddings.shape[1])
index.add(embeddings)
distances, indices = index.search(query_embedding, k=5)

# After: 인덱싱을 사용하여 검색
nlist = 100  # 클러스터 수
quantizer = faiss.IndexFlatL2(embeddings.shape[1])  
index = faiss.IndexIVFFlat(quantizer, embeddings.shape[1], nlist, faiss.METRIC_L2)
index.train(embeddings)
index.add(embeddings)
distances, indices = index.search(query_embedding, k=5)

위 코드에서 faiss.IndexIVFFlat을 사용하여 인덱싱을 적용하면 검색 속도가 크게 향상됩니다. 인덱싱은 벡터를 클러스터링하고 검색 시 관련 클러스터만 탐색하여 효율성을 높입니다.

3. 배치 처리 활용:

벡터 임베딩과 검색을 배치 단위로 처리하면 속도를 높일 수 있습니다. 다음은 배치 처리를 활용하는 예시 코드입니다.

# Before: 개별 처리
embeddings = []
for text in texts:
    embedding = model.encode(text, convert_to_tensor=True)
    embeddings.append(embedding)

# After: 배치 처리
batch_size = 32
embeddings = []
for i in range(0, len(texts), batch_size):
    batch_texts = texts[i:i+batch_size]
    batch_embeddings = model.encode(batch_texts, convert_to_tensor=True)
    embeddings.extend(batch_embeddings)

위 코드에서 batch_size를 설정하고 텍스트를 배치 단위로 처리하면 임베딩 생성 속도가 향상됩니다. 배치 처리는 GPU 활용도를 높이고 연산 오버헤드를 줄여줍니다.

위에서 소개한 성능 최적화 방법들을 적용하면 LLM과 벡터데이터베이스를 연결하여 사용할 때 검색 속도와 메모리 효율성을 크게 개선할 수 있습니다. 다음 섹션에서는 이러한 최적화 기법을 실제 프로젝트에 적용하는 방법에 대해 살펴보겠습니다.

일반적인 오류와 해결 방법

LLM과 벡터데이터베이스를 연결하는 과정에서 몇 가지 자주 발생하는 오류들이 있습니다. 이 섹션에서는 그러한 오류들과 해결 방법을 코드 예제와 함께 살펴보겠습니다.

먼저, 벡터데이터베이스에 연결할 때 인증 오류가 발생할 수 있습니다. 이는 보통 잘못된 엑세스 키나 시크릿 키를 사용했을 때 나타납니다.

from pymilvus import connections

connections.connect("default", host='localhost', port='19530', user='username', password='incorrect_password')

위 코드에서 password가 올바르지 않아 인증 오류가 발생합니다. 정확한 인증 정보를 입력하면 이 문제를 해결할 수 있습니다.

다음으로, 벡터 차원(dimension)이 일치하지 않아 오류가 발생하는 경우가 있습니다. LLM에서 생성한 벡터와 데이터베이스의 벡터 차원이 동일해야 합니다.

from pymilvus import Collection

collection = Collection("my_collection")
wrong_dim_vectors = [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]]  # 3차원 벡터

collection.insert(wrong_dim_vectors)  # 차원 불일치로 인한 오류 발생

위 코드에서는 my_collection이 예를 들어 4차원 벡터용으로 생성되었는데, 3차원 벡터를 삽입하려 해서 오류가 발생합니다. LLM과 벡터데이터베이스의 벡터 차원을 일치시켜야 합니다.

마지막으로, 쿼리 시 적절한 인덱스를 사용하지 않아 성능 저하가 발생할 수 있습니다. 인덱스를 생성하고 사용하면 검색 속도를 크게 향상시킬 수 있습니다.

from pymilvus import Collection

collection = Collection("my_collection")

query_vectors = [[0.2, 0.4, 0.6, 0.8]]
result = collection.search(query_vectors, anns_field="embedding", param={"nprobe": 10})
print(result)  # 인덱스 없이 검색하여 느린 결과 반환

위 코드는 인덱스를 사용하지 않고 검색하는 예시입니다. collection.create_index()를 사용하여 인덱스를 생성한 후 param에 인덱스 정보를 전달하면 빠른 검색이 가능합니다.

collection.create_index("embedding", index_params={"metric_type": "L2", "index_type": "IVF_FLAT", "params": {"nlist": 128}})

result = collection.search(query_vectors, anns_field="embedding", param={"nprobe": 16})
print(result)  # 인덱스를 사용하여 빠른 검색 결과 반환

위와 같이 인덱스를 생성하고 nprobe 파라미터를 조정하면 검색 성능을 최적화할 수 있습니다.

이상으로 LLM과 벡터데이터베이스 연결 시 자주 발생하는 오류들과 해결 방법을 알아보았습니다. 이제 실제로 LLM과 벡터데이터베이스를 연결하여 활용하는 방법을 살펴보겠습니다.

최신 트렌드와 미래 전망

LLM과 벡터 데이터베이스를 연결하는 최신 트렌드로는 파이썬의 라이브러리인 LangChain을 활용하는 방법이 있습니다. LangChain은 LLM과 벡터 데이터베이스를 쉽게 연결할 수 있는 인터페이스를 제공합니다.

예를 들어, OpenAI의 GPT-3와 Pinecone 벡터 데이터베이스를 연결하는 코드는 다음과 같습니다:

from langchain.llms import OpenAI
from langchain.vectorstores import Pinecone
import pinecone

# Pinecone 초기화
pinecone.init(api_key="your_api_key", environment="your_env")

# OpenAI LLM 설정
llm = OpenAI(temperature=0, openai_api_key="your_openai_api_key") 

# Pinecone 벡터 데이터베이스 로드
index_name = "your_index_name"
vectorstore = Pinecone.from_existing_index(index_name, llm.embed_query)

위 코드에서는 Pinecone 데이터베이스를 초기화하고, OpenAI LLM을 설정한 후, 기존의 Pinecone 인덱스를 로드하여 벡터 데이터베이스와 연결합니다. `llm.embed_query`는 텍스트를 벡터로 임베딩하는 함수입니다.

연결된 벡터 데이터베이스를 활용하여 유사도 검색을 수행하는 예제는 다음과 같습니다:

query = "What is the capital of France?"
result = vectorstore.similarity_search(query, k=1)

print(result[0].page_content)

실행 결과:

The capital of France is Paris.

위 코드에서는 `similarity_search` 메서드를 사용하여 질의와 가장 유사한 문서를 검색합니다. `k` 매개변수는 반환할 유사 문서의 개수를 지정합니다.

또 다른 예로, Chroma 벡터 데이터베이스와 Hugging Face의 BERT 모델을 사용하는 코드는 다음과 같습니다:

from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import Chroma

# Hugging Face 임베딩 모델 로드
embeddings = HuggingFaceEmbeddings()

# Chroma 벡터 데이터베이스 생성
vectorstore = Chroma.from_texts(texts, embeddings)

query = "What is the meaning of life?"
result = vectorstore.similarity_search(query, k=1)
print(result[0].page_content)

위 코드에서는 Hugging Face의 임베딩 모델을 사용하여 텍스트를 벡터로 변환하고, Chroma 데이터베이스에 저장합니다. 그 후 `similarity_search`를 사용하여 유사도 검색을 수행합니다.

LLM과 벡터 데이터베이스의 연결은 지식 검색, 질의 응답, 추천 시스템 등 다양한 분야에서 활용될 수 있습니다. 향후에는 더욱 다양한 LLM과 벡터 데이터베이스의 조합이 등장하고, 이를 쉽게 통합할 수 있는 도구들이 발전할 것으로 예상됩니다.

다음 섹션에서는 LLM과 벡터 데이터베이스를 활용한 실제 애플리케이션 구축 사례를 살펴보겠습니다.

결론 및 추가 학습 자료

이 포스트에서는 LLM과 벡터 데이터베이스를 연결하는 방법에 대해 알아보았습니다. 주요 내용은 다음과 같습니다:

• LLM을 활용하여 텍스트 임베딩을 생성하는 방법
• 벡터 데이터베이스에 임베딩을 저장하고 검색하는 방법
• LLM과 벡터 데이터베이스를 연결하여 질의응답 시스템을 구축하는 방법

텍스트 임베딩 생성 예제:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')
sentences = ["안녕하세요", "반갑습니다"]
embeddings = model.encode(sentences)
print(embeddings)

위 코드는 sentence-transformers 라이브러리를 사용하여 텍스트 임베딩을 생성하는 예제입니다. all-MiniLM-L6-v2 모델을 로드하고, 텍스트 리스트를 입력으로 받아 임베딩을 생성합니다.

벡터 데이터베이스에 임베딩 저장 예제:

from qdrant_client import QdrantClient

client = QdrantClient(host="localhost", port=6333)
collection_name = "my_collection"
client.recreate_collection(collection_name=collection_name, vector_size=384)

client.upsert(
    collection_name=collection_name,
    points=[
        {"id": 1, "vector": embeddings[0], "payload": {"text": sentences[0]}},
        {"id": 2, "vector": embeddings[1], "payload": {"text": sentences[1]}}
    ]
)

위 코드는 Qdrant 벡터 데이터베이스를 사용하여 생성한 임베딩을 저장하는 예제입니다. QdrantClient를 초기화하고, 컬렉션을 생성한 후, upsert 메서드를 사용하여 임베딩과 원본 텍스트를 저장합니다.

벡터 데이터베이스에서 유사한 임베딩 검색 예제:

query_text = "안녕하세요"
query_embedding = model.encode([query_text])[0]

search_result = client.search(
    collection_name=collection_name,
    query_vector=query_embedding,
    limit=1
)

print(search_result[0].payload["text"])

위 코드는 벡터 데이터베이스에서 유사한 임베딩을 검색하는 예제입니다. 검색할 텍스트의 임베딩을 생성하고, search 메서드를 사용하여 가장 유사한 임베딩을 찾습니다. 검색 결과에서 원본 텍스트를 출력합니다.

출력 결과:

안녕하세요

추천 학습 자료:

• [Sentence Transformers 공식 문서](https://www.sbert.net/)
• [Qdrant 공식 문서](https://qdrant.tech/documentation/)
• [Pinecone 공식 문서](https://www.pinecone.io/docs/)