LangChain for LLM App Development

#DeepLearning.AI #Review

이 컨텐츠는 DeepLearning.AI 의 ShortCourse 중 하나인 LangChain for LLM Application Development 내용을 정리한 것 입니다.

LangChain

• LangChain 은 LLM 어플리케이션 개발을 위한 오픈소스 프레임워크 입니다

• LangChain 은 2가지 언어를 위한 프레임워크를 지원합니다

  • Python

  • JavaScript (TypeScript)

LangChain overview - Docs by LangChainDocs by LangChain

LangChain 은 다음 5가지의 컴포넌트들로 구성되어 있습니다.

Models

• Large Language Models

• Chat Models

• Text Embedding Models

Prompts

• Prompt Templates

• Output Parsers

• Example Selectors

Indexes

• Document Loaders

• Text Splitters

• Vector Stores

• Retrievers

Chains

• Prompt + LLM + Output Parser

• Application Specific Chains

Agents

• Agent Types

• Agent Toolkits

Models, Prompts and Output Parsers

• Model 은 LLM API 와 쉽고 편리하게 연결하기 위한 장치 (예를 들어, OpenAI Chat API 전용 클래스)

from langchain.chat_models import ChatOpenAI

# To control the randomness and creativity of the generated
# text by an LLM, use temperature = 0.0
chat = ChatOpenAI(temperature=0.0)

• Prompt 는 자주 사용하는 Prompting 포맷을 코드 내 객체로 관리할 수 있도록 도와주며, 자주 사용하는 일반적인 Prompt 들을 LangChain 에서 제공합니다

from langchain.prompts import ChatPromptTemplate

# 템플릿 구조를 잡기 위한 문자열 데이터
template_string = """Translate the text \
that is delimited by triple backticks \
into a style that is {style}. \
text: ```{text}```
"""

# 템플릿 내 컨텐츠를 위한 문자열 데이터 (1)
customer_style = """American English \
in a calm and respectful tone
"""

# 템플릿 내 컨텐츠를 위한 문자열 데이터 (2)
customer_email = """
Arrr, I be fuming that me blender lid \
flew off and splattered me kitchen walls \
with smoothie! And to make matters worse, \
the warranty don't cover the cost of \
cleaning up me kitchen. I need yer help \
right now, matey!
"""

# 템플릿 구조를 인식하고
prompt_template = ChatPromptTemplate.from_template(template_string)

# 템플릿 내 컨텐츠를 작성하는 것을 도와줍니다
customer_messages = prompt_template.format_messages(
                    style=customer_style,
                    text=customer_email)

• Output Parser 가 필요한 이유는 LLM 에게 특정 형식의 반환값을 요청하더라도, 실제로 돌아오는 데이터는 string 이므로 프로그래밍 코드 내 자료구조로 변환하는 parsing 작업이 필요합니다

• LangChain 에서 Output Parser 관련 코드 중에는 Prompt 를 작성할 때 Output 포맷에 대해 설명하는 것을 도와주는 도구들이 존재합니다

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

# LLM 에게 명령 전달 시 어떤 출력 데이터가 필요한지 설명해야하며, 
# 이를 돕기 위하여 ResponseScheme 클래스를 제공

# Gift 에 대한 응답은 True, Fals 로 전달되어야 하며, 
# 어떤 경우에 True 이고, 어떤 경우에 False 인지 소개하고 있음
gift_schema = ResponseSchema(name="gift",
                             description="Was the item purchased \
                             as a gift for someone else? \
                             Answer True if yes,\
                             False if not or unknown.")

# 마찬가지로 delivery_days 응답에 대한 설명과 응답 데이터 형식을 알려줌
delivery_days_schema = ResponseSchema(name="delivery_days",
                                      description="How many days\
                                      did it take for the product\
                                      to arrive? If this \
                                      information is not found,\
                                      output -1.")

# price_value 응답에 대한 설명과 데이터 형
price_value_schema = ResponseSchema(name="price_value",
                                    description="Extract any\
                                    sentences about the value or \
                                    price, and output them as a \
                                    comma separated Python list.")

