LangChain에서 document loader를 이용해 문서를 읽어들인 후 text splitter를 이용해 긴 문서를 chunk들로 나누었습니다. 그 다음엔 분할한 문서들로 요약이나 질의응답(QA)과 같은 LLM 작업을 수행해야겠죠? 문서를 이용해 LLM 작업을 수행하는 방법들에 대해 알아보겠습니다.

Stuff

먼저 Stuff 방법입니다. 이 방법은 분할할 필요가 없는 짧은 문서 전체를 프롬프트에 넣어 LLM에 전달하는 방법입니다. 간단하고 API를 한 번만 호출하면 되지만, 문서 길이가 길어지면 사용할 수 없는 방법입니다.

Refine

Refine 방법을 이용해 4개의 chunk로 나눠진 문서를 요약하는 과정을 생각해봅시다.

• 우선 1번 chunk를 요약합니다.
• 1번 요약에 2번 chunk를 더한 내용을 요약합니다.
• 1+2번 요약에 3번 chunk를 더한 내용을 요약합니다.
• 1+2+3번 요약에 4번 chunk를 더한 내용을 요약합니다. 이 내용이 최종 결과가 됩니다.

이 방법은 문서의 맥락을 유지하며 긴 문서를 요약할 수 있는 방법이지만, Stuff 방법에 비하면 API 호출 횟수가 많습니다. 또한 LLM을 순차적으로 호출해야 하므로 전체 작업 시간이 길어지게 됩니다.

Map Reduce

Map Reduce 방법을 이용해 4개의 chunk로 나눠진 문서를 요약하는 과정을 생각해봅시다.

• 1번부터 4번 chunk를 각각 요약합니다.
• 4개의 요약 내용을 합해서 다시 요약합니다. 이 내용이 최종 결과가 됩니다.

이 방법은 각 Chunk를 요약할 때 병렬로 요약할 수 있기 때문에 Refine 방법보다 빠르지만 Reduce 과정 포함하므로 API 호출 횟수가 더 많아집니다.

Map Re-rank

Map Re-rank 방법을 이용해 4개의 chunk로 나눈 문서에서 질문에 대한 답을 찾는 과정을 생각해봅시다.

• 1번부터 4번까지의 Chunk에서 각각 답을 찾습니다. 이 때 답에 대해 확신하는 정도를 점수로 나타냅니다.
• 확신 점수가 가장 높은 답을 결과로 채택합니다.

이 방법은 Map Reduce 방법에 비하면 API 호출 횟수가 적지만, 몇 개의 Chunk에 걸쳐 답에 관한 정보가 나눠져 있을 경우 이 정보들을 조합해서 답을 찾을 수는 없습니다.

Map Re-rank vs VectorDB

벡터 데이터베이스에서는 문서 Chunk들의 임베딩 벡터와 질문의 임베딩 벡터 사이의 코사인 거리를 이용해 질문과 의미가 가까운 내용을 찾았습니다. 이 방법도 일종의 점수를 매기는 방법이라고 할 수 있겠죠. 그럼 Map Re-rank와 벡터 임베딩을 이용하는 방법은 어떤 차이가 있을까요?

벡터 임베딩을 이용하는 경우에는 벡터 거리를 이용하므로 글의 의미가 질문과 얼마나 가까운지만 고려합니다. 반면에, Map Re-rank 방법은 의미 뿐 아니라 글의 품질과 같은 요소도 고려할 수 있습니다. 따라서 벡터 임베딩과 함께 사용하면 벡터 임베딩 기법을 보완할 수 있는 방법이라고 할 수 있습니다.

LangChain에서 Document loader로 읽어들인 문서의 텍스트를 적절한 길이의 chunk로 분할할 때Text splitter를 사용합니다. 지정한 문자들로 텍스트를 자르는 RecursiveCharacterTextSplitter에 이어 MarkdownHeaderTextSplitter에 대해 살펴보겠습니다.

MarkdownHeaderTextSplitter

MarkdownHeaderTextSplitter에서는 Markdown 파일에서 사용하는 #, ##, ### 등의 헤더를 기준으로 Markdown 텍스트를 분할합니다. 예제 코드를 보겠습니다.

간단한 마크다운 문자열이 있습니다.

md = """
# Title

## Chapter 1

### Sub1
content 1-1

### Sub2
content 1-2

## Chapter 2
content 2-0

## Chapter 3

### Sub1
content 3-1

### Sub2
content 3-2
"""

1단계 #, 2단계 ##, 3단계 ###까지 헤더를 사용한 문자열입니다. MarkdownHeaderTextSplitter로 분할해보겠습니다.

from langchain.text_splitter import MarkdownHeaderTextSplitter

