🦜🔗 랭체인(Langchain)으로 Naive RAG 구현하기 cookbook

CLOVA Studio 운영자 · November 8

본 가이드는 클로바 스튜디오(CLOVA Studio)와 랭체인(Langchain)을 이용해 RAG(Retrieval Augmented Generation; 검색 증강 생성) 시스템을 만드는 방법을 설명합니다.

NCP 가이드: https://guide.ncloud-docs.com/docs/clovastudio-dev-langchain
LangChain 공식 문서: https://python.langchain.com/docs/integrations/providers/naver/

RAG는 AI가 주어진 정보를 바탕으로 더 정확하고 관련성 높은 답변을 생성하도록 돕는 기술입니다. 이 예제에서 우리는 HTML 형식의 데이터(클로바 스튜디오 가이드)를 기반으로 질문에 대한 답변을 출력하는 RAG 시스템을 랭체인을 활용해 구현해보겠습니다. 구현하고자 하는 RAG 시스템의 구조도는 아래와 같습니다.

클로바 스튜디오의 HyperCLOVA X 모델 (챗 모드), 임베딩 API, 문단 나누기 API를 사용하며, 랭체인을 통해 아래와 같은 단계로 진행해 간단한 RAG 시스템을 구현해보겠습니다.

버전 정보
아래 예제 코드는 Python 3.12.4에서 실행 확인하였으며, 최소 Python3.9를 필요로 합니다.
아래 파일을 참고해 필요한 모듈을 모두 설치해줍니다.
requirements.txt

1. 사전 준비

1) Langchain 패키지 설치

langchain-community >= 0.3.4부터 langchain_community 안에 ChatClovaX, ClovaXEmbeddings가 포함되었습니다. 랭체인은 아래 명령문을 통해 설치할 수 있습니다.

pip install langchain

pip install langchain-community~=0.3.4

2) 참조할 문서 (HTML 데이터) 준비

본 예제에서는 네이버클라우드플랫폼(NCP)의 클로바 스튜디오 사용 가이드중 CLOVA Studio 개념, CLOVA Studio 시나리오 페이지를 HTML 데이터로 활용합니다. 참고할 웹사이트의 링크를 아래와 같이 txt 파일로 준비했으며, 해당 내용은 필요한 데이터에 맞게 수정되어도 무방합니다.

(주의) txt파일을 작성할 때는 한 줄에 하나의 URL을 작성해야 합니다. 즉, 각 URL은 줄바꿈으로 구분되어야 합니다.

https://guide.ncloud-docs.com/docs/clovastudio-info
https://guide.ncloud-docs.com/docs/clovastudio-procedure

3) 코드에 공통적으로 들어가는 필요 모듈 import

import json

import getpass

import os

from tqdm import tqdm

import requests

import time

import uuid

from uuid import uuid4

from pathlib import Path

4) 테스트앱 및 API키 미리 발급 받기

각 모듈 호출시 필요한 테스트앱 및 API키를 미리 발급받고 환경 변수로 저장해두세요.

Quote

키 값 가져오는 방법 (클로바 스튜디오 앱 신청 현황 페이지)

1.API키, Gateway키 설정하기
테스트 앱을 이용하는 경우, API키와 Gateway키는 계정당 발급되기 때문에 어떤 테스트앱으로 발급받아도 키 값이 동일합니다.
본 예제에선 테스트 앱을 사용하므로 API 키와 Gateway 키를 사전 발급받아 정의해두고, 각 모듈 호출시 불러오겠습니다.

단, 앱의 API Key/API GW Key가 전부 동일한 건 테스트앱만 해당됩니다. 서비스 앱을 이용하고자 할 경우 사전 설정이 아니라 개별 모듈 정의 시마다 해당 API Key를 입력해야합니다.

NCP_CLOVASTUDIO_API_KEY

NCP_APIGW_API_KEY

2.문단나누기 테스트 앱 발급받고, app_id 값을 설정하기
(ClovaStudio > 익스플로러 > 문단 나누기 > 테스트앱 발급)

NCP_CLOVASTUDIO_APP_ID_SEGMENTATION

3. 임베딩V2 테스트앱 발급받고, app_id 값을 설정하기
(ClovaStudio > 익스플로러 > 임베딩V2 > 테스트앱 발급)
*임베딩 모델 emb,sts를 쓰는경우 V1으로 발급 받아야합니다.

NCP_CLOVASTUDIO_APP_ID

# API 키와 Gateway API 키를 넣습니다.

os.environ["NCP_CLOVASTUDIO_API_KEY"] = getpass.getpass("NCP CLOVA Studio API Key: ")

os.environ["NCP_APIGW_API_KEY"] = getpass.getpass("NCP API Gateway API Key: ")

NCP CLOVA Studio API Key:  ········
NCP API Gateway API Key:  ········

# 문단나누기 테스트앱의 앱 ID를 넣습니다.

os.environ["NCP_CLOVASTUDIO_APP_ID_SEGMENTATION"] = input("NCP CLOVA Studio Segmentation App ID: ")

NCP CLOVA Studio Segmentation App ID:  <your Segmentation App ID>

# 임베딩 테스트앱의 앱 ID를 넣습니다.

os.environ["NCP_CLOVASTUDIO_APP_ID"] = input("NCP CLOVA Studio App ID: ")

NCP CLOVA Studio App ID:  <your App ID>

2. Load

RAG의 첫번째 작업은 추후 LLM이 응답의 문맥으로 사용할 때 RAG 시스템이 참고할 HTML 데이터를 준비하는 단계입니다. txt 파일(clovastudiourl.txt)에 사용하고 싶은 사이트 URL을 작성한 후, wget 라이브러리와 LangChain의 Document Loader 컴포넌트를 활용하여 HTML 데이터를 작업에 편한 형태로 변환했습니다. 또한, 로딩한 데이터 안에 사이트 URL을 넣어 추후 답변과 함께 사이트 주소가 출력되게 하여 질문한 사용자가 답변의 내용이 있는 실제 URL을 함께 참조할 수 있게 데이터를 수정했습니다.

1) txt → html 변환 및 원본 사이트 주소 mapping

import subprocess

url_to_filename_map = {}

with open("clovastudiourl.txt", "r") as file:

urls = [url.strip() for url in file.readlines()]

folder_path = "clovastudioguide"

if not os.path.exists(folder_path):

os.makedirs(folder_path)

for url in urls:

filename = url.split("/")[-1] + ".html"

file_path = os.path.join(folder_path, filename)

subprocess.run(["wget", "--user-agent=RAGCookbook-Crawler/1.0", "-O", file_path, url], check=True)

url_to_filename_map[url] = filename

with open("url_to_filename_map.json", "w") as map_file:

json.dump(url_to_filename_map, map_file)

