더 나은 세상을 위하여…

CommaSeparatedListOutputParser는 LangChain 프레임워크에서 제공하는 강력한 출력 파서 중 하나로, 언어 모델(LLM)의 텍스트 응답을 쉼표(,)로 구분된 리스트 형태로 변환하는 데 사용됩니다. 이를 통해 언어 모델이 생성한 비구조화된 텍스트 데이터를 구조화된 리스트 형태로 가공하여, 후속 작업에서 보다 쉽게 활용할 수 있도록 돕습니다. 예를 들어, “인기 있는 한국 음식 5가지” 또는 “대한민국 관광 명소 5곳”과 같은 질문에 대해 쉼표로 구분된 텍스트 응답을 받아 이를 Python 리스트로 변환할 수 있습니다.

이 파서는 특히 데이터 가공, API 응답 처리, 또는 데이터 분석과 같은 작업에서 유용합니다. 

주요 기능

• 쉼표로 구분된 텍스트를 리스트로 변환: 언어 모델이 쉼표로 항목을 구분한 텍스트를 반환하면, 이를 Python 리스트로 자동 변환합니다.
• 데이터 가독성 향상: 비구조화된 텍스트를 구조화된 형태로 변환하여 코드 내에서 쉽게 다룰 수 있도록 합니다.
• 다양한 작업에 활용 가능: 리스트 형태의 데이터가 필요한 데이터베이스 입력, UI 표시, 또는 후속 처리 작업에 적합합니다.

사용 예제

CommaSeparatedListOutputParser를 활용하여 EXAone 3.5 모델을 기반으로 LangChain에서 “대한민국 관광 명소 5곳”을 요청하고, 결과를 리스트로 변환하는 과정을 살펴보겠습니다. 아래는 이를 구현한 코드와 실행 결과입니다.

예제 1: 기본 호출

from langchain_core.output_parsers import CommaSeparatedListOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_ollama import ChatOllama

# 콤마로 구분된 리스트 출력 파서 초기화
output_parser = CommaSeparatedListOutputParser()

# 출력 형식 지침 가져오기
format_instructions = output_parser.get_format_instructions()

# 프롬프트 템플릿 설정
prompt = PromptTemplate(
    template="다음 주제에 대해 5가지 항목을 한국어로 나열해주세요.\n{subject}\n{format_instructions}",
    input_variables=["subject"],
    partial_variables={"format_instructions": format_instructions + "\n답변은 반드시 한국어로 작성해주세요."},
)

# EXAone 3.5 모델 초기화
llm_model = ChatOllama(model="exaone3.5")

# 프롬프트, 모델, 출력 파서를 연결하여 체인 생성
chain = prompt | llm_model | output_parser

# "대한민국 관광 명소"에 대한 체인 호출
result = chain.invoke({"subject": "대한민국 관광 명소"})
print(result)

[‘경복궁’, ‘남산 타워’, ‘부산 해운대 해수욕장’, ‘제주도 올레길’, ‘경복궁 야간 개장지’]

설명:

• PromptTemplate은 사용자가 입력한 주제(subject)와 출력 형식 지침(format_instructions)을 조합하여 모델에 전달합니다.
• format_instructions은 CommaSeparatedListOutputParser가 요구하는 형식(쉼표로 구분된 텍스트)을 모델에 명시합니다.
• CommaSeparatedListOutputParser는 모델의 응답을 파싱하여 Python 리스트로 변환합니다.

예제 2: 스트리밍 호출

LangChain의 chain.stream 기능을 사용하면 응답을 실시간으로 스트리밍하여 처리할 수 있습니다. 이는 대량의 데이터를 처리하거나 실시간 응답이 필요한 경우 유용합니다. 아래는 스트리밍을 통해 “대한민국 관광 명소”를 요청하는 예제입니다.

# 스트리밍 호출
for s in chain.stream({"subject": "대한민국 관광 명소"}):
    print(s)  # 스트림으로 받은 각 항목을 출력

[‘한강공원’] [‘경복궁’] [‘부산 해운대 해수욕장’] [‘제주도 올레길’] [‘강원도 설악산 등산코스’]

설명:

• chain.stream은 모델의 응답을 즉시 처리하며, 각 항목이 생성될 때마다 리스트 형태로 반환합니다.
• 스트리밍 방식은 사용자 경험을 향상시키거나 대규모 응답을 효율적으로 처리할 때 적합합니다.

주의사항

• 응답 형식 일관성: EXAone 3.5 모델이 쉼표로 구분된 형식으로 정확히 응답하도록 프롬프트에서 명확히 지시해야 합니다. 예를 들어, format_instructions에 쉼표 구분 형식을 명시적으로 포함해야 합니다.
• 한국어 처리: EXAone 3.5는 한국어에 최적화된 모델이므로, 프롬프트에 “한국어로 답변”을 명시하면 더 자연스러운 결과를 얻을 수 있습니다.
• 스트리밍 성능: 스트리밍 호출은 네트워크 환경과 Ollama 서버의 성능에 따라 지연이 발생할 수 있으므로, 안정적인 환경에서 테스트하는 것이 좋습니다.

활용 사례

• 여행 추천 시스템: 사용자가 요청한 관광 명소를 리스트로 변환하여 데이터베이스에 저장하거나 UI에 표시.
• 설문조사 응답 처리: 사용자가 쉼표로 구분하여 입력한 답변을 리스트로 가공.
• 자연어 기반 데이터 추출: 언어 모델이 생성한 비구조화된 텍스트에서 필요한 항목을 리스트로 추출.

CommaSeparatedListOutputParser는 단순하지만 강력한 도구로, 다양한 애플리케이션에서 데이터 구조화를 간소화합니다.

PydanticOutputParser는 LangChain 프레임워크에서 제공하는 강력한 출력 파서로, 대형 언어 모델(LLM)의 텍스트 출력을 구조화된 Python 객체로 변환하는 데 사용됩니다. 이 파서는 Pydantic 라이브러리를 기반으로 동작하며, 사전에 정의된 데이터 스키마에 따라 LLM의 출력을 검증하고 매핑하여 개발자가 원하는 형식으로 데이터를 쉽게 활용할 수 있도록 돕습니다. 특히, 복잡한 텍스트 데이터를 JSON, 리스트, 또는 사용자 정의 클래스의 인스턴스로 변환하는 데 유용합니다.