headers_to_split_on = [
    ("#", "Header 1"),
    ("##", "Header 2"),
    ("###", "Header 3")
]

markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on = headers_to_split_on)
md_header_splits = markdown_splitter.split_text(md)
md_header_splits

## 출력
[Document(page_content='content 1-1', metadata={'Header 1': 'Title', 'Header 2': 'Chapter 1', 'Header 3': 'Sub1'}),
 Document(page_content='content 1-2', metadata={'Header 1': 'Title', 'Header 2': 'Chapter 1', 'Header 3': 'Sub2'}),
 Document(page_content='content 2-0', metadata={'Header 1': 'Title', 'Header 2': 'Chapter 2'}),
 Document(page_content='content 3-1', metadata={'Header 1': 'Title', 'Header 2': 'Chapter 3', 'Header 3': 'Sub1'}),
 Document(page_content='content 3-2', metadata={'Header 1': 'Title', 'Header 2': 'Chapter 3', 'Header 3': 'Sub2'})]

위에서 headers_to_split_on을 이용해 어떤 헤더(#, ##, ###)를 기준으로 분할할지, 분할한 헤더의 이름(Header 1, Header 2, Header 3)을 무엇으로 할지 지정해줍니다. 분할한 헤더의 이름은 결과로 나온 Document 객체의 metadata에 들어갑니다. 출력 결과를 보면 지정해준 1, 2, 3단계 헤더들을 기준으로 문서를 분할한 것을 알 수 있습니다.

이번엔 2단계 헤더까지만 사용해보겠습니다.

headers_to_split_on = [
    ("#", "Header 1"),
    ("##", "Header 2")
]

markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on = headers_to_split_on)
md_header_splits = markdown_splitter.split_text(md)
md_header_splits

## 출력
[Document(page_content='### Sub1\ncontent 1-1  \n### Sub2\ncontent 1-2', metadata={'Header 1': 'Title', 'Header 2': 'Chapter 1'}),
 Document(page_content='content 2-0', metadata={'Header 1': 'Title', 'Header 2': 'Chapter 2'}),
 Document(page_content='### Sub1\ncontent 3-1  \n### Sub2\ncontent 3-2', metadata={'Header 1': 'Title', 'Header 2': 'Chapter 3'})]

결과를 보면 2단계 헤더까지만 이용해 텍스트가 나눠지고, 3단계 헤더는 page_content에 들어가 있는 것을 확인할 수 있습니다.

앞에서 봤던 RecursiveCharacterTextSplitter 또는 다른 Text splitter와 달리, 길이를 기준으로 나누는 것이 아니라 헤더를 기준으로 나누기 때문에 길이가 매우 긴 Document가 나올 수 있습니다.

MarkdownHeaderTextSplitter와 유사한 Text splitter로 HTMLHeaderTextSplitter가 있습니다. HTMLHeaderTextSplitter는 HTML 헤더를 이용해 HTML 파일을 분할합니다.

LangChain에서 Document loader를 이용해 문서를 읽어들인 후 문서가 길면 LLM에서 소화할 수 있도록 chunk로 분할해야 합니다. 이런 작업을 해주는 클래스들이 langchain.text_splitter 모듈에 들어 있습니다. 해당 모듈에는 다양한 클래스들이 있고, 계속 추가되고 있습니다. 몇 가지만 적어보겠습니다.

Text Splitter

• CharacterTextSplitter: 특정 문자를 이용해 문자열을 나눕니다.
• RecursiveCharacterTextSplitter: 아래에서 자세히 살펴보겠습니다.
• MarkdownHeaderTextSplitter: 마크다운 파일의 헤더를 기준으로 나눕니다.
• HTMLHeaderTextSplitter: HTML 파일의 헤더를 기준으로 나눕니다.
• TokenTextSplitter: 토큰 수를 기준으로 나눕니다. OpenAI의 tiktoken을 이용합니다.

RecursiveCharacterTextSplitter

RecursiveCharacterTextSplitter는 지정한 chunk_size 이하가 되도록 문자열을 자르는데, 기본적으로 ["\n\n", "\n", " ", ""]와 같은 문자를 이용해 자릅니다. 순서대로 가장 먼저 “\n\n”으로 자르고, 그래도 chunk_size 보다 긴 chunk는 “\n”으로 자르고, 그래도 길면 ” “로 자르는 방식으로 chunk를 만듭니다. 단순히 글자수로 자르는 것에 비해 문단, 문장, 단어 등으로 자르기 때문에 글의 의미를 보존하는데 좋은 방법이라 할 수 있습니다.