#Output
--2024-08-26 13:37:02--  https://guide.ncloud-docs.com/docs/clovastudio-info
Resolving guide.ncloud-docs.com (guide.ncloud-docs.com)... 104.18.6.159, 104.18.7.159
Connecting to guide.ncloud-docs.com (guide.ncloud-docs.com)|104.18.6.159|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: unspecified [text/html]
Saving to: ‘clovastudioguide_0822/clovastudio-info.html’

     0K .......... .......... .......... .......... .......... 21.4M
    50K .......... .......... .......... ..........            83.3M=0.003s

2024-08-26 13:37:02 (32.1 MB/s) - ‘clovastudioguide_0822/clovastudio-info.html’ saved [92957]

--2024-08-26 13:37:02--  https://guide.ncloud-docs.com/docs/clovastudio-procedure
Resolving guide.ncloud-docs.com (guide.ncloud-docs.com)... 104.18.6.159, 104.18.7.159
Connecting to guide.ncloud-docs.com (guide.ncloud-docs.com)|104.18.6.159|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: unspecified [text/html]
Saving to: ‘clovastudioguide_0822/clovastudio-procedure.html’

     0K .......... .......... .......... .......... .......... 18.0M
    50K .......... .......... ..........                       21.6M=0.004s

2024-08-26 13:37:03 (19.2 MB/s) - ‘clovastudioguide_0822/clovastudio-procedure.html’ saved [82265]

LangChain을 활용해 로딩한 html은, 파일을 저장한 디렉토리의 주소를 metadata의 'source'로 가져오게 됩니다. 추후 답변 제공시, 디렉토리 주소가 아닌 실제 URL을 제공하기 위해, LangChain이 로딩한 데이터를 수정해야합니다. html을 로딩할 때 파일명을 URL로 할 경우, /와 : 기호로 인해 파일명이 깨지게 됩니다. 따라서 원본 URL과 로딩한 HTML 파일을 쌍으로 mapping하고, 이 정보를 json 형식으로 "url_to_filename_map"에 저장합니다. 이후, html 파일의 저장 경로가 담긴 'source'를, 이 json 파일을 참고해 실제 URL로 변환해줍니다. 위 코드는, json 파일을 저장하는 단계까지입니다.

외부 사이트 접근 허용 코드

wget 명령어를 통해 HTML 데이터를 로딩하기 전, 해당 웹사이트의 robots.txt를 확인하여 데이터로 활용할 웹페이지의 크롤러 접근 허용 여부를 확인해야합니다. NCP의 클로바스튜디오 사용 가이드의 경우 User-agent: * Allow:/ 로 접근이 가능합니다.
- 일부 사이트는 User-agent를 정의하는 부분을 추가해서 사용해야 웹 서버의 요청 차단이나 에러를 방지할 수 있습니다. 대부분 서버의 --user-agent는 Mozilla/5.0를 따르고 있습니다. 하지만 경우에 따라 불러오고자 하는 사이트의 --user-agent 정보를 직접 찾아서 적어야합니다.

2) LangChain 활용 HTML 로딩

2-1) BSHTMLLoader 사용

#!pip install beautifulsoup4 lxml #필요시 beautifulsoup4 설치

from langchain_community.document_loaders import BSHTMLLoader

# 폴더 이름에 맞게 수정

html_files_dir = Path('clovastudioguide')

html_files = list(html_files_dir.glob("*.html"))

# 모든 문서 데이터를 저장할 리스트 초기화

clovastudiodatas = []

# 찾은 HTML 파일들에 대해 처리

for html_file in html_files:

# 각 파일에 대해 BSHTMLLoader 인스턴스 생성

loader = BSHTMLLoader(str(html_file))

document_data = loader.load()

# 로드된 문서 데이터를 리스트에 추가

clovastudiodatas.append(document_data)

print(f"Processed {html_file}")

#Output
Processed /Users/user/langchain/libs/community/sample/clovastudioguide/clovastudio-info.html
Processed /Users/user/langchain/libs/community/sample/clovastudioguide/clovastudio-procedure.html

2-2) UnstructuredHTMLLoader 사용
이전 단계에서 txt 파일을 HTML로 변환한 후, LangChain의 UnstructuredHTMLLoader를 사용하여 이후 문단 나누기와 임베딩을 위해 machine readable한 형태로 변환해 줍니다.

#!pip install unstructured #필요시 unstructured 설치

from langchain_community.document_loaders import UnstructuredHTMLLoader

# 폴더 이름에 맞게 수정

html_files_dir = Path('./clovastudioguide')

html_files = list(html_files_dir.glob("*.html"))

clovastudiodatas = []

for html_file in html_files:

loader = UnstructuredHTMLLoader(str(html_file))

document_data = loader.load()

clovastudiodatas.append(document_data)

print(f"Processed {html_file}")

#Output
Processed /Users/user/langchain/libs/community/sample/clovastudioguide/clovastudio-info.html
Processed /Users/user/langchain/libs/community/sample/clovastudioguide/clovastudio-procedure.html

각 HTML에는 page_content에 모든 텍스트가, metadata의 'source'에는 저장 경로가 기록되어 있습니다. 위는, 로딩된 데이터 중 하나인 clovastudio-info.html의 형태입니다. metadata의 'source'에 실제 URL이 아닌 html 파일이 저장된 디렉토리 경로가 담긴 것을 확인할 수 있습니다. Mapping을 통해 이 'source'를 실제 URL로 바꾸는 작업을 다음 단계에 진행하게 됩니다.

3) Mapping 정보를 활용해 'source'를 실제 URL로 대체

아래의 output은 앞선 예시인 clovastudio-info.html의 형태입니다. Mapping 정보를 활용해 'source'를 실제 url로 바꾼 것을 확인할 수 있습니다.

with open("url_to_filename_map.json", "r") as map_file:

url_to_filename_map = json.load(map_file)

filename_to_url_map = {v: k for k, v in url_to_filename_map.items()}

# clovastudiodatas 리스트의 각 Document 객체의 'source' 수정

for doc_list in clovastudiodatas:

for doc in doc_list:

extracted_filename = doc.metadata["source"].split("/")[-1]

if extracted_filename in filename_to_url_map:

doc.metadata["source"] = filename_to_url_map[extracted_filename]

else:

print(f"Warning: {extracted_filename}에 해당하는 URL을 찾을 수 없습니다.")

print(doc.metadata["source"])

#Output
https://guide.ncloud-docs.com/docs/clovastudio-procedure

# 이중 리스트를 풀어서 하나의 리스트로 만드는 작업

clovastudiodatas_flattened = [item for sublist in clovastudiodatas for item in sublist]

HTML데이터가 잘 로딩되었는지 결과물을 출력해 확인해봅니다.

# 처음 3개 문서의 URL과 내용 일부 출력

for doc in clovastudiodatas_flattened[:2]:

print(f"URL: {doc.metadata['source']}")

print(f"{doc.page_content[:100]}...")

print("-" * 50)