주요 특징 및 기능

• 구조화된 데이터 변환
  PydanticOutputParser는 LLM의 비구조화된 텍스트 출력을 JSON 객체, 리스트, 혹은 Pydantic 모델 기반의 사용자 정의 객체로 변환합니다. 이를 통해 데이터를 체계적으로 관리하고, 후속 처리나 분석 작업을 간소화할 수 있습니다.
• Croatia 데이터 모델 정의**
  Pydantic의 BaseModel 클래스를 사용하여 출력 데이터의 스키마를 정의합니다. 이 스키마에는 필드 이름, 데이터 타입, 필수 여부 등이 포함되며, 이를 통해 LLM의 출력이 기대한 형식을 충족하는지 검증합니다. 잘못된 데이터가 입력될 경우, Pydantic이 자동으로 오류를 감지하여 안정적인 데이터 처리를 보장합니다.
• 자동 매핑 및 검증
  정의된 스키마에 따라 LLM의 출력을 자동으로 매핑하고, 데이터의 유효성을 검증합니다. 예를 들어, 특정 필드가 문자열이어야 하거나 필수값이 누락되지 않도록 강제할 수 있습니다. 이 과정은 수작업으로 데이터를 처리하는 번거로움을 줄여줍니다.
• 유연한 출력 형식 지정
  PydanticOutputParser는 get_format_instructions() 메서드를 통해 LLM이 따라야 할 출력 형식 지침을 제공합니다. 이 지침은 JSON 스키마 형태로 제공되며, LLM이 구조화된 출력을 생성하도록 유도합니다.

PydanticOutputParser는 두 가지 주요 메서드를 통해 동작합니다:

• get_format_instructions()
  이 메서드는 LLM이 출력해야 할 데이터의 형식과 구조를 설명하는 지침을 문자열 형태로 반환합니다. 예를 들어, JSON 스키마를 기반으로 필드 이름, 타입, 설명 등을 명시하여 LLM이 해당 형식에 맞는 출력을 생성하도록 안내합니다. 이 지침은 프롬프트에 포함되어 LLM의 출력 형식을 제어하는 데 중요한 역할을 합니다.
• parse()
  LLM이 생성한 텍스트 출력을 입력받아 이를 사전에 정의된 Pydantic 모델로 파싱합니다. 이 과정에서 출력이 스키마를 준수하는지 검증하고, 유효한 경우 해당 모델의 인스턴스로 변환합니다. 만약 출력이 스키마와 맞지 않으면, Pydantic이 오류를 발생시켜 문제를 즉시 파악할 수 있습니다.

예제: 이메일 내용 파싱

아래는 PydanticOutputParser를 사용하여 이메일 내용을 파싱하는 예제입니다. 이 예제에서는 이메일의 주요 정보를 추출하여 구조화된 형식으로 변환합니다.

이메일 본문

출력 파서 없이 처리한 경우:

먼저, 출력 파서를 사용하지 않고 이메일 내용을 요약하는 코드를 살펴보겠습니다.

from langchain_core.prompts import PromptTemplate
from langchain_ollama import ChatOllama

llm_model = ChatOllama(model="exaone3.5", temperature=0)

prompt = PromptTemplate.from_template(
    "다음의 이메일 내용 중 중요한 내용을 추출해 주세요.\n\n{email_conversation}"
)
chain = prompt | llm_model
response = chain.invoke({"email_conversation": email_conversation})
print(response.content)

이메일의 중요한 내용 요약: 발신자 및 수신자: 발신: 김철수 상무 (바이크코퍼레이션) 수신: 이은채 대리 (테디인터내셔널) 주요 목적: “ZENESIS” 자전거 모델에 대한 정보 요청 (브로슈어, 특히 기술 사양, 배터리 성능, 디자인) 자전거 유통 협력 가능성 논의를 위한 미팅 제안 미팅 제안: 날짜: 1월 15일 화요일 시간: 오전 10시 장소: 테디인터내셔널 사무실 이러한 내용들이 협력 및 미팅 계획의 핵심입니다.

이 결과는 텍스트 형식으로 요약된 내용이지만, 구조화된 데이터로 활용하기에는 추가 처리가 필요합니다. 이를 해결하기 위해 PydanticOutputParser를 사용해 보겠습니다.

PydanticOutputParser를 사용한 구조화된 출력:

다음은 PydanticOutputParser를 활용하여 이메일의 주요 정보를 구조화된 객체로 변환하는 예제입니다.

from langchain_ollama import ChatOllama
from langchain_core.output_parsers import PydanticOutputParser
from langchain_core.prompts import PromptTemplate
from pydantic import BaseModel, Field

# Pydantic 모델 정의
class EmailSummary(BaseModel):
    from_person: str = Field(description="메일을 보낸 사람의 이름")
    from_email: str = Field(description="메일을 보낸 사람의 이메일 주소")
    to_person: str = Field(description="메일을 받는 사람의 이름")
    to_email: str = Field(description="메일을 받는 사람의 이메일 주소")
    subject: str = Field(description="메일 제목")
    summary: str = Field(description="메일 본문을 요약한 텍스트")
    date: str = Field(description="메일 본문에 언급된 미팅 날짜와 시간")

# PydanticOutputParser 생성
parser = PydanticOutputParser(pydantic_object=EmailSummary)

# 프롬프트 정의
prompt = PromptTemplate.from_template("""
You are an assistant to make JSON format.
Please do not answer your opinion by adding ```.
Do not use quotes in strings within JSON.

QUESTION:
{question}

EMAIL CONVERSATION:
{email_conversation}

FORMAT:
Do not use quotes in strings within JSON.\n
{format}
""")

# 프롬프트에 포맷 지침 추가
prompt = prompt.partial(format=parser.get_format_instructions())