구분 문자(separators)는 원하는 문자들의 리스트로 바꿀 수 있습니다. chunk_size를 계산하는 함수는 기본적으로 len인데, 토크나이저를 지정해서 토큰 수로 chunk_size를 계산할 수도 있습니다. 정규표현식을 이용해 나누는 것도 가능합니다.

예제를 살펴보겠습니다. 프로젝트 구텐베르그 사이트에서 명상록 텍스트 파일을 받아 파일로 저장했습니다.

import requests
url = "https://www.gutenberg.org/cache/epub/2680/pg2680.txt"
response = requests.get(url)

with open("Meditations_pg.txt",'wb') as fh:
    fh.write(response.content)

다음엔 Document loader 중 텍스트 파일을 읽는데 사용하는 TextLoader를 이용해 앞에서 쓴 텍스트 파일을 읽습니다.

from langchain.document_loaders import TextLoader

loader = TextLoader("Meditations_pg.txt")
data = loader.load()

data는 Document 자료형의 원소를 하나 가진 리스트입니다.

len(data[0].page_content) # 417445

길이가 길기 때문에 LLM에 그대로 입력으로 쓸 수는 없습니다. 분할해봅시다.

from langchain.text_splitter import RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size = 1000,
    chunk_overlap  = 50,
    length_function = len,
    is_separator_regex = False,
)
texts = text_splitter.split_documents(data)

한 chunk의 길이가 1000자 이내가 되도록 나눴습니다.

len(texts) # 595
type(texts) # list

texts[0]
## 결과
Document(page_content='\ufeffThe Project Gutenberg eBook of Meditations\n    \nThis ebook is for the use of anyone anywhere in the United States and\nmost other parts of the world at no cost and with almost no restrictions\nwhatsoever. You may copy it, give it away or re-use it under the terms\nof the Project Gutenberg License included with this ebook or online\nat www.gutenberg.org. If you are not located in the United States,\nyou will have to check the laws of the country where you are located\nbefore using this eBook.\n\nTitle: Meditations\n\n\nAuthor: Emperor of Rome Marcus Aurelius\n\nRelease date: June 1, 2001 [eBook #2680]\n                Most recently updated: March 9, 2021\n\nLanguage: English\n\n\n\n*** START OF THE PROJECT GUTENBERG EBOOK MEDITATIONS ***\n\n\n\nMEDITATIONS\n\nBy Marcus Aurelius\n\n\n\n\nCONTENTS\n\n\n     NOTES\n\n     INTRODUCTION\n\n     FIRST BOOK\n\n     SECOND BOOK\n\n     THIRD BOOK\n\n     FOURTH BOOK\n\n     FIFTH BOOK\n\n     SIXTH BOOK\n\n     SEVENTH BOOK\n\n     EIGHTH BOOK\n\n     NINTH BOOK\n\n     TENTH BOOK', metadata={'source': 'Meditations_pg.txt'})

이렇게 split_documents를 이용하면 Document로 구성된 리스트를 분할할 수 있습니다. 문자열로 구성된 리스트를 분할하고 싶다면 create_documents를, 그냥 문자열을 분할하고 싶다면 split_text 메소드를 이용하면 됩니다.

with open("Meditations_pg.txt",'r') as fh:
    txt = fh.read()
texts2 = text_splitter.create_documents([txt])

len(texts2) # 595
type(texts2) # list

texts2[10]
## 출력
Document(page_content='from him, and he was assassinated. Marcus now went to the east, and\nwhile there the murderers brought the head of Cassius to him; but the\nemperor indignantly refused their gift, nor would he admit the men to\nhis presence.')

create_documents의 결과도 Document 자료형의 리스트로 나오는 것을 볼 수 있습니다. 반면에, split_text를 이용해 문자열을 분할하면 그냥 문자열의 리스트가 나옵니다.

texts3 = text_splitter.split_text(txt)

len(texts3) # 595
type(texts3) # list

texts3[10]
## 출력
'from him, and he was assassinated. Marcus now went to the east, and\nwhile there the murderers brought the head of Cassius to him; but the\nemperor indignantly refused their gift, nor would he admit the men to\nhis presence.'

LangChain의 Chain에는 몇 가지 종류가 있습니다. 앞에서 PromptTemplate, LLM, OutputParser를 연결한 LLMChain과 LLMChain에 Memory를 추가해 대화가 가능한 ConversationChain을 살펴봤습니다. (사실 LLMChain에서 ChatModels를 사용하고 Memory를 할당하면 ConversationChain과 유사합니다.)

이번에는 LLMChain들을 간단하게 연결할 수 있는 SimpleSequentialChain을 살펴보겠습니다. 아래 그림처럼 단순하게 이전 Chain의 출력을 다음 Chain의 입력으로 연결해주는 Chain입니다.