# 필요한 모든 응답을 모아서
response_schemas = [gift_schema, 
                    delivery_days_schema,
                    price_value_schema]

# StructuredOutputParser 클래스를 사용하여 구조화된 출력을 만들도록 프롬프팅을 작성함
# 아마 내부적으로 JSON 출력을 요청하며, 각 key-value 값에 위의 형식들을 사용할 것으로 보임
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)

# 프롬프트에 들어가기 위한 출력 데이터 포맷 지시사항
format_instructions = output_parser.get_format_instructions()

# 아래 2개의 컨텐츠 {text} 와 {format_instructions}
review_template_2 = """\
For the following text, extract the following information:

gift: Was the item purchased as a gift for someone else? \
Answer True if yes, False if not or unknown.

delivery_days: How many days did it take for the product\
to arrive? If this information is not found, output -1.

price_value: Extract any sentences about the value or price,\
and output them as a comma separated Python list.

text: {text}

{format_instructions}
"""

# 프롬프트 객체를 작성
prompt = ChatPromptTemplate.from_template(template=review_template_2)

# 프롬프트 내 컨텐츠를 채워넣음
messages = prompt.format_messages(text=customer_review, 
                                format_instructions=format_instructions)

# 모델에게 메시지를 전달하면, 모델은 응답을 받아옵니다      
response = chat(messages)

# JSON 형식으로 구성된 문자열 응답 데이터를 output parser 를 사용하여
# Python Dictionary 자료형으로 변환합니다
output_dict = output_parser.parse(response.content)

LangChain: Memory

대형 언어 모델(LLM)을 사용할 때 주의해야할 점은 LLM은 'stateless' 하다는 것 입니다. LLM과의 모든 transaction은 독립적이라고 볼 수 있습니다. OpenAI LLM API를 사용하여 챗봇을 만든다고 가정해 봅시다. LLM에게 이전 대화를 알려주는 방법은 다음 질문을 던질때 이전 대화의 기록(history)을 함께 전달하는 것 입니다.

LLM은 마치 메멘토의 주인공과 비슷하다..

LangChain 패키지에는 이러한 Memory 요소를 쉽게 적용할 수 있도록 도와주는 장치들이 있습니다. 우선 대화형 LLM 에서 사용하는 기본적인 Memory 모듈들을 살펴보겠습니다.

• ConversationBufferMemory

• ConversationBufferWindowMemory

• ConversationTokenBufferMemory

• ConversationSummaryMemory

Converation Buffer Memory

가장 기본적인 형태의 메모리 모듈 입니다. 말 그대로 버퍼에 이전 기록들을 담아 다음 출력에 사용하는 방식 입니다.

Conversation Buffer Memory 예시

위 그림에서도 볼 수 있듯이 이전 대화 기록을 모두 저장하는 것이라고 보시면 되겠습니다. 이러한 방식의 Memory 관리는 이전 기록을 모두 활용할 수 있다는 점에서 장점이 있지만, 대화가 길어질수록 LLM이 처리해야하는 토큰의 개수가 증가하는 단점이 있습니다. 처리해야하는 토큰의 개수는 곧 비용 문제로 되돌아오기 때문에 조심해서 사용할 필요가 있는 Memory 모듈 입니다.

아래는 실제 코드 예시 입니다.

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

# LLM과 연결할 객체를 생성합니다.
llm = ChatOpenAI(temperature=0.0)

# 대화 기록을 남기기위한 도구를 생성합니다.
memory = ConversationBufferMemory()

# 대화형 작업을 위해 미리 구성된, 엮어 놓은(chaining), 모듈을 생성합니다.
conversation = ConversationChain(
    llm=llm, 
    memory = memory,
    verbose=True
)

# conversation_chain 에게 입력 데이터를 전달합니다
conversation.predict(input="Hi, my name is John")

# memory 에는 대화 기록이 그대로 저장됩니다
# ...
conversation.predict(input="What is my name?")

Conversation Buffer Window Memory