# LLM 모델 설정
llm_model = ChatOllama(model="exaone3.5", temperature=0)

# 체인 구성
chain = prompt | llm_model

# 체인 실행
result = chain.invoke({
    "email_conversation": email_conversation,
    "question": "이메일 내용 중 주요 내용을 추출해 주세요.",
})

# 결과 파싱
structured_output = parser.parse(result.content)
print(structured_output)

from_person=’김철수’ from_email=’chulsoo.kim@bikecorporation.me’ to_person=’이은채’ to_email=’eunchae@teddyinternational.me’ subject=’ZENESIS 자전거 유통 협력 및 미팅 일정 제안’ summary=’김철수 상무는 이은채 대리에게 바이크코퍼레이션의 자전거 제조 및 유통 전문성을 강조하며, ZENESIS 모델의 브로슈어 요청과 함께 기술 사양, 배터리 성능, 디자인 정보를 요청했습니다. 또한, 협력 가능성을 논의하기 위해 1월 15일 화요일 오전 10시에 미팅을 제안했습니다.’ date=’1월 15일 화요일 오전 10시’

이 결과는 EmailSummary 클래스의 인스턴스로 반환되며, 각 필드가 명확하게 구조화되어 있어 데이터베이스 저장, API 응답, 또는 추가 처리에 바로 활용할 수 있습니다.

출력 파서를 체인에 통합:

PydanticOutputParser를 체인에 직접 포함시켜 LLM의 출력을 바로 Pydantic 객체로 변환할 수 있습니다.

# 체인 구성 (파서 포함)
chain = prompt | llm_model | parser

# 체인 실행
response = chain.invoke({
    "email_conversation": email_conversation,
    "question": "이메일 내용 중 주요 내용을 추출해 주세요.",
})

print(response)

from_person=’김철수’ from_email=’chulsoo.kim@bikecorporation.me’ to_person=’이은채’ to_email=’eunchae@teddyinternational.me’ subject=’ZENESIS 자전거 유통 협력 및 미팅 일정 제안’ summary=’김철수 상무는 이은채 대리에게 바이크코퍼레이션의 자전거 제조 및 유통 전문성을 강조하며, ZENESIS 모델의 브로슈어 요청과 함께 기술 사양, 배터리 성능, 디자인 정보를 요청했습니다. 또한, 협력 가능성을 논의하기 위해 1월 15일 화요일 오전 10시에 미팅을 제안했습니다.’ date=’1월 15일 화요일 오전 10시’

이 방식은 별도의 파싱 단계를 생략하고, 체인 실행 결과로 바로 Pydantic 객체를 얻을 수 있어 더욱 간결합니다.

with_structured_output() 활용

LangChain의 with_structured_output() 메서드는 LLM의 출력을 구조화된 형식으로 반환하는 간편한 방법입니다. 이 메서드는 JSON 스키마 또는 Pydantic 모델을 입력으로 받아, LLM의 출력을 해당 형식으로 자동 변환합니다. 단, exaone3.5 모델은 구조화된 출력용 도구 호출 기능을 지원하지 않으므로, 이 예제에서는 llama3.2 모델을 사용합니다.

예제: with_structured_output() 사용

from langchain_ollama import ChatOllama
from pydantic import BaseModel, Field

# Pydantic 모델 정의
class EmailSummary(BaseModel):
    from_person: str = Field(description="메일을 보낸 사람의 이름")
    from_email: str = Field(description="메일을 보낸 사람의 이메일 주소")
    to_person: str = Field(description="메일을 받는 사람의 이름")
    to_email: str = Field(description="메일을 받는 사람의 이메일 주소")
    subject: str = Field(description="메일 제목")
    summary: str = Field(description="메일 본문을 요약한 텍스트")
    date: str = Field(description="메일 본문에 언급된 미팅 날짜와 시간")

# LLM 모델 설정
llm_model_with_structured = ChatOllama(model="llama3.2", format="json").with_structured_output(EmailSummary)

# 실행
response = llm_model_with_structured.invoke(email_conversation)
print(response)

from_person=’kim, chulsoo.kim@bikecorporation.me’ from_email=’chulsoo.kim@bikecorporation.me’ to_person=’Lee Eun Chae, eunchae@teddyinternational.me’ to_email=’eunchae@teddyinternational.me’ subject=’ZENESIS 자전거 유통 협력 및 미팅 일정 제안’ summary=’바이크코퍼레이션의 김철수 상무가 이은채 대리님에게 ZENESIS 모델에 대한 브로슈어를 요청하여 discussion을 위한 미팅 연장을 제안합니다.’ date=’2023-01-15 10:00:00′

with_structured_output()의 장점

• 간편성: 프롬프트나 출력 파서를 별도로 설정할 필요 없이, 모델에 스키마를 전달하면 자동으로 구조화된 출력을 생성합니다.
• 통합성: LangChain의 다른 기능과 쉽게 결합하여 복잡한 워크플로우를 구성할 수 있습니다.
• 자동화: 스키마 포맷팅과 출력 파싱 과정을 자동으로 처리하여 개발자의 작업 부담을 줄입니다.

주의사항

1. 모델 지원 여부
   with_structured_output()은 도구 호출(tool calling)을 지원하는 모델에서만 동작합니다. exaone3.5는 이 기능을 지원하지 않으므로, 대체 모델(예: llama3.2)을 사용해야 합니다.
2. 정확한 스키마 정의
   Pydantic 모델의 Field에 포함된 description은 LLM이 데이터를 올바르게 추출하는 데 중요한 역할을 합니다. 따라서 설명은 명확하고 구체적이어야 합니다.
3. 프롬프트 최적화
   PydanticOutputParser를 사용할 때는 get_format_instructions()를 통해 제공되는 지침을 프롬프트에 포함해야 하며, 프롬프트의 질문과 지침이 LLM의 출력에 직접적인 영향을 미칩니다.