코드를 봅시다.

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import LLMChain
from langchain.chains import SimpleSequentialChain

llm = ChatOpenAI(temperature=0.9)

prompt1 = ChatPromptTemplate.from_template(
    "{area} 분야에서 역사적으로 가장 중요한 사람은?"
)

prompt2 = ChatPromptTemplate.from_template(
    "{name}: 이 사람이 속했던 기관은?"
)

prompt3 = ChatPromptTemplate.from_template(
    "{org}: 이 기관의 주요 업적은?"
)

세 개의 Chain을 만들고 연결하기 위해 세 개의 PromptTemplate를 만들었습니다. 각각의 Chain은 위의 LLM과 PromptTemplate을 연결해 만들겠습니다.

chains = []
for prompt in [prompt1, prompt2, prompt3]:
    chains.append(LLMChain(llm=llm, prompt=prompt))

이렇게 Chain들의 리스트를 만들었습니다. SimpleSequentialChain은 이 리스트를 이용해 만듭니다.

simple_chain = SimpleSequentialChain(chains=chains, verbose=True)
simple_chain.run("중력 이론")

위에서 verbose는 중간 과정도 출력하기 위해 True로 넣었습니다. verbose=False로 놓으면(기본값) 최종 응답만 출력됩니다. 출력된 내용은 다음과 같습니다.

> Entering new SimpleSequentialChain chain...

### 첫 번째 Chain의 결과
중력 이론 분야에서 역사적으로 가장 중요한 사람은 아이작 뉴턴(Isaac Newton)입니다. 뉴턴은 17세기에 중력 이론을 개발하였으며, 그의 "형성력학"은 현대 물리학의 기초를 세우는 데 큰 영향을 주었습니다. 뉴턴의 중력 이론은 이후 약 200년 동안 가장 효과적이고 정확한 설명이었으며, 그의 업적은 고전 물리학의 기초와 현대 과학의 발전에 큰 영감을 주었습니다.

### 두 번째 Chain의 결과
아이작 뉴턴은 케임브리지 대학교에서 교수로 활동하였습니다.

### 세 번째 Chain의 결과
아이작 뉴턴은 케임브리지 대학교에서 교수로 활동하였으며, 그의 주요 업적은 다음과 같습니다:

1. 만유인력의 법칙과 중력: 뉴턴은 중력의 법칙을 제시하고 지구의 운동을 설명하는 뉴턴의 운동 법칙을 개발했습니다. 그는 또한 만유인력의 법칙을 제시하여 물체 간의 인력을 설명하였습니다.

2. 광학: 뉴턴은 광학 연구를 수행하여 "광방사"와 "광굴절"의 원리를 밝혀내었습니다. 그는 빛이 다양한 색상으로 구성되어 있다는 것을 발견하였고, 이는 후에 뉴턴의 색채 이론으로 알려지게 되었습니다.

3. 미적분학: 뉴턴은 미적분학의 기초를 개발하였습니다. 그의 연구는 운동, 탄성, 적분 등 다양한 수학적 문제들을 해결하는데 사용되었으며, 이는 현대 과학 및 공학의 핵심 개념 중 하나가 되었습니다.

4. 역학: 뉴턴의 연구는 역학의 발전에 큰 기여를 했습니다. 그는 뉴턴의 운동 법칙을 통해 물리학적 시스템의 움직임과 운동을 설명하였으며, 이를 통해 천문학, 공학, 물리학 등에서 다양한 응용분야에 사용되었습니다.

이러한 업적들은 뉴턴을 현대 과학의 선구자 중 한 명으로 여기게 되었으며, 그의 연구는 현대과학의 기반을 다지는 데 큰 역할을 한 것으로 평가되고 있습니다.

결과를 보면 질문에 대한 답만 말한 것이 아니라 부연 설명이 들어가 있습니다. 최종 응답에서는 기관의 업적이 아니라 뉴턴의 업적이 결과로 나왔네요. OutputParser를 추가하면 첫 번째 응답은 “뉴턴”, 두 번째 응답은 “케임브리지 대학교”로 만들어 세 번째에 기관의 업적이 나오도록 만들 수 있을겁니다. 해봅시다.

from langchain.output_parsers import ResponseSchema
from langchain.output_parsers import StructuredOutputParser

schema = ResponseSchema(name='name', description="json object: key=name, value=person's name")
response_schemas = [schema]
output_parser1 = StructuredOutputParser.from_response_schemas(response_schemas)

schema = ResponseSchema(name='org', description="json object: key=org, value=organization's name")
response_schemas = [schema]
output_parser2 = StructuredOutputParser.from_response_schemas(response_schemas)