#Output
URL: https://guide.ncloud-docs.com/docs/clovastudio-info
Login
Korean
English
Ja - 日本語
Korean
API 가이드
(...이하 중략)

3. Chunking

임베딩 모델이 처리할 수 있는 적당한 크기로 raw data를 나누는 것은 매우 중요합니다. 이는 임베딩 모델마다 한 번에 처리할 수 있는 토큰 수의 한계가 있기 때문입니다. CLOVA Studio의 문단 나누기 API를 활용해 앞서 만든 raw data를 나눠보겠습니다. 모델이 직접 문장들간의 의미 유사도를 찾아 최적의 청크(chunk) 개수와 사용자가 원하는 1개 청크 크기(글자 수)를 직접 설정하여 문단을 나눌 수 있습니다. 추가로, 후처리(postProcess = True)를 통해 chunk당 글자 수의 상한선과 하한선을 postProcessMaxSize와 postProcessMinSize로 조절할 수도 있습니다.

import http.client

from http import HTTPStatus

class CLOVAStudioExecutor:

def __init__(self, host, request_id=None):

self._host = host

self._api_key = os.environ["NCP_CLOVASTUDIO_API_KEY"]

self._api_key_primary_val = os.environ["NCP_APIGW_API_KEY"]

self._request_id = request_id or str(uuid.uuid4())

def _send_request(self, completion_request, endpoint):

headers = {

'Content-Type': 'application/json; charset=utf-8',

'X-NCP-CLOVASTUDIO-API-KEY': self._api_key,

'X-NCP-APIGW-API-KEY': self._api_key_primary_val,

'X-NCP-CLOVASTUDIO-REQUEST-ID': self._request_id

}

conn = http.client.HTTPSConnection(self._host)

conn.request('POST', endpoint, json.dumps(completion_request), headers)

response = conn.getresponse()

status = response.status

result = json.loads(response.read().decode(encoding='utf-8'))

conn.close()

return result, status

def execute(self, completion_request, endpoint):

res, status = self._send_request(completion_request, endpoint)

if status == HTTPStatus.OK:

return res, status

else:

error_message = res.get("status", {}).get("message", "Unknown error") if isinstance(res, dict) else "Unknown error"

raise ValueError(f"오류 발생: HTTP {status}, 메시지: {error_message}")

class SegmentationExecutor(CLOVAStudioExecutor):

def execute(self, completion_request):

app_id = os.environ["NCP_CLOVASTUDIO_APP_ID_SEGMENTATION"]

endpoint = f'/testapp/v1/api-tools/segmentation/{app_id}'

res, status = super().execute(completion_request, endpoint)

if status == HTTPStatus.OK and "result" in res:

return res["result"]["topicSeg"]

else:

error_message = res.get("status", {}).get("message", "Unknown error") if isinstance(res, dict) else "Unknown error"

raise ValueError(f"오류 발생: HTTP {status}, 메시지: {error_message}")

if __name__ == "__main__":

# 환경 변수가 설정되어 있는지 확인

required_env_vars = [

"NCP_CLOVASTUDIO_API_KEY",

"NCP_APIGW_API_KEY",

"NCP_CLOVASTUDIO_APP_ID_SEGMENTATION"

]

missing_vars = [var for var in required_env_vars if not os.environ.get(var)]

if missing_vars:

raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")

segmentation_executor = SegmentationExecutor(

host="clovastudio.apigw.ntruss.com"

)

chunked_html = []

for htmldata in tqdm(clovastudiodatas_flattened):

try:

request_data = {

"postProcessMaxSize": 100,

"alpha": -100,

"segCnt": -1,

"postProcessMinSize": -1,

"text": htmldata.page_content,

"postProcess": True

}

response_data = segmentation_executor.execute(request_data)

result_data = [' '.join(segment) for segment in response_data]

for paragraph in result_data:

chunked_document = {

"metadata": htmldata.metadata["source"],

"page_content": paragraph

}

chunked_html.append(chunked_document)

except Exception as e:

print(f"Error processing data from {htmldata.metadata['source']}: {e}")

# 오류 발생 시 현재 반복을 건너뛰고 다음으로 진행

continue

print(len(chunked_html))

#Output
100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:04<00:00,  2.06s/it]
108

위 코드를 실행해 108개의 chunk가 생겼습니다. 샘플 청크를 3개 출력해 결과를 확인해봅시다.

# 청크 분석 및 출력

print(f"\n총 청크 수: {len(chunked_html)}")

# 샘플 청크 출력

print("\n샘플 청크 (처음 3개):")

for i, chunk in enumerate(chunked_html[:3], 1):

print(f"\n청크 {i}:")

print(f"메타데이터: {chunk['metadata']}")

print(f"내용: {chunk['page_content']}")

print(f"길이: {len(chunk['page_content'])} 문자")

#Output
총 청크 수: 108

샘플 청크 (처음 3개):

청크 1:
메타데이터: https://guide.ncloud-docs.com/docs/clovastudio-info
내용: Login Korean English Ja - 日本語 Korean API 가이드 CLI 가이드 내용 x HOME 포털 및 콘솔 네이버 클라우드 플랫폼 사용 환경 Compute Containers Storage Networking Database Security
길이: 145 문자

청크 2:
메타데이터: https://guide.ncloud-docs.com/docs/clovastudio-info
내용: AI Services AI·NAVER API Application Services Big Data & Analytics
길이: 66 문자

청크 3:
메타데이터: https://guide.ncloud-docs.com/docs/clovastudio-info
내용: Blockchain Business Applications Content Delivery Developer Tools Digital Twin Gaming
길이: 85 문자

4. Embedding

임베딩 단계는 앞서 Chunking 단계에서 생성된 chunk들을 기계가 이해할 수 있는 수치적 형태인 벡터 데이터로 변환하는 과정입니다. 문서의 의미를 벡터(숫자의 배열) 형태로 표현함으로써, 유저의 질문에 대해 관련있는 chunk를 검색하여 가져오는 유사도 계산시 활용됩니다.

1) LangChain을 통해 CLOVA Studio Embedding 활용하기

1-1) 임베딩 모델 설정하기
문단 나누기 API를 통해 분할된 청크(chunked_html)를 CLOVA Studio의 임베딩 API를 사용해 1024차원 벡터로 변환하는 과정입니다. <1. 사전 준비> 단계에서 발급한 임베딩 V2 테스트앱을 사용했으며, 앞서 저장해둔 API키 및 app id 를 활용합니다. 임베딩 V2는 bge-m3 모델을 사용하며, 이 모델은 임베딩 과정에서 유사도 판단을 위해 코사인 거리(Cosine)를 거리 단위로 사용합니다. 모델을 설정하지 않으면 clir-emb-dolphin 모델이 기본 설정되므로, ClovaXEmbeddings의 모델을 bge-m3로 설정해주어야 합니다.

from langchain_community.embeddings import ClovaXEmbeddings