PydanticOutputParser와 with_structured_output()은 LangChain에서 LLM의 출력을 구조화된 데이터로 변환하는 데 매우 유용한 도구입니다. PydanticOutputParser는 프롬프트와 파서를 통해 세밀한 제어가 가능하며, with_structured_output()은 간단하고 자동화된 방식으로 구조화된 출력을 제공합니다. 이를 활용하면 이메일 파싱, 데이터 추출, API 응답 생성 등 다양한 작업을 효율적으로 수행할 수 있습니다. 특히, Pydantic의 강력한 데이터 검증 기능을 통해 안정적이고 신뢰할 수 있는 데이터 처리가 가능하다는 점에서 큰 장점을 가집니다.

LangChain 프레임워크에서 **출력 파서(Output Parser)**는 언어 모델(LLM)의 출력을 구조화하고, 더 유용한 형태로 변환하는 핵심적인 역할을 담당합니다. 언어 모델은 텍스트를 생성하는 데 탁월하지만, 그 출력은 종종 자유로운 형태의 텍스트로 나타나며, 이를 바로 애플리케이션에서 사용하기에는 적합하지 않을 수 있습니다. 출력 파서는 이러한 자유 형식의 텍스트를 JSON, 리스트, 딕셔너리와 같은 구조화된 데이터로 변환하여 개발자가 데이터를 쉽게 처리하고 활용할 수 있도록 돕습니다. 특히, EXAOne 3.5와 같은 고성능 언어 모델을 Ollama 기반의 LangChain 환경에서 사용할 때, 출력 파서는 애플리케이션의 효율성과 정확성을 크게 향상시킵니다.

이 챕터에서는 출력 파서의 역할, 주요 특징, 이점, 그리고 실제 사용 사례를 통해 출력 파서가 어떻게 LangChain 기반 애플리케이션 개발에 기여하는지 자세히 살펴보겠습니다.

출력파서의 역할:

출력 파서는 언어 모델의 출력을 받아 이를 더 적합한 형식으로 변환하는 도구입니다. 언어 모델은 일반적으로 텍스트를 생성하지만, 이 텍스트는 때로는 비정형적이거나 애플리케이션에서 바로 사용하기 어려운 형태일 수 있습니다. 출력 파서는 이러한 문제를 해결하며, 다음과 같은 역할을 수행합니다:

• 구조화된 데이터 생성: 자유 형식의 텍스트를 JSON, 리스트, 딕셔너리 등의 구조화된 데이터로 변환합니다. 이를 통해 데이터를 체계적으로 저장하거나 후속 처리에 활용할 수 있습니다.
• 출력 형식 표준화: 언어 모델의 출력은 일관되지 않을 수 있습니다. 출력 파서는 출력 형식을 표준화하여 일관된 데이터를 제공합니다.
• 복잡한 데이터 처리: 이메일, 문서, 대화 로그 등에서 특정 정보를 추출하거나 재구성하는 데 유용합니다.
• 애플리케이션 통합: 출력 파서를 통해 변환된 데이터는 데이터베이스 저장, API 호출, 또는 UI 표시 등 다양한 애플리케이션 작업에 바로 사용될 수 있습니다.

주요 특징:

LangChain은 다양한 출력 파서를 제공하며, 이들은 다음과 같은 주요 특징을 갖습니다:

• 다양성: LangChain은 JSON, CSV, 리스트, Pydantic 객체 등 다양한 출력 형식을 지원하는 파서를 제공합니다. 개발자는 애플리케이션의 요구사항에 맞는 파서를 선택할 수 있습니다.
• 스트리밍 지원: 대규모 데이터 처리나 실시간 애플리케이션에서 유용하도록, 많은 출력 파서가 스트리밍을 지원합니다. 이를 통해 데이터를 점진적으로 처리할 수 있습니다.
• 확장성: 간단한 텍스트 파싱부터 복잡한 데이터 구조로의 변환까지, 출력 파서는 확장 가능한 인터페이스를 제공합니다. 이를 통해 개발자는 최소한의 코드로 복잡한 작업을 수행할 수 있습니다.
• 사용자 정의 가능: LangChain은 사용자 정의 출력 파서를 만들 수 있는 유연한 API를 제공하여, 특정 요구사항에 맞춘 파싱 로직을 구현할 수 있습니다.

출력 파서를 사용하면 다음과 같은 이점을 얻을 수 있습니다:

• 구조화: 언어 모델의 자유 형식 텍스트를 체계적인 데이터 구조로 변환하여, 데이터를 더 쉽게 분석하고 활용할 수 있습니다.
• 일관성: 출력 형식을 일관되게 유지함으로써, 후속 처리 과정에서 오류를 줄이고 예측 가능한 결과를 얻을 수 있습니다.
• 유연성: JSON, 리스트, 딕셔너리, Pydantic 객체 등 다양한 출력 형식으로 변환할 수 있어, 다양한 애플리케이션 시나리오에 적응 가능합니다.
• 효율성: 출력 파서를 사용하면 수작업으로 데이터를 처리할 필요가 없어 개발 시간이 단축되고, 코드의 유지보수가 쉬워집니다.

출력 파서의 활용 가능성을 보여주기 위해, 두 가지 예제를 통해 출력 파서가 어떻게 사용되는지 살펴보겠습니다.

예제 1: 이메일 내용에서 중요 정보 추출

다음은 바이크코퍼레이션의 김철수 상무가 테디인터내셔널의 이은채 대리에게 보낸 이메일의 내용입니다. 이 이메일에서 중요한 정보를 추출하여 구조화된 형태로 변환하는 과정을 살펴보겠습니다.

원본 이메일 텍스트:

출력 파서 없이 처리했을 때: 언어 모델이 이 텍스트를 처리하면, 단순히 요약된 텍스트나 비정형적인 결과를 반환할 가능성이 높습니다. 예를 들어:

이런 출력은 정보를 체계적으로 활용하기 어렵습니다.

출력 파서를 사용했을 때: LangChain의 구조화된 출력 파서(예: PydanticOutputParser 또는 JsonOutputParser)를 사용하면, 다음과 같은 구조화된 데이터를 얻을 수 있습니다:

이와 같이 출력 파서를 사용하면, 이메일의 주요 정보를 체계적으로 추출하여 데이터베이스에 저장하거나, 일정 관리 시스템에 통합하는 등의 작업을 쉽게 수행할 수 있습니다.

예제 2: JSON 형식의 요약 생성

이번에는 언어 모델이 생성한 텍스트를 JSON 형식으로 요약하는 사례를 살펴보겠습니다. 예를 들어, 언어 모델이 위 이메일 내용을 요약한 결과가 다음과 같다고 가정합니다:

언어 모델 출력:

출력 파서 적용 결과: LangChain의 JsonOutputParser를 사용하여 위 텍스트를 다음과 같은 JSON 형식으로 변환할 수 있습니다:

이 JSON 출력은 API 응답, 데이터베이스 입력, 또는 다른 시스템과의 통합에 바로 사용될 수 있습니다.

LangChain에서 출력 파서를 사용하는 기본적인 흐름은 다음과 같습니다:

1. 출력 파서 선택: LangChain에서 제공하는 출력 파서 중 애플리케이션 요구사항에 맞는 파서를 선택합니다. 예를 들어, JSON 출력이 필요하다면 JsonOutputParser를, Pydantic 객체가 필요하다면 PydanticOutputParser를 사용할 수 있습니다.
2. 프롬프트 설계: 언어 모델에 출력 파서가 기대하는 형식으로 출력을 생성하도록 프롬프트를 설계합니다. 예를 들어, JSON 형식을 요청하는 지침을 포함할 수 있습니다.
3. 출력 파싱: 언어 모델의 출력을 출력 파서에 전달하여 구조화된 데이터를 얻습니다.
4. 결과 활용: 파싱된 데이터를 애플리케이션의 후속 작업(데이터베이스 저장, API 호출 등)에 활용합니다.

LangChain의 출력 파서는 언어 모델의 출력을 구조화하고, 애플리케이션에서 바로 사용할 수 있는 형태로 변환하는 강력한 도구입니다. 출력 파서는 데이터 처리의 효율성과 정확성을 크게 향상시킵니다. 다양한 출력 형식 지원, 스트리밍 기능, 확장 가능한 인터페이스 등의 특징을 통해 개발자는 복잡한 데이터 처리 작업을 간소화할 수 있습니다.

다이나믹 퓨샷 프롬프트(Dynamic Few-Shot Prompting)는 대규모 언어 모델(LLM)을 활용하여 특정 작업에 최적화된 응답을 생성하기 위한 고급 프롬프트 엔지니어링 기법입니다. 이 기법은 정적인 프롬프트와 달리, 작업의 맥락이나 입력 데이터에 따라 동적으로 예제를 선택하거나 생성하여 모델의 성능을 향상시킵니다

다이나믹 퓨샷 프롬프트의 개념

퓨샷 러닝(Few-Shot Learning)은 모델이 소수의 예제를 통해 새로운 작업을 학습하도록 유도하는 방법입니다. 다이나믹 퓨샷 프롬프트는 이러한 예제를 고정적으로 제공하는 대신, 입력 데이터의 특성, 작업 유형, 또는 사용자 요구사항에 따라 예제를 동적으로 선택하거나 생성합니다. 이는 모델이 더 관련성 높은 맥락을 이해하고, 작업에 최적화된 출력을 생성하도록 돕습니다.

주요 특징

• 맥락 적응성: 입력 데이터에 따라 가장 적합한 예제를 선택하거나 생성.
• 효율성: 불필요한 예제를 배제하여 프롬프트의 길이를 최적화.
• 확장성: 다양한 작업과 도메인에 적용 가능.
• 성능 최적화: 모델의 응답 품질을 개선하고, 오답 가능성을 줄임.

다이나믹 퓨샷 프롬프트를 설계할 때 고려해야 할 주요 원칙은 다음과 같습니다:

1. 예제 관련성: 선택된 예제는 입력 데이터와 작업의 맥락에 밀접하게 관련되어야 합니다. 예를 들어, 감정 분석 작업에서는 입력 문장의 감정 톤과 유사한 예제를 선택하는 것이 중요합니다.
2. 다양성: 예제는 작업의 다양한 측면을 커버해야 하며, 편향된 결과를 방지하기 위해 균형 잡힌 데이터셋에서 추출되어야 합니다.
3. 최적화된 예제 수: 너무 많은 예제는 토큰 제한을 초과하거나 모델을 혼란스럽게 할 수 있습니다. 일반적으로 3~5개의 예제가 적절합니다.
4. 동적 생성: 예제를 실시간으로 생성하거나 데이터베이스에서 검색하여 프롬프트에 통합.
5. 명확한 지시사항: 프롬프트는 작업의 목표와 기대되는 출력 형식을 명확히 정의해야 합니다.

다음은  감정 분석 작업을 위한 다이나믹 퓨샷 프롬프트 구현 예제입니다.

사용자가 입력한 문장의 감정을 긍정, 부정, 중립으로 분류하는 작업을 수행한다고 가정합니다. 다이나믹 퓨샷 프롬프트는 입력 문장의 특성(예: 키워드, 문장 길이)에 따라 적합한 예제를 선택합니다.

from langchain.prompts import PromptTemplate
from langchain_ollama import OllamaLLM
from langchain.chains import LLMChain
import random

llm = OllamaLLM(model="exaone3.5")

example_db = [
    {"text": "이 영화 정말 재미있었어요!", "label": "긍정"},
    {"text": "서비스가 너무 느려서 짜증났습니다.", "label": "부정"},
    {"text": "제품은 괜찮은데 배송이 좀 늦었네요.", "label": "중립"},
    {"text": "최고의 경험이었어요!", "label": "긍정"},
    {"text": "별로였어요, 기대 이하였습니다.", "label": "부정"}
]

def select_dynamic_examples(input_text, num_examples=3):
    keywords = input_text.split()
    scored_examples = []

    for example in example_db:
        score = sum(1 for word in keywords if word in example["text"])
        scored_examples.append((score, example))

    scored_examples.sort(key=lambda x: x[0], reverse=True)
    selected = [ex[1] for ex in scored_examples[:num_examples]]
    return selected