첫 번째와 두 번째 LLM 출력을 위한 OutputParser들을 만들었습니다.

prompt1 = ChatPromptTemplate.from_template(
    "{area} 분야에서 역사적으로 가장 중요한 사람은?\n{format_instructions}",
    partial_variables={"format_instructions":output_parser1.get_format_instructions()}
)

prompt2 = ChatPromptTemplate.from_template(
    "{name}: 이 사람이 속했던 기관은?\n{format_instructions}",
        partial_variables={"format_instructions":output_parser2.get_format_instructions()}
)

prompt3 = ChatPromptTemplate.from_template(
    "{org}: 이 기관의 주요 업적은?"
)

첫 번째와 두 번째 프롬프트에 OutputParser의 format_instructions를 추가했습니다.

new_chains=[]
new_chains.append(LLMChain(llm=llm, prompt=prompt1, output_parser=output_parser1))
new_chains.append(LLMChain(llm=llm, prompt=prompt2, output_parser=output_parser2))
new_chains.append(LLMChain(llm=llm, prompt=prompt3))

new_simple_chain = SimpleSequentialChain(chains=new_chains, verbose=True)

new_simple_chain.run("중력 이론")

OutputParser를 추가한 LLMChain들을 이용해 SimpleSequentialChain을 만들고 실행했습니다. 결과를 보겠습니다.

> Entering new SimpleSequentialChain chain...

### 첫 번째 Chain의 결과
{'name': '아이작 뉴턴'}

### 두 번째 Chain의 결과
{'org': '옥스퍼드 대학교'}

### 세 번째 Chain의 결과
옥스퍼드 대학교는 많은 주요 업적을 가지고 있습니다. 이 중 일부는 다음과 같습니다:

1. 학문적 우수성: 옥스퍼드 대학교는 국제적으로 인정받는 세계적인 연구 및 교육 기관으로, 학문적 우수성과 혁신적인 연구로 유명합니다. 이는 다양한 분야에서 많은 세계적인 수상을 받았음을 증명하고 있습니다.

2. 역사적인 유산: 옥스퍼드 대학교는 12세기에 설립되어 역사적인 유산을 가지고 있습니다. 옥스퍼드의 대학 조직 구조는 근대 대학의 모델로 사용되었으며, 다른 대학들에 큰 영향을 미쳤습니다.

3. 알럼니 네트워크: 옥스퍼드 대학교는 강력하고 영향력 있는 알럼니 네트워크를 가지고 있습니다. 많은 옥스퍼드 졸업생들이 세계적으로 성공한 사업가, 정치인, 문화인으로 알려져 있습니다.

4. 문화적 영향력: 옥스퍼드 대학교는 창의적이고 혁신적인 사고 방식을 장려하며, 학문의 자유를 존중합니다. 이러한 문화적인 영향력이 전 세계에서 영향을 미치고 있으며, 다양한 분야에서 지식과 이해를 증진시키는 역할을 합니다.

5. 국제 협력: 옥스퍼드 대학교는 다양한 국제 협력 프로그램을 통해 세계의 다른 연구기관과 협력하고 있습니다. 이를 통해 옥스퍼드는 국제적인 역량을 키우고, 글로벌 문제에 대한 해결책을 모색하는 데 기여하고 있습니다.

첫 번째와 두 번째 Chain에서 원하는 출력 형식을 얻었으나, 두 번째 응답의 결과가 잘못 되었네요. 케임브리지 대학이 맞습니다. 이렇게 틀린 응답을 할 때가 종종 있으니 결과를 확인해볼 필요가 있습니다. 정확도가 중요할 때는 Retrieval Augmented Generation과 같은 방법을 쓰는게 좋겠죠.

LangChain에는 LLM과 대화시 대화 내용을 저장하기 위한 Memory 기능이 있습니다. OpenAI API와 같은 REST API는 상태를 저장하지 않습니다(stateless). 따라서 API 실행시 이전 대화 내용을 전달하지 않고 새로운 메시지만 던지면 처음 받는 질문으로 판단하고 대답하게 됩니다. 대화를 이어가기 위해서는 지난 대화 내용을 프롬프트에 포함해 전달하면서 새로운 메시지를 추가해야 합니다. 지난 대화 내용을 저장할 때 사용하는 것이 바로 Memory입니다.

그런데, 대화가 길어지면 문제가 생깁니다. API를 통해 한 번에 입출력할 수 있는 토큰 수가 정해져 있죠. 지난 대화가 길면 토큰 수를 넘어가서 답변을 듣지 못하게 됩니다. 물론 API 사용료도 더 많이 나가죠. 그래서 LangChain의 Memory 중에는 지난 대화 내용을 줄이는 Memory도 있습니다. 기본적인 메모리들을 몇 가지 살펴보겠습니다.