이름에서도 알 수 있듯이 버퍼 메모리 입니다. 한 가지 차이점은 Window 입니다. 아래 코드는 실제 Conversation Buffer Window Memory를 생성하는 작업을 보여주고 있습니다.

from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(k=1) 

입력 매개변수로 k의 양의 정수 값을 받습니다. k가 의미하는 것은 window size 입니다. 단순 버퍼 메모리의 단점으로 지목받던 비효율적인 대화 히스토리 누적을 회피하기 위한 방법 중 하나 입니다. 단순한 전략으로, 이전 k 개의 대화 이력만 다음 대화의 히스토리로 사용하는 것 입니다.

Convesation Buffer Window Memory 예시

위 그림은 다소 극단적인 예시이긴 하지만, window 사이즈가 0인 경우 이전 대화기록을 남기지 않는 것으로 볼 수 있습니다. 따라서 직전 대화에서 얻을 수 있는 정보를 다음 대화에서 사용하지 못하게 됩니다. k 값을 조절하여 토큰 개수를 적절하게 관리할 수 있을 것 입니다.

Convesation Token Buffer Memory

Buffer Windlow Memory와 비슷한 목적으로 사용되는 메모리 입니다. 이전에는 히스토리의 개수로 누적되는 히스토리 토큰 양을 조절하였다면, 이번 메모리에서는 좀 더 직관적으로 토큰 개수를 사용합니다.

from langchain.memory import ConversationTokenBufferMemory

memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=30)

Conversation Summary Buffer Memory

이전 대화 기록의 일부만 남기는 방식은 결국 손실되는 정보가 생길 수 밖에 없습니다. 히스토리를 줄이는 것은 손실되는 정보가 있기 마련이며, 이를 최소화하기 위해 대화 기록을 요약하여 저장하고 다시 재사용하는 프로세스를 생각해볼 수 있습니다. 이것이 Conversation Summary Buffer Memory 입니다.

이 Memory의 특징은 기존과 다르게 히스토리 처리 작업에 LLM이 사용된다는 점 입니다. 추가적인 토큰 활용이 예상되지만, 단순하게 히스토리를 누적시켜 무의미하게 사용되는 토큰개수 보다는 현저히 적을 것 입니다. 아래는 강좌에서 제공하는 예시 입니다.

from langchain.memory import ConversationSummaryBufferMemory

# Summary Buffer Memory 를 준비합니다. 
# 이 때, llm 이 사용되는 것을 확인할 수 있습니다.
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100)

# 단순 누적 방식으로 메모리를 관리할 경우 낭비되는 토큰이 많은 경우를 가정합니다.
# 우선 긴 대화 내용을 준비합니다.
schedule = """There is a meeting at 8am with your product team. \
You will need your powerpoint presentation prepared. \
9am-12pm have time to work on your LangChain \
project which will go quickly because Langchain is such a powerful tool. \
At Noon, lunch at the italian resturant with a customer who is driving \
from over an hour away to meet you to understand the latest in AI. \
Be sure to bring your laptop to show the latest LLM demo."""
memory.save_context({"input": "Hello"}, {"output": "What's up"})
memory.save_context({"input": "Not much, just hanging"},
                    {"output": "Cool"})
memory.save_context({"input": "What is on the schedule today?"}, 
                    {"output": f"{schedule}"})

# 대화를 목적으로 하는 Chain을 생성합니다.                    
conversation = ConversationChain(
    llm=llm, 
    memory = memory,
    verbose=True
)

# 입력
conversation.predict(input="What would be a good demo to show?")

아래는 실제 Summary Buffer 로 요약된 프롬프트 템플릿 입니다.

> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:
System: The human and AI engage in small talk before discussing the day's schedule. The AI informs the human of a morning meeting with the product team, time to work on the LangChain project, and a lunch meeting with a customer interested in the latest AI developments.
Human: What would be a good demo to show?
AI:

현재 대화(Current conversation)에서 시스템 명령어가 이전 대화의 맥락을 요약하여 전달하는 것을 확인할 수 있습니다.