prompt_template = PromptTemplate(
    input_variables=["examples", "input_text"],
    template="""
다음 예시들을 참고하여 새로운 입력을 분류하세요:

{examples}

새로운 입력: {input_text}
분류 결과:"""
)

def format_examples(examples):
    formatted = ""
    for ex in examples:
        formatted += f"입력: {ex['text']}\n출력: {ex['label']}\n\n"
    return formatted

chain = prompt_template | llm

# 테스트
input_text = "이 레스토랑 음식이 정말 맛있었어요!"
dynamic_examples = select_dynamic_examples(input_text)
formatted_examples = format_examples(dynamic_examples)

# 수정된 부분: 단일 딕셔너리 입력으로 변경
result = chain.invoke({"examples": formatted_examples, "input_text": input_text})
print(f"입력: {input_text}")
print(f"출력: {result.strip()}")

입력: 이 레스토랑 음식이 정말 맛있었어요! 출력: 분류 결과: 긍정

이와 같은 예시에서는 example의 수가 적기 때문에 비용적으로 부담되지 않지만 수가 커진다면 부담이 될 수 있습니다. 이럴 때 dynamic few shot prompting을 사용하면 부담을 줄일 수 있습니다.

코드 설명

1. 모델 초기화: Ollama를 통해 EXAONE 3.5 모델을 로드합니다.
2. 예제 선택: select_dynamic_examples 함수는 입력 문장의 키워드를 분석하여 가장 관련성 높은 예제를 선택합니다. 실제 구현에서는 텍스트 임베딩(예: Sentence-BERT)을 사용하여 더 정교한 유사성 계산을 수행할 수 있습니다.
3. 프롬프트 템플릿: LangChain의 PromptTemplate을 사용하여 동적으로 예제를 삽입할 수 있는 프롬프트를 정의합니다.
4. 체인 실행: LLMChain을 통해 프롬프트와 모델을 연결하고, 입력 문장에 대한 감정 분석 결과를 생성합니다.

다이나믹 퓨샷 프롬프트는 감정 분석 외에도 다양한 작업에 적용될 수 있습니다. 예를 들어:

• 질문 답변: 사용자의 질문과 유사한 질문-답변 쌍을 동적으로 선택.
• 텍스트 생성: 특정 스타일(예: 공식 문서, 캐주얼 대화)에 맞는 예제를 선택하여 생성된 텍스트의 톤을 조정.
• 코드 생성: 입력된 코드 스니펫과 유사한 예제를 제공하여 더 정확한 코드 완성을 유도.

고급 구현 팁

• 임베딩 기반 예제 선택: LangChain의 벡터 스토어(Vector Store)를 활용하여 입력과 예제 간의 코사인 유사도를 계산.
• 예제 생성: EXAONE 3.5 자체를 사용하여 입력에 맞는 예제를 생성한 후 프롬프트에 통합.
• 프롬프트 최적화: LangChain의 PromptSelector를 활용하여 작업 유형별로 최적의 프롬프트 템플릿을 선택.

다이나믹 퓨샷 프롬프트는 언어 모델의 성능을 극대화하는 강력한 도구입니다. 동적으로 선택된 예제는 모델이 작업 맥락을 더 잘 이해하도록 돕고, 다양한 도메인에서 높은 품질의 출력을 보장합니다.

Example Selector는 특정 작업에 적합한 예제를 동적으로 선택하여 프롬프트에 포함시키는 데 사용됩니다. 특히, 유사도 검색 기반 Example Selector는 입력 쿼리와 저장된 예제 간의 의미적 유사성을 평가하여 가장 관련성 높은 예제를 선택합니다. 그러나 유사도 검색 과정에서 발생할 수 있는 문제들—예를 들어, 부정확한 임베딩, 검색 결과의 낮은 품질, 또는 계산 비용 문제—는 모델 성능에 직접적인 영향을 미칩니다. 이 챕터에서는 유사도 검색 문제를 해결하는 방법에 대해 다룹니다.

유사도 검색의 핵심 개념

유사도 검색은 입력 쿼리와 예제 데이터를 임베딩 벡터로 변환한 뒤, 코사인 유사도(Cosine Similarity)와 같은 메트릭을 사용하여 가장 유사한 예제를 선택하는 과정입니다. EXAONE 3.5와 같은 모델은 고품질의 텍스트 임베딩을 생성할 수 있는 강력한 언어 모델로, LangChain의 SemanticSimilarityExampleSelector와 통합하여 효율적인 예제 선택을 지원합니다. 하지만 다음과 같은 문제들이 발생할 수 있습니다:

• 임베딩 품질 문제: 입력 쿼리나 예제 데이터의 의미가 부정확하게 표현될 경우.
• 벡터 저장소 검색 효율성: 대규모 데이터셋에서 검색 속도가 느려지는 문제.
• 컨텍스트 불일치: 선택된 예제가 작업 컨텍스트와 맞지 않는 경우.

이러한 문제들을 다음과 같은 방법으로 해결해볼 수 있습니다.

1) 고품질 임베딩 생성

LLM 모델은 다국어 지원과 고차원 임베딩 생성 능력이 뛰어나지만, 입력 데이터의 전처리가 중요합니다. 아래는 임베딩 품질을 개선하기 위한 방법입니다:

• 텍스트 정규화: 입력 쿼리와 예제 데이터를 정규화하여 불필요한 노이즈(예: 특수 문자, 불용어)를 제거합니다.
• 도메인 특화 fine-tuning: LLM 모델을 특정 도메인 데이터로 미세 조정하여 임베딩의 도메인 적합성을 높입니다. 예를 들어, 법률 관련 작업이라면 법률 문서로 fine-tuning을 진행합니다.
• 배치 처리 최적화: Ollama의 API를 활용하여 대량의 예제 데이터를 한 번에 임베딩 처리함으로써 계산 효율성을 높입니다.

2) 벡터 저장소 최적화