clovax_embeddings = ClovaXEmbeddings(model='bge-m3') # 임베딩 모델을 설정해주세요

임베딩 모델은 니즈에 따라 세가지 모델 중, 선택하여 작업을 수행할 수 있습니다. 거리 단위를 임베딩부터 인덱싱, 검색까지 일치시켜야 데이터의 품질이 향상되므로, 임베딩 과정에서 사용한 모델(emb / sts / bge-m3)이 무엇인지 기억하는 것이 중요합니다. (자세한 내용은 클로바 스튜디오 가이드 참고)

도구명	모델명	최대 토큰 수	벡터 차원	권장 거리 지표
임베딩	clir-emb-dolphin (랭체인 기본설정)	500 토큰	1024	IP (Inner/Dot/Scalar Product; 내적)
임베딩	clir-sts-dolphin	500 토큰	1024	Cosine Similarity (코사인 유사도)
임베딩 v2	bge-m3	8192 토큰	1024	Cosine Similarity (코사인 유사도)

1-2) 임베딩 결과 확인하기
다음 예제 코드는 "클로바 스튜디오"라는 글자에 대해 CLOVA Studio의 임베딩 API를 사용해 임베딩을 생성하는 과정입니다. 임베딩은 텍스트 데이터의 의미를 벡터 공간에서 표현하기 위해 사용됩니다.

text = "클로바 스튜디오"

clovax_embeddings.embed_query(text)

결과를 확인해보면 "클로바 스튜디오"라는 텍스트에 대한 임베딩 벡터가 생성됩니다. 이 벡터의 크기는 1024로, 실수 배열의 형태로 표현됩니다.

#Output
[-0.13467026,
 -0.54031295,
 -0.5842034,
 1.6036854,
 -1.2513447,
 -0.8417246,
 -0.51857895,
...생략]

2) 리스트 형식의 documents로 만들기

임베딩 처리를 위해 앞서 만든 청크를 Document 객체들의 리스트 형식의 documents로 변환합니다.

from langchain_core.documents import Document

documents = []

for index, item in enumerate(chunked_html):

doc = Document(

page_content=str(item['page_content']),

metadata={"source": item['metadata']},

id=str(uuid4())

)

documents.append(doc)

아래 코드를 통해 변환된 documents의 구조를 확인할 수 있습니다.

# documents 구조 체크

for i, doc in enumerate(documents):

print(f"Document {i}:")

print(f" Page Content: {doc.page_content[:100]}...") # 첫 100자만 출력

print(f" Metadata: {doc.metadata}")

print(f" Page Content Type: {type(doc.page_content)}")

print(f" Metadata Type: {type(doc.metadata)}")

print("-" * 40)

#Output
Document 0:
  Page Content: CLOVA Studio 개념 Login Korean English Ja - 日本語 Korean API 가이드 CLI 가이드내용 x HOME 포털 및 콘솔 네이버 클라우드 플랫폼 사...
  Metadata: {'source': 'https://guide.ncloud-docs.com/docs/clovastudio-info', 'title': 'CLOVA Studio 개념'}
  Page Content Type: <class 'str'>
  Metadata Type: <class 'dict'>
----------------------------------------
Document 1:
  Page Content: 의견을 보내 주셔서 감사합니다.Classic/VPC 환경에서 이용 가능합니다.CLOVA Studio를 이용하는 전체 시나리오를 학습하기에 앞서 CLOVA Studio에 대한 몇 가...
  Metadata: {'source': 'https://guide.ncloud-docs.com/docs/clovastudio-info', 'title': 'CLOVA Studio 개념'}
  Page Content Type: <class 'str'>
  Metadata Type: <class 'dict'>
----------------------------------------
...(이하 중략)

5. Vector store

이 단계는 앞서 임베딩한 결과를 Vector Store에 효율적으로 저장하고 관리하는 단계입니다. 벡터 DB는 벡터 데이터를 저장하고 검색하기 위한 데이터베이스입니다. 이 예제에서는 로컬 환경에서 보다 쉽게 활용할 수 있는 Chroma와 FAISS를 사용했습니다. Langchain의 Vector DB 비교 문서를 보고, 자신의 개발 환경에 맞는 제품을 활용하세요.

1) Vector DB에 저장하기

1-1) Chroma 활용

Chroma는 오픈소스 Vector DB이며, 클라우드를 사용하지않고 클라이언트용으로 사용하면 Apache 2.0 라이센스에 무료로 이용할 수 있습니다. 본 예제에서는 chroma를 활용해 컬렉션을 생성하고, 컬렉션에 앞서 만든 문서를 추가해보겠습니다. hnsw:space의 값을 설정함으로써 임베딩 공간의 거리 방법을 사용자 정의할 수 있습니다. 임베딩에 사용할 모델은 유사도 판단을 위해 벡터의 cosine 거리 단위로 사용하므로, 컬렉션 또한 매개변수를 "cosine"으로 설정해주었습니다.

*매개변수는 ip, cosine, l2(기본값) 중에 선택할 수 있습니다.

또한, 임베딩 클래스에 오류가 발생시 멈추게끔 하는 로직을 일부 추가해, 다량의 데이터를 처리할 때 오류 발생시 재실행의 부담을 줄였습니다. LangChain 공식 문서에서 Chroma를 활용하는 자세한 내용을 확인할 수 있습니다.

#chroma 다운받기

%pip install -qU "langchain-chroma>=0.1.2"

import chromadb

from langchain_chroma import Chroma

# 임베딩 모델 정의

clovax_embeddings = ClovaXEmbeddings(model='bge-m3')

# 로컬 클라이언트 경로 지정

client = chromadb.PersistentClient(path="./chroma_langchain_db") #저장할 로컬 경로

# Chroma 컬렉션 생성

chroma_collection = client.get_or_create_collection(

name="clovastudiodatas_docs", #collection이 바뀔때마다 이름도 꼭 변경해줘야 합니다.

metadata={"hnsw:space": "cosine"} #사용하는 임베딩 모델에 따라 ‘l2’, 'ip', ‘cosine’ 중에 사용

)

# Chroma 벡터 저장소 생성

vectorstore = Chroma(

client=client,

collection_name="clovastudiodatas_docs",

embedding_function=clovax_embeddings

)

# tqdm으로 for 루프 감싸기

for doc in tqdm(documents, desc="Adding documents", total=len(documents)):

embeddings = clovax_embeddings.embed_documents([doc.page_content])[0]

# 문서 추가

chroma_collection.add(

ids=[str(uuid.uuid4())], # 고유한 ID 생성

documents=[doc.page_content],

embeddings=[embeddings],

metadatas=[doc.metadata]

)

time.sleep(1.1) # 이용량 제어를 고려한 1초 이상의 딜레이, 필요에 따라 조정 가능

print("All documents have been added to the vectorstore.")

#Output
Adding documents: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 108/108 [03:17<00:00,  2.46s/it]
All documents have been added to the vectorstore.