• ConversationBufferMemory
• ConversationBufferWindowMemory
• ConversationTokenBufferMemory
• ConversationSummaryBufferMemory

ConversationBufferMemory

ConversationBufferMemory는 지난 대화 내용을 그대로 저장하는 메모리입니다.

from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

llm = ChatOpenAI(temperature=0.0)

memory = ConversationBufferMemory()

conversation = ConversationChain(
    llm=llm, 
    memory = memory
)
conversation.predict(input="안녕, 나는 토니 스타크라고 해.")

### 결과(응답)
'안녕, 토니 스타크! 반가워요. 저는 OpenAI의 인공지능입니다. 무엇을 도와드릴까요?'

코드에서 사용한 ConversationChain은 한 번 응답을 받는 LLMChain과 달리 여러 번 대화를 주고 받을 때 사용하는 Chain입니다. Chain을 생성할 때 memory 인자에 LangChain의 Memory 객체를 입력하는 방식으로 Memory를 사용합니다. Chain 내부에서는 사용자가 input 메시지를 입력하면 메모리에 메시지를 추가한 후 LLM에 전달하고, LLM이 응답하면 메모리에 응답을 추가한 후 사용자에게 응답을 반환합니다. 대화를 이어나가겠습니다.

conversation.predict(input="내 인공지능 비서 이름이 뭐지?")
# 응답: '당신의 인공지능 비서의 이름은 "지니"입니다. 어떤 일을 도와드릴까요?'
conversation.predict(input="내 이름이 뭐였지?")
# 응답: '당신의 이름은 "토니 스타크"입니다.'

이렇게 이전 대화 내용을 기억하며 대화를 이어나갈 수 있습니다. 메모리에 저장된 내용은 다음과 같이 확인할 수 있습니다.

print(memory.buffer)

### 결과
Human: 안녕, 나는 토니 스타크라고 해.
AI: 안녕, 토니 스타크! 반가워요. 저는 OpenAI의 인공지능입니다. 무엇을 도와드릴까요?
Human: 내 인공지능 비서 이름이 뭐지?
AI: 당신의 인공지능 비서의 이름은 "지니"입니다. 어떤 일을 도와드릴까요?
Human: 내 이름이 뭐였지?
AI: 당신의 이름은 "토니 스타크"입니다.

load_memory_variables를 이용할 수도 있습니다.

memory.load_memory_variables({})

### 결과
{'history': 'Human: 안녕, 나는 토니 스타크라고 해.\nAI: 안녕, 토니 스타크! 반가워요. 저는 OpenAI의 인공지능입니다. 무엇을 도와드릴까요?\nHuman: 내 인공지능 비서 이름이 뭐지?\nAI: 당신의 인공지능 비서의 이름은 "지니"입니다. 어떤 일을 도와드릴까요?\nHuman: 내 이름이 뭐였지?\nAI: 당신의 이름은 "토니 스타크"입니다.'}

save_context를 이용해 메모리에 직접 내용을 추가할 수도 있습니다.

memory = ConversationBufferMemory()
memory.save_context({"input": "안녕, 나는 토니 스타크라고 해."}, 
                    {"output": "안녕하세요, 토니 스타크님! 반갑습니다."})
print(memory.buffer)

### 결과
Human: 안녕, 나는 토니 스타크라고 해.
AI: 안녕하세요, 토니 스타크님! 반갑습니다.

더 추가해볼까요?

memory.save_context({"input": "내 비서 이름이 뭐지?"}, 
                    {"output": "JARVIS입니다."})
memory.load_memory_variables({})

### 결과
{'history': 'Human: 안녕, 나는 토니 스타크라고 해.\nAI: 안녕하세요, 토니 스타크님! 반갑습니다.\nHuman: 내 비서 이름이 뭐지?\nAI: JARVIS입니다.'}

ConversationBufferWindowMemory

ConversationBufferWindowMemory는 윈도우 크기 k를 지정하면 최근 k개의 대화만 기억하고 이전 대화는 삭제합니다. 여기서 1개의 대화는 한 번 주고 받는 대화를 말합니다.

from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(k=1) 
memory.save_context({"input": "안녕, 나는 토니 스타크라고 해."},
                    {"output": "안녕하세요, 토니 스타크님! 반갑습니다."})
memory.save_context({"input": "내 비서 이름이 뭐지?"},
                    {"output": "JARVIS입니다."})
memory.load_memory_variables({})

### 결과
{'history': 'Human: 내 비서 이름이 뭐지?\nAI: JARVIS입니다.'}