LangChain에서 벡터 저장소는 유사도 검색의 핵심 구성 요소입니다. Ollama 기반 환경에서는 로컬 벡터 저장소(예: FAISS)와 LLM 모델의 임베딩을 결합하여 효율적인 검색을 구현할 수 있습니다. 최적화 방법은 다음과 같습니다:

• 인덱싱 전략: FAISS의 HNSW(Hierarchical Navigable Small World) 인덱스를 사용하여 검색 속도를 높입니다.
• 차원 축소: PCA(Principal Component Analysis) 또는 UMAP을 활용하여 임베딩 차원을 축소함으로써 검색 속도를 개선하고 메모리 사용량을 줄입니다.
• 캐싱: 자주 사용되는 쿼리의 검색 결과를 캐싱하여 반복적인 계산을 방지합니다.

3) 컨텍스트 일치도 향상

유사도 검색 결과가 작업 컨텍스트와 맞지 않는 경우, 선택된 예제가 프롬프트에 부정적인 영향을 미칠 수 있습니다. 이를 해결하기 위한 방법은 다음과 같습니다:

• 메타데이터 필터링: 예제 데이터에 태그나 카테고리와 같은 메타데이터를 추가하여 검색 범위를 좁힙니다. 예를 들어, “질문 유형”이나 “도메인”별로 예제를 분류합니다.
• 하이브리드 검색: 키워드 기반 검색과 유사도 검색을 결합하여 의미적 유사성과 키워드 일치를 모두 고려합니다.
• 예제 다양성 관리: 너무 유사한 예제만 선택되지 않도록, 선택된 예제 간의 다양성을 보장하는 알고리즘(예: Maximal Marginal Relevance, MMR)을 적용합니다.

4) 계산 비용 절감

Ollama 기반 로컬 환경에서는 계산 리소스가 제한적일 수 있습니다. 이를 해결하기 위해:

• 모델 경량화: 경량화된 LLM 모델버전을 사용하거나, 양자화(Quantization)된 모델을 사용합니다.
• 비동기 처리: LangChain의 비동기 API(async/await)를 활용하여 병렬 처리를 구현합니다.
• 샘플링: 전체 예제 데이터셋 대신, 작업에 적합한 샘플 데이터만 사용하여 검색 부담을 줄입니다.

아래는 FAISS와 EXAONE 3.5를 사용하여 SemanticSimilarityExampleSelector를 구현하는 예제 코드입니다.

from langchain.prompts import SemanticSimilarityExampleSelector
from langchain_community.vectorstores import FAISS
from langchain_ollama import OllamaEmbeddings
from langchain.prompts import FewShotPromptTemplate, PromptTemplate

# 예제 데이터
examples = [
    {"input": "프로그래밍에서 함수란 무엇인가?", "output": "함수는 특정 작업을 수행하는 코드 블록으로..."},
    {"input": "법률 문서에서 계약 해지 조건은 무엇인가?", "output": "계약 해지 조건은 계약서에 명시된 조항에 따라 다르며..."},
    {"input": "이 공의 색깔은 무엇인가요?", "output": "발간색입니다."},
    {"input": "집에서 회사까지 얼마나 걸리나요?", "output": "1시간 정도..."},
]

# EXAONE 3.5 임베딩 설정 (Ollama 기반)
embeddings = OllamaEmbeddings(model="exaone3.5")

# FAISS 벡터 저장소 생성 (메타데이터 수정)
vectorstore = FAISS.from_texts(
    texts=[example["input"] for example in examples],
    embedding=embeddings,
    metadatas=examples  # 전체 예제 객체를 메타데이터로 저장
)

# Example Selector 설정
example_selector = SemanticSimilarityExampleSelector(
    vectorstore=vectorstore,
    k=1,
)

# 프롬프트 템플릿 정의
example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="입력: {input}\n출력: {output}\n"
)

prompt = FewShotPromptTemplate(
    example_selector=example_selector,
    example_prompt=example_prompt,
    prefix="다음은 질문과 답변 예제입니다:",
    suffix="입력: {user_input}\n출력:",
    input_variables=["user_input"]
)

# 테스트
user_input = "계약 해지 절차는 어떻게 되나요?"
formatted_prompt = prompt.format(user_input=user_input)
print(formatted_prompt)

다음은 질문과 답변 예제입니다: 입력: 법률 문서에서 계약 해지 조건은 무엇인가? 출력: 계약 해지 조건은 계약서에 명시된 조항에 따라 다르며… 입력: 계약 해지 절차는 어떻게 되나요? 출력:

구현 후에는 다음과 같은 방법으로 성능을 평가하고 개선할 수 있습니다:

• 정확도 평가: 선택된 예제가 작업 결과에 미치는 영향을 정량적으로 측정합니다. 예를 들어, 생성된 답변의 BLEU 점수나 사용자 피드백을 활용합니다.
• A/B 테스트: 서로 다른 임베딩 모델이나 검색 알고리즘을 비교하여 최적의 조합을 찾습니다.
• 로그 분석: Ollama의 로그를 분석하여 병목 지점을 식별하고 최적화합니다.

유사도 검색 문제를 해결하려면 임베딩 품질, 벡터 저장소 효율성, 컨텍스트 일치도, 그리고 계산 비용을 종합적으로 고려해야 합니다. 고품질 임베딩 생성, 벡터 저장소 최적화, 하이브리드 검색, 그리고 비동기 처리와 같은 전략을 통해 Example Selector의 성능을 극대화할 수 있습니다.

FewShotChatMessagePromptTemplate는 소수의 예제를 제공하여 모델이 특정 작업에 적합한 응답을 생성하도록 유도하는 데 유용합니다. 

LangChain의 프롬프트 템플릿 중 하나로, 대화 형식의 입력과 출력 예제를 제공하여 모델이 맥락을 이해하고 유사한 패턴의 응답을 생성하도록 돕습니다. 이는 소수 샷 학습(Few-Shot Learning)을 구현하는 데 이상적이며, 모델이 새로운 작업을 빠르게 학습하도록 유도합니다.

주요 특징:

• 대화 형식 지원: 사용자와 모델 간의 대화 흐름을 반영한 프롬프트 설계 가능.
• 예제 기반 학습: 소수의 입력-출력 쌍을 제공하여 모델의 응답 품질 향상.
• 유연한 템플릿: 다양한 작업에 맞게 커스터마이징 가능.

일반적으로 다음과 같은 구성 요소로 이루어집니다:

1. 예제(Examples): 모델이 참고할 입력-출력 쌍.
2. 프롬프트 템플릿(Prompt Template): 대화 형식의 메시지 구조를 정의.
3. 포맷팅 로직(Formatting Logic): 입력 데이터를 템플릿에 맞게 변환.

다음 코드는 FewShotChatMessagePromptTemplate를 사용한 감정 분류 예제 코드입니다.

from langchain.prompts import FewShotChatMessagePromptTemplate, ChatPromptTemplate
from langchain_ollama import ChatOllama

# EXAONE 3.5 모델 초기화
llm = ChatOllama(model="exaone3.5")

# 예제 데이터: 고객 문의와 감정 레이블
examples = [
    {
        "input": "제품이 너무 빨리 배송되어서 놀랐어요! 정말 만족합니다.",
        "output": "긍정"
    },
    {
        "input": "배송이 늦어서 아쉬웠습니다. 다음엔 개선 부탁드려요.",
        "output": "부정"
    },
    {
        "input": "고객 서비스가 정말 친절해서 기분이 좋았어요!",
        "output": "긍정"
    }
]

# 예제 프롬프트 템플릿 정의
example_prompt = ChatPromptTemplate.from_messages([
    ("human", "{input}"),
    ("ai", "{output}")
])

# FewShotChatMessagePromptTemplate 설정
few_shot_prompt = FewShotChatMessagePromptTemplate(
    examples=examples,
    example_prompt=example_prompt
)

# 최종 프롬프트 템플릿
final_prompt = ChatPromptTemplate.from_messages([
    ("system", "당신은 고객 문의의 감정을 긍정 또는 부정으로 분류하는 전문가입니다. 다음 예제를 참고하여 응답하세요."),
    few_shot_prompt,
    ("human", "{input}")
])

# 체인 구성
chain = final_prompt | llm

# 테스트 입력
test_input = "제품 품질이 기대 이상이었어요! 다음에도 구매할게요."
response = chain.invoke({"input": test_input})

print(f"입력: {test_input}")
print(f"출력: {response.content}")

입력: 제품 품질이 기대 이상이었어요! 다음에도 구매할게요. 출력: 긍정

코드 설명:

• 모델 초기화: ChatOllama를 사용하여 EXAONE3.5 모델을 로드합니다.
• 예제 정의: 고객 문의와 해당 감정(긍정/부정)을 쌍으로 제공합니다.
• 예제 프롬프트: ChatPromptTemplate을 사용하여 입력과 출력을 대화 형식으로 정의합니다.
• FewShot 프롬프트: FewShotChatMessagePromptTemplate로 예제를 묶어 모델에 전달합니다.
• 최종 프롬프트: 시스템 메시지와 FewShot 프롬프트를 결합하여 최종 프롬프트를 생성합니다.
• 체인 실행: 입력 데이터를 프롬프트에 적용하고 모델을 호출하여 결과를 얻습니다.

다음은 고급 활용으로 FewShotChatMessagePromptTemplate는 단순한 텍스트 분류뿐만 아니라 다양한 작업에 활용될 수 있습니다. 예를 들어:

• 질문 답변: 특정 도메인의 질문에 대한 답변 형식을 학습.
• 텍스트 생성: 특정 스타일의 글쓰기(예: 공식 문서, 캐주얼 대화)를 유도.
• 작업 자동화: 고객 문의에 대한 자동 응답 템플릿 생성.

고급 예제는 고객 문의에 대한 자동 응답이며, 고객 문의에 대한 자동 응답 템플릿을 생성하는 예제를 살펴보겠습니다.

from langchain.prompts import FewShotChatMessagePromptTemplate, ChatPromptTemplate
from langchain_ollama import ChatOllama

# 모델 초기화
llm = ChatOllama(model="exaone3.5")

# 예제 데이터
examples = [
    {
        "input": "배송 상태를 알려주세요.",
        "output": "안녕하세요! 배송 상태를 확인하려면 주문 번호를 말씀해 주세요."
    },
    {
        "input": "제품이 언제 도착하나요?",
        "output": "안녕하세요! 주문하신 제품의 예상 도착 날짜를 확인하려면 주문 번호를 알려주시면 빠르게 확인해드리겠습니다."
    }
]

# 예제 프롬프트
example_prompt = ChatPromptTemplate.from_messages([
    ("human", "{input}"),
    ("ai", "{output}")
])

# FewShot 프롬프트
few_shot_prompt = FewShotChatMessagePromptTemplate(
    examples=examples,
    example_prompt=example_prompt
)

# 최종 프롬프트
final_prompt = ChatPromptTemplate.from_messages([
    ("system", "당신은 고객 문의에 친절하게 응답하는 챗봇입니다. 예제를 참고하여 자연스럽게 답변하세요."),
    few_shot_prompt,
    ("human", "{input}")
])

# 체인 구성
chain = final_prompt | llm

# 테스트
test_input = "주문한 물건이 언제 올까요?"
response = chain.invoke({"input": test_input})

print(f"입력: {test_input}")
print(f"출력: {response.content}")

입력: 주문한 물건이 언제 올까요? 출력: 주문 번호를 알려주시면 정확한 배송 예정일을 확인해 드릴 수 있습니다. 혹시 아직 주문 번호를 확인하지 못하셨다면, 주문 확인 이메일이나 주문 내역을 확인하시면 쉽게 찾으실 수 있을 거예요. 주문 번호를 알려주시겠어요?

FewShotChatMessagePromptTemplate는 LangChain에서 소수 샷 학습을 구현하는 데 매우 효과적인 도구입니다. 이를 다양한 실제 시나리오에 쉽게 적용할 수 있습니다.