Quote

emb 모델을 사용하는 경우
필요에 따라 클로바 스튜디오의 임베딩 모델 중 clir-emb-dolphin 을 사용하고자 하는 경우, 모델에 적합한 거리 지표인 IP(내적)을 사용하기 위해 Chroma 컬렉션 생성 시 설정 역시 'ip'로 변경이 필요하며, 랭체인 연동을 위해 정규화된(normalized) 임베딩 결과를 얻기 위해 아래와 같이 추가적인 조치가 필요합니다.

clir-emb-dolphin모델을 사용하는 경우 전체코드

from langchain_community.embeddings import ClovaXEmbeddings

from langchain_chroma import Chroma

client = chromadb.PersistentClient(path="./chroma_langchain_db")

chroma_collection = client.get_or_create_collection(

    name="clovastudiodatas_rag_cosine",

    metadata={"hnsw:space": "ip"} # ip거리로 설정

)

# IP거리를 사용하는 모델(clir-emb-dolphin)의 임베딩 결과 정규화 필요

import numpy as np

class NormalizedClovaXEmbeddings(ClovaXEmbeddings) :

    def _embed_text(self, text: str) :

        # Call the parent class method to get the original embedding

        original_embeddings = super()._embed_text(text)



        # Postprocessing: apply normalization function to each element

        try:

            normalized_embeddings = list(original_embeddings/np.linalg.norm(original_embeddings))

        except:

            raise ValueError(f"normalization failed on text: {text}")

        return normalized_embeddings



    async def _aembed_text(self, text: str) :

        original_embeddings = await super()._aembed_text(text)



        try:

            normalized_embeddings = list(original_embeddings/np.linalg.norm(original_embeddings))

        except:

            raise ValueError(f"normalization failed on text: {text}")

        return normalized_embeddings

clova_embeddings = ClovaXEmbeddings(model="clir-emb-dolphin")

vectorstore = Chroma(

    client=client,

    collection_name="clovastudiodatas_rag_cosine", #collection이 바뀔때마다 이름도 꼭 변경해줘야 합니다.

    embedding_function=clova_embeddings

)

# tqdm으로 for 루프 감싸기

for doc in tqdm(documents, desc="Adding documents", total=len(documents)) :

    embeddings = clova_embeddings.embed_documents([doc.page_content])[0]

    # 문서 추가

    chroma_collection.add(

        ids=[str(uuid.uuid4())],

        documents=[doc.page_content],

        embeddings=[embeddings],

        metadatas=[doc.metadata]

    )

    time.sleep(1.4) # 이용량 제어를 고려한 1초 이상의 딜레이, 필요에 따라 조정 가능

print("All documents have been added to the vector store.")

1-2) FAISS 활용

Facebook AI Similarity Search (Faiss)는 밀집 벡터의 효율적인 유사도 검색과 클러스터링을 위한 라이브러리입니다. 본 예제에서는 FAISS를 활용해 vectorstore를 생성하고, 문서를 추가해보겠습니다. vectorstrore를 생성할 때, 임베딩 차원 크기를 1024차원으로 설정했습니다. 또한, 임베딩 클래스에 오류가 발생시 멈추게끔 하는 로직을 일부 추가해, 다량의 데이터를 처리할 때 오류 발생시 재실행의 부담을 줄였습니다. Langchain 공식 문서에서 FAISS 활용에 대한 더 자세한 내용을 확인 할 수 있습니다.

#FAISS 다운로드

%pip install -qU langchain-community faiss-cpu

import faiss

from langchain_community.vectorstores import FAISS

from langchain_community.docstore.in_memory import InMemoryDocstore

# 임베딩 모델 정의

clovax_embeddings = ClovaXEmbeddings(model='bge-m3')

# FAISS 벡터 저장소 생성

vectorstore_FAISS = FAISS(

embedding_function=clovax_embeddings,

index=faiss.IndexFlatIP(1024), # 임베딩 차원 크기

docstore=InMemoryDocstore(),

index_to_docstore_id={},

)

# tqdm으로 for 루프 감싸기

for doc in tqdm(documents, desc="Adding documents", total=len(documents)):

embeddings = clovax_embeddings.embed_documents([doc.page_content])[0]

# 문서 추가

vectorstore_FAISS.add_documents(

ids=[str(uuid.uuid4())], # 고유한 ID 생성

documents=[doc], # 문자열만 전달

embeddings=[embeddings]

)

time.sleep(1.4) # 이용량 제어를 고려한 1초 이상의 딜레이, 필요에 따라 조정 가능

print("All documents have been added to the vectorstore.")

#Output
Adding documents: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 108/108 [03:17<00:00,  2.46s/it]
All documents have been added to the vectorstore.

2) 다양한 파라미터를 활용해 Retriever 생성하기

검색기(Retriever) 단계는 저장된 벡터 DB에서 사용자의 질문과 관련된 문서를 검색하는 과정입니다. vectorstore.as_retriever()를 통해 검색기를 생성할 수 있습니다. 이 예제에서는 retriever 파라미터 설정을 통해 3개의 문서를 참고해 답변을 하도록 해보겠습니다.

retriever = vectorstore.as_retriever(kwargs={"k": 3})

만들고자 하는 RAG 시스템의 목적 및 활용에 맞게 아래의 1~4번의 항목의 다양한 파라미터를 사용해 커스텀해보세요. 파라미터를 다양하게 조절해가며 제품의 목적에 가장 적합한 답변을 하는 방식을 찾아나갈 수 있습니다.

2-1) 유사도 점수 임계값 설정

이 설정은 유사도 점수가 0.5 이상인 문서만 반환합니다. 이를 통해 질문과 관련성이 높은 문서만을 선택적으로 가져올 수 있습니다. 임계값을 높게 설정할수록 더 관련성 높은 문서만 반환되지만, 관련 정보를 놓칠 가능성도 있습니다. 반대로 임계값을 낮추면 더 많은 문서가 반환되지만, 관련성이 떨어지는 문서도 포함될 수 있습니다. Langchain 공식 문서에서 더 자세한 내용을 확인할 수 있습니다.

retriever = db.as_retriever(

# 검색 유형을 "유사도 점수 임계값"으로 설정합니다.

search_type="similarity_score_threshold",

# 검색 인자로 점수 임계값을 0.5로 지정합니다.

search_kwargs={"score_threshold": 0.5},

)

유사도 임계값은 0에서 1 사이의 값이어야 합니다. 이는 코사인 거리를 사용하는 `clir-sts-dolphin` 모델과 `bge-m3` 모델을 사용할 때 적합합니다.
IP(Inner Product) 거리를 사용하는 `clir-emb-dolphin` 임베딩 모델의 경우 유사도 점수 범위가 달라 앞서 작성된 코드를 사용해 정규화가 필요합니다.

2-2) 반환 문서 수 제한