k=1로 했더니 마지막 대화만 기억하고 그 앞의 대화는 잊어버렸습니다.

memory = ConversationBufferWindowMemory(k=1)
conversation = ConversationChain(
    llm=llm, 
    memory = memory
)
conversation.predict(input="안녕, 나는 토니 스타크라고 해.")
# 응답: '안녕, 토니 스타크! 반가워요. 저는 OpenAI의 인공지능입니다. 무엇을 도와드릴까요?'
conversation.predict(input="내 인공지능 비서 이름은 뭐지?")
# 응답: '당신의 인공지능 비서의 이름은 "제이비"입니다.'
conversation.predict(input="내 이름이 뭐라고?")
# 응답: '죄송합니다, 저는 당신의 이름을 알 수 없습니다.'

이전 대화를 잊어버렸으니 이전 대화에 있던 정보를 물으면 답할 수가 없습니다. 보통 대화에서는 k=1보다 큰 값을 사용합니다.

ConversationTokenBufferMemory

ConversationTokenBufferMemory는 기억되는 토큰 수를 제한합니다. 최대 토큰 수를 넘지 않는 범위에서 최근 대화들을 기억합니다.

from langchain.memory import ConversationTokenBufferMemory
memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=50)
memory.save_context({"input": "안녕, 나는 토니 스타크라고 해."},
                    {"output": "안녕, 토니 스타크! 반가워요. 저는 OpenAI의 인공지능입니다. 무엇을 도와드릴까요?"})
memory.save_context({"input": "내 인공지능 비서 이름은 뭐지?"},
                    {"output": "당신의 인공지능 비서의 이름은 JARVIS입니다."})
memory.save_context({"input": "내 이름이 뭐라고?"}, 
                    {"output": "당신의 이름은 '토니 스타크'입니다."})
memory.load_memory_variables({})

### 결과
{'history': "Human: 내 이름이 뭐라고?\nAI: 당신의 이름은 '토니 스타크'입니다."}

최대 토큰 수를 50으로 작게 잡았기 때문에 마지막 대화밖에 안 남았습니다.

ConversationSummaryBufferMemory

ConversationSummaryMemory는 이전 대화 내용 그대로 기억하지 않고 요약해서 기억합니다. 요약은 LLM이 하기 때문에 Memory 생성시 LLM을 지정해줍니다. ConversationSummaryBufferMemory는 ConversationSummaryMemory의 확장판이라고 볼 수 있습니다. 이전 대화를 요약해 기억하면서 최근 대화는 최대 토큰 범위 내에서 유지합니다. 이를 위해 최대 토큰 길이도 지정해줍니다. 코드에서는 ConversationSummaryBufferMemory를 사용하겠습니다.

from langchain.memory import ConversationSummaryBufferMemory

schedule = "내일 아침 8시에는 퓨리랑 미팅이 있습니다. \
어벤져스와 가디언즈 오브 갤럭시 팀의 관계에 대해 상의할 예정입니다. \
12시에는 페퍼와 점심식사가 있습니다. 치즈버거를 먹기로 했습니다. \
3시에는 해피와 스파이더맨 교육 계획 회의가 있습니다 \
5시에는 아크 원자로 개선 버전 공개 행사가 있습니다. \
간단한 소개 자료를 준비해 놓았습니다."

memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100)
memory.save_context({"input": "자비스"}, {"output": "네, 말씀하세요."})
memory.save_context({"input": "자기 전에 확인할게 있어."},
                    {"output": "무엇을 확인해드릴까요?"})
memory.save_context({"input": "내일 일정에 대해 알려줘."}, 
                    {"output": f"{schedule}"})
memory.load_memory_variables({})

### 결과
{'history': 'System: The human asks the AI to check something before they go to bed. The AI asks what they would like to check. The human asks the AI to inform them about their schedule for tomorrow. The AI informs the human that they have a meeting with Fury at 8 am to discuss the relationship between the Avengers and the Guardians of the Galaxy teams. At 12 pm, they have a lunch with Pepper, where they will be having a cheeseburger. At 3 pm, they have a meeting with Happy and Spiderman to discuss educational plans. At 5 pm, there is a public event for the unveiling of an improved version of the Arc Reactor, and the AI has prepared a brief introduction material.'}

대화 내용을 요약해서 기억하는 것을 볼 수 있습니다. 대화를 이어가면 메모리 내용이 어떻게 달라지는가 봅시다.

conversation = ConversationChain(
    llm=llm, 
    memory = memory,
    verbose=True
)
conversation.predict(input="행사 전 4시에 닥터 스트레인지와 약속을 추가해줘.")
# 응답: '행사 전 4시에 닥터 스트레인지와 약속을 추가했습니다.'
memory.load_memory_variables({})

### 결과
{'history': 'System: The human asks the AI to check something before they go to bed. The AI asks what they would like to check. The human asks the AI to inform them about their schedule for tomorrow. The AI informs the human that they have a meeting with Fury at 8 am to discuss the relationship between the Avengers and the Guardians of the Galaxy teams. At 12 pm, they have a lunch with Pepper, where they will be having a cheeseburger. At 3 pm, they have a meeting with Happy and Spiderman to discuss educational plans. At 5 pm, there is a public event for the unveiling of an improved version of the Arc Reactor, and the AI has prepared a brief introduction material.\nHuman: 행사 전 4시에 닥터 스트레인지와 약속을 추가해줘.\nAI: 행사 전 4시에 닥터 스트레인지와 약속을 추가했습니다.'}

앞의 내용은 요약되어 있지만 최근 대화는 그대로 들어가 있습니다. 대화를 더 이어가봅시다.

conversation.predict(input="내일 행사 참석 인원은 100명 정도야.")
# 응답: '내일 행사에는 약 100명 정도의 참석자가 있을 것으로 예상됩니다.'
memory.load_memory_variables({})

### 결과
{'history': 'System: The human asks the AI to check something before they go to bed. The AI asks what they would like to check. The human asks the AI to inform them about their schedule for tomorrow. The AI informs the human that they have a meeting with Fury at 8 am to discuss the relationship between the Avengers and the Guardians of the Galaxy teams. At 12 pm, they have a lunch with Pepper, where they will be having a cheeseburger. At 3 pm, they have a meeting with Happy and Spiderman to discuss educational plans. At 5 pm, there is a public event for the unveiling of an improved version of the Arc Reactor, and the AI has prepared a brief introduction material. The human requests to add a meeting with Doctor Strange at 4 pm before the event.\nAI: 행사 전 4시에 닥터 스트레인지와 약속을 추가했습니다.\nHuman: 내일 행사 참석 인원은 100명 정도야.\nAI: 내일 행사에는 약 100명 정도의 참석자가 있을 것으로 예상됩니다.'}

앞에서 그대로 들어가 있던 대화의 일부가 요약에 포함된 것을 볼 수 있습니다.

conversation.predict(input="내일 원자로 소개할 때 뭐라고 시작할까?")
# 응답
'내일 원자로 소개할 때, "안녕하세요 여러분, 오늘 저희는 개선된 아크 리액터의 공개 행사에 참석하게 되어 매우 기쁩니다. 이번 개발은 이전 버전에 비해 더욱 효율적이고 안전한 에너지 공급을 제공합니다. 이 아크 리액터는 우리의 노력과 협력으로 만들어진 결과물이며, 앞으로의 미래에 대한 희망과 발전을 상징합니다. 이제부터 자세한 소개를 시작하도록 하겠습니다."라고 시작하시면 좋을 것 같습니다.'

마지막 대화가 길었습니다. 토큰 수 제한이 있기 때문에 마지막에 주고 받은 대화가 길어지면 다음과 같이 마지막 대화까지 요약에 포함될 수도 있습니다.

memory.load_memory_variables({})

### 결과
{'history': 'System: The human asks the AI to check their schedule for tomorrow. The AI informs the human that they have a meeting with Fury at 8 am, a lunch with Pepper at 12 pm, a meeting with Happy and Spiderman at 3 pm, and a public event for the unveiling of an improved version of the Arc Reactor at 5 pm. The human requests to add a meeting with Doctor Strange at 4 pm before the event. The AI adds the meeting to the schedule. The human mentions that there will be around 100 attendees at the event. The AI estimates that there will be about 100 attendees. The human asks for suggestions on how to start the introduction for the Arc Reactor unveiling. The AI suggests starting with "Hello everyone, we are delighted to have you all here today for the unveiling of the improved Arc Reactor. This development provides more efficient and safe energy supply compared to the previous version. It is a result of our efforts and collaboration, symbolizing hope and progress for the future. Now, let\'s begin with a detailed introduction."'}

이전 대화 내용을 요약하는 메모리의 경우 요약을 위해 내부적으로 LLM 호출이 추가된다는 점을 기억합시다.

(추가) OpenAI Thread

2023년 11월 6일 OpenAI에서 새로운 API들을 발표했습니다. 그중 Assistants API의 Thread가 있는데, Thread에 Message를 추가하면 OpenAI 서버에 대화 내용을 저장해주고, 프롬프트에 이전 대화 내용을 넣는 과정도 알아서 진행해줍니다. 참고: OpenAI Assistants API로 대화 내용 저장하기