이 설정은 상위 3개의 가장 관련성 높은 문서만 반환합니다. k 값을 낮게 설정하면 처리 속도가 빨라지고 가장 관련성 높은 문서에 집중할 수 있지만, 중요한 정보를 놓칠 수 있습니다. k 값을 높게 설정하면 더 많은 맥락을 제공할 수 있지만, 처리 시간이 길어지고 관련성이 낮은 정보가 포함될 수 있습니다.

search_kwargs의 k와 kwargs의 k의 차이

kwargs의 k 값의 의미는 검색기(retriever)가 답변 생성 최종적으로 참조하는 상위 문서의 개수를 의미합니다. 즉, 아래의 예제와 같이 '3'으로 설정한다면 검색하는 문서 중에서 유사도가 높은 상위 3개의 문서를 참조하여 답변을 생성합니다.
search_kwargs의 k 값의 의미는 검색하는 문서의 개수를 의미합니다. 이전의 kwargs의 k 값은 검색한 문서에서 답변을 할때 참조하는 상위 문서의 수 였다면 search_kwargs의 k는 검색하려는 문서의 개수를 의미합니다.

따라서 search_kwargs의 k값이 kwargs의 k 값보다 적은 수로 설정된다면, 검색하는 문서의 수가 답변 생성 시에 참조하는 문서의 개수보다 적은 개수로 설정된 것으로, search_kwargs의 k값의 수로 문서의 개수가 제한되어 답변됩니다. 예를 들어, search_kwargs의 k 값은 도서관에서 정보를 얻으려고 빌린 전체 책의 권 수가 되고, kwargs의 k 값은 빌린 책 전체에서 실제 정보를 얻은 책의 권수라고 이해할 수 있습니다.

2-3) MMR (Maximum Marginal Relevance) 검색

대부분의 검색 알고리즘은 문서와 쿼리 간의 유사도를 계산하여 가장 높은 점수를 가진 문서들을 순서대로 반환합니다. 이 경우, 내용이 매우 유사하거나 심지어 동일한 문서들이 연속해서 검색 결과에 나타날 수 있습니다.
이 문제점을 MMR(Maximal Marginal Relevance) 방식으로 해결할 수 있습니다. 쿼리에 대한 관련 항목을 검색할 때 검색된 문서의 중복을 피하기 위해 단순히 가장 관련성 높은 항목들만을 검색하는 대신, 이미 선택된 문서들과의 차별성도 고려해 문서를 반환합니다. 따라서, 정보 검색이나 추천 시스템처럼 검색 결과의 다양성이 중요하거나 중복된 정보를 줄이고 싶을 때 이 방식을 사용하면 좋습니다.

매개변수(parameters)

k: 이 매개변수는 최종적으로 반환할 문서의 총 개수입니다. (기본값: 4)
fetch_k: MMR 알고리즘을 수행할 때 고려할 초기 후보 문서 집합의 크기를 의미합니다. 광범위한 후보군에서 문서를 선택하면 좋을 때 이 값을 높입니다. 반대로, 빠른 응답 시간이 우선적이라면 이 값을 낮출 수 있습니다.(기본값: 20)
lambda_mult: 쿼리와의 유사성과 선택된 문서 간의 다양성 사이의 균형을 조절하는 변수입니다. 1에 가까울수록 쿼리와의 유사도 점수만 고려하고, 0에 가까워질수록 문서간의 다양성만 고려합니다. (0~1, 기본값: 0.5)

2-4) 메타 데이터 필터링

메타 데이터 필터를 이용하여 특정 키워드가 포함된 메타 데이터만 필터링할 수 있습니다. 앞서 document에 저장할 때, metadata의 title을 함께 저장했습니다. 이를 활용해 문서를 필터링해 가져올 수 있습니다.

# 메타데이터 필터링

filtered_retriever = db.as_retriever(

search_kwargs={"filter": {'title': 'CLOVA Studio 시나리오'}}

)

6. RAG 시스템 완성

1) LCEL을 사용해 Chain 구현하기

LCEL(LangChain Expression Language)은 랭체인에서 코드를 작성하는 새로운 방법입니다. 프롬프트와 LLM 모델을 정의해두고, | 기호로 각 요소를 연결해 한 구성 요소의 출력을 다음 구성 요소의 입력으로 전달할 수 있습니다. 이렇게 Chain을 생성해 복잡한 AI 시스템의 워크플로우를 보다 쉽고 직관적으로 구성할 수 있습니다.

1-1) 사용할 LLM 모델 정의
먼저, HyperCLOVA X 모델 (HCX-003) 을 랭체인 Chat model 컴포넌트의 ChatClovaX를 통해 불러와 정의합니다.

from langchain_community.chat_models import ChatClovaX

llm = ChatClovaX(

model="HCX-003",

)

1-2) Prompt 정의

PromptTemplate 사용하기
쿼리에 사용할 Prompt는 StringPromptTemplates 혹은 ChatPromptTemplates을 사용해 정의할 수 있습니다. Langchain 공식 문서에서 관련 내용을 확인해보세요.
PromptTemplate은 단일 문자열의 서식을 지정하는 데 사용되며, 일반적으로 간단한 입력에 사용되는 템플릿입니다. PromptTemplate은 Python의 문자열 포맷팅을 사용하여 동적으로 특정한 위치에 입력 값을 포함시킬 수 있어, 다양한 상황에 맞게 프롬프트를 구성할 수 있습니다. 아래 예제처럼 {question}, {context} 와 같은 사용자 입력 및 매개 변수를 언어 모델에 전달하게 할 수 있습니다.

from langchain_core.prompts import PromptTemplate

prompt1 = PromptTemplate.from_template(

"""당신은 질문-답변(Question-Answering)을 수행하는 친절한 AI 어시스턴트입니다. 당신의 임무는 원래 가지고있는 지식은 모두 배제하고, 주어진 문맥(context) 에서 주어진 질문(question) 에 답하는 것입니다.

검색된 다음 문맥(context) 을 사용하여 질문(question) 에 답하세요. 만약, 주어진 문맥(context) 에서 답을 찾을 수 없다면, 답을 모른다면 `주어진 정보에서 질문에 대한 정보를 찾을 수 없습니다` 라고 답하세요.

#Question:

{question}

#Context:

{context}

#Answer:"""

)

ChatPromptTemplate 사용하기
ChatPromptTemplate 은 대화목록을 프롬프트로 주입하고자 할 때 활용할 수 있습니다. 메시지는 튜플(tuple) 형식으로 구성하며, (role, message) 로 구성하여 리스트로 생성할 수 있습니다.

"system": 시스템 설정 메시지 입니다. 주로 전역설정과 관련된 프롬프트입니다.
"human" : 사용자 입력 메시지 입니다.
"ai": AI 의 답변 메시지입니다.

from langchain_core.prompts import ChatPromptTemplate

system_prompt = (

"""당신은 질문-답변(Question-Answering)을 수행하는 친절한 AI 어시스턴트입니다. 당신의 임무는 원래 가지고있는 지식은 모두 배제하고, 주어진 문맥(context) 에서 주어진 질문(question) 에 답하는 것입니다.

검색된 다음 문맥(context) 을 사용하여 질문(question) 에 답하세요. 만약, 주어진 문맥(context) 에서 답을 찾을 수 없다면, 답을 모른다면 `주어진 정보에서 질문에 대한 정보를 찾을 수 없습니다` 라고 답하세요.

"""

"\n\n"

"{context}"

)

prompt2 = ChatPromptTemplate.from_messages(

[

("system", system_prompt),

("human", "{question}"),

]

)

1-3) Chain 생성
앞서 정의한 LLM 모델과 prompt를 LCEL 표기법을 사용해 chain으로 연결합니다. 이때, Langchain의 StrOutputParser도 chain으로 연결해 모델의 출력을 문자열로 변환해보겠습니다. 아래 코드를 실행하면 연결된 chain이 연쇄적으로 실행됩니다. retriever를 통해 관련 문서를 context로 불러오고, context와 question이 프롬프트 템플릿으로 전달되고, llm 모델을 통해 프롬프트가 실행되고, StrOutputParser를 통해 답변만 파싱해 문자열로 출력합니다.

from langchain_core.runnables import RunnablePassthrough

from langchain_core.output_parsers import StrOutputParser

# 체인을 생성합니다.

rag_chain = (

{"context": retriever, "question": RunnablePassthrough()}

| prompt1

| llm

| StrOutputParser()

)

rag_chain.invoke("토큰이 뭔가요?")

#Output
토큰은 자연어 처리를 위해 하나의 단어를 세분화한 단어 조각을 의미합니다. 
예를 들어, '맛있어'라는 표현은 각각 '맛'과 '있어'라는 두 개의 토큰으로 나뉠 수 있습니다.
다른 예시로는 '원숭이 엉덩이는 빨개' 라는 문장은 '원숭이', '엉덩이는', '빨개' 와 같은 세 개의 토큰으로 나뉠 수 있습니다.

1-4) 참조 문서 링크와 함께 답변 출력하기
모델이 답변을 생성할 때 참조하는 문서의 출처를 확인하고 싶으시다면 아래의 코드를 참조하세요. RunnablePassthrough.assign()을 사용하여 검색 체인에서 소스 문서를 반환해 참조 문서 링크와 함께 답변을 출력해보겠습니다.

from pprint import pprint

from langchain_core.runnables import RunnablePassthrough

from langchain.schema.runnable import RunnableParallel

from langchain_core.output_parsers import StrOutputParser

# 쿼리 텍스트

query_text = "max_token을 몇으로 설정해야해?"

# 1. 쿼리 임베딩 생성

clovax_embeddings = ClovaXEmbeddings(model='bge-m3')

query_embedding = clovax_embeddings.embed_query(query_text)

# 2. Chroma 컬렉션에 쿼리 실행하여 유사한 문서 검색

results = chroma_collection.query(

query_embeddings=[query_embedding],

n_results=5,

include=["embeddings", "documents", "metadatas", "distances"]

)

# 3. 유사도 검색 결과를 사용하여 리트리버 구성

similarity_retriever = vectorstore.as_retriever(

kwargs={"k": 5},

search_type="similarity_score_threshold",

search_kwargs={"score_threshold": 0.1, "k": 3}

)

# 4. 검색된 문서를 RAG 체인에 연결하여 답변 생성

rag_chain_from_docs = (

RunnablePassthrough.assign(context=(lambda x: format_docs(x["context"])))

| prompt1

| llm

| StrOutputParser()

)

def format_docs(docs):

return "\n\n".join(doc.page_content for doc in docs)

rag_chain_with_source = RunnableParallel(

{"context": similarity_retriever, "question": RunnablePassthrough()}

).assign(answer=rag_chain_from_docs)

pprint(rag_chain_with_source)

Vector DB에 저장한 문서들과 관련있는 질문에 대해서는 모델이 아래와 같이 답변을 잘하는 것을 확인할 수 있습니다.

#Output
{'answer': '일반 모드에서 제공하는 언어 모델인 경우에는 최대 2048 토큰까지, 챗 모드에서 제공하는 HyperCLOVA X 언어 '
           '모델인 경우에는 최대 4096 토큰까지 허용됩니다. Maximum tokens는 300~500을 권장하며 작업에 따라 '
           '달라질 수 있습니다.',
 'context': [Document(metadata={'source': 'https://guide.ncloud-docs.com/docs/clovastudio-info'}, page_content='Maximum tokens Maximum tokens는 결괏값을 생성할 때 사용할 최대 토큰 수입니다. 토큰 수를 높게 설정할 수록 긴 결괏값을 출력합니다.'),
             Document(metadata={'source': 'clovastudioguide_0822/clovastudio-info.html'}, page_content='Maximum tokens Maximum tokens는 결괏값을 생성할 때 사용할 최대 토큰 수입니다. 토큰 수를 높게 설정할 수록 긴 결괏값을 출력합니다.'),
             Document(metadata={'source': 'clovastudioguide_0822/clovastudio-info.html'}, page_content='프롬프트와 결괏값을 포함하여 일반 모드에서 제공하는 언어 모델인 경우에는 최대 2048 토큰까지, 챗 모드에서 제공하는 HyperCLOVA X 언어 모델인 경우에는 최대 4096 토큰까지 허용됩니다. Maximum tokens는 300~500을 권장하며 작업에 따라 달라질 수 있습니다.')],
 'question': 'max_token을 몇으로 설정해야해?'}

위의 결과를 보다 보기 좋게 확인할 수 있습니다.

result = rag_chain_with_source.invoke(query_text)

model_answer=result['answer']

urls = {doc.metadata['source'] for doc in result['context']}

print("- 사용자 질문: {0}\n- 모델의 답변: {1}\n- 참조한 문서의 url: {2}".format(query_text, model_answer, list(urls)))

#Output
- 사용자 질문: max_token을 몇으로 설정해야해?
- 모델의 답변: 일반 모드에서 제공하는 언어 모델인 경우에는 최대 2048 토큰까지, 챗 모드에서 제공하는 HyperCLOVA X 언어 모델인 경우에는 최대 4096 토큰까지 허용됩니다. Maximum tokens는 300~500을 권장하며 작업에 따라 달라질 수 있습니다.
- 참조한 문서의 url: ['clovastudioguide_0822/clovastudio-info.html', 'https://guide.ncloud-docs.com/docs/clovastudio-info']

아래와 같이 문서와 관련 없는 질문에 대해선 정보를 찾을 수 없다고 답하는 것을 확인할 수 있습니다.

rag_chain_with_source.invoke("오늘 기분이 어때?")

#Output
{'context': [Document(metadata={'source': 'https://guide.ncloud-docs.com/docs/clovastudio-info'}, page_content='Temperature 값이 높은 경우'),
  Document(metadata={'source': 'https://guide.ncloud-docs.com/docs/clovastudio-info'}, page_content='Temperature 값이 높은 경우'),
  Document(metadata={'source': 'https://guide.ncloud-docs.com/docs/clovastudio-procedure'}, page_content='이 문서가 도움이 되었습니까?')],
 'question': '오늘 기분이 어때?',
 'answer': '주어진 정보에서 질문에 대한 정보를 찾을 수 없습니다.'}

2) Built in chain 활용

원하는 경우 LangChain에는 RAG 시스템을 위의 LCEL을 사용하지 않고 함수로도 구현할 수 있습니다.

create_stuff_documents_chain
검색된 컨텍스트가 프롬프트와 LLM에 공급되는 방법을 지정합니다. 이 경우 프롬프트에 문서의 요약이나 기타 처리 없이 검색된 모든 컨텍스트를 포함합니다. 이 함수를 통해 {input}과 {context}에 내용이 들어가게 됩니다.
입력 키: context, input
create_retrieval_chain
검색 단계를 추가하고 검색된 문서를 최종 답변과 함께 제공합니다.
입력 키: input 출력: input, context, answer

from langchain.chains import create_retrieval_chain

from langchain.chains.combine_documents import create_stuff_documents_chain

from langchain_core.prompts import ChatPromptTemplate

from langchain_community.chat_models import ChatClovaX

# chat모델 정의

llm = ChatClovaX(

model="HCX-003",

)

# ChatPromptTemplate 사용

system_prompt = (

"""당신은 질문-답변(Question-Answering)을 수행하는 친절한 AI 어시스턴트입니다. 당신의 임무는 원래 가지고있는 지식은 모두 배제하고, 주어진 문맥(context) 에서 주어진 질문(question) 에 답하는 것입니다.

검색된 다음 문맥(context) 을 사용하여 질문(question) 에 답하세요. 만약, 주어진 문맥(context) 에서 답을 찾을 수 없다면, 답을 모른다면 `주어진 정보에서 질문에 대한 정보를 찾을 수 없습니다` 라고 답하세요.

"""

"\n\n"

"{context}"

)

prompt2 = ChatPromptTemplate.from_messages(

[

("system", system_prompt),

("human", "{input}"),

]

)

# Built-in chains

question_answer_chain = create_stuff_documents_chain(llm, prompt2)

rag_chain = create_retrieval_chain(retriever, question_answer_chain)

result = rag_chain.invoke({"input": "토큰이 뭐야?"})

print(result)

#Output
{'input': '토큰이 뭐야?', 'context': [Document(page_content='토큰', metadata={'source': 'https://guide.ncloud-docs.com/docs/clovastudio-info'}), Document(page_content="<예시> '맛있어'라는 표현은 각각 '맛'과 있어'라는 두 개의 토큰으로 나뉠 수 있습니다.", metadata={'source': 'https://guide.ncloud-docs.com/docs/clovastudio-info'}), Document(page_content='Temperature를 낮게 설정하면 후보에 포함된 토큰의 순위는 바뀌지 않지만 확률이 높았던 토큰은 더욱 확률 값이 높아지고 낮았던 토큰은 확률 값이 더욱 낮아집니다. 가장 높은 순위의 토큰이 선택될 가능성이 크기 때문에 정형적인 결괏값을 생성합니다.', metadata={'source': 'https://guide.ncloud-docs.com/docs/clovastudio-info'})], 'answer': '토큰은 문장이나 단어를 구성하는 기본 단위로, 의미를 가지는 최소 단위입니다. 예를 들어, "맛있어"라는 표현은 각각 "맛"과 "있어"라는 두 개의 토큰으로 나뉠 수 있습니다. 또한 인공지능 분야에서는 자연어 처리나 기계학습에서 데이터를 분석하기 위해 토큰화(tokenization) 과정을 거칩니다. 이 때 각 단어나 기호 등을 토큰으로 분리하여 처리합니다.'}

위의 결과를 보다 보기 좋게 확인할 수 있습니다.

print("질문:")

print(result['input'])

print("\n답변:")

print(result['answer'])

print("\n참조 문서 URL:")

unique_urls = set(doc.metadata['source'] for doc in result['context'])

for url in unique_urls:

print(url)

#Output
질문:
토큰이 뭐야?
 
답변:
토큰은 문장이나 단어를 구성하는 기본 단위로, 의미를 가지는 최소 단위입니다. 예를 들어, "맛있어"라는 표현은 각각 "맛"과 "있어"라는 두 개의 토큰으로 나뉠 수 있습니다. 또한 인공지능 분야에서는 자연어 처리나 기계학습에서 데이터를 분석하기 위해 토큰화(tokenization) 과정을 거칩니다. 이 때 각 단어나 기호 등을 토큰으로 분리하여 처리합니다.
 
참조 문서 URL:
https://guide.ncloud-docs.com/docs/clovastudio-info

7. 맺음말

지금까지 NAVER Cloud Platform(NCP)에서 Langchain을 활용하여 RAG 시스템을 구현하는 방법을 살펴보았습니다. 이 가이드에서는 HCX 모델을 활용하여 간단한 RAG 파이프라인을 구축하는 과정을 다뤘습니다. 이 가이드는 RAG의 기본 구조와 흐름에 초점을 맞추었지만, RAG 기술은 계속 발전하고 있습니다. 앞으로 다양한 RAG 시스템 구현에 관한 더 깊이 있는 주제들을 다룰 예정입니다.

NCP 가이드: https://guide.ncloud-docs.com/docs/clovastudio-dev-langchain
LangChain 공식 문서: https://python.langchain.com/docs/integrations/providers/naver/

🦜🔗 랭체인(Langchain)으로 Naive RAG 구현하기 cookbook

Recommended Posts

CLOVA Studio 운영자

1. 사전 준비

1) Langchain 패키지 설치

2) 참조할 문서 (HTML 데이터) 준비

3) 코드에 공통적으로 들어가는 필요 모듈 import

4) 테스트앱 및 API키 미리 발급 받기

2. Load

1) txt → html 변환 및 원본 사이트 주소 mapping

2) LangChain 활용 HTML 로딩

3) Mapping 정보를 활용해 'source'를 실제 URL로 대체

3. Chunking

4. Embedding

1) LangChain을 통해 CLOVA Studio Embedding 활용하기

2) 리스트 형식의 documents로 만들기

5. Vector store

1) Vector DB에 저장하기

2) 다양한 파라미터를 활용해 Retriever 생성하기

6. RAG 시스템 완성

1) LCEL을 사용해 Chain 구현하기

2) Built in chain 활용

7. 맺음말

링크 복사

다른 사이트에 공유하기

게시글 및 댓글을 작성하려면 로그인 해주세요.

NAVER Cloud

Home