OUTPUT PARSER Archives

[PYTHON/LANGCHAIN] BaseOutputParser 클래스 : 커스텀 출력 파서를 체인에서 사용하기

■ BaseOutputParser 클래스를 사용해 커스텀 출력 파서를 체인에서 사용하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                        import load_dotenv
from langchain_core.output_parsers import BaseOutputParser
from langchain_core.exceptions     import OutputParserException
from langchain_openai              import ChatOpenAI

load_dotenv()

class CustomOutputParser(BaseOutputParser[bool]):
    """Custom boolean parser."""

    trueString  : str = "YES"
    falseString : str = "NO"

    def parse(self, text : str) -> bool:
        textCleaned = text.strip().upper()
        if textCleaned not in (self.trueString.upper(), self.falseString.upper()):
            raise OutputParserException(
                f"BooleanOutputParser expected output value to either be "
                f"{self.trueString} or {self.falseString} (case-insensitive). "
                f"Received {textCleaned}."
            )
        return textCleaned == self.trueString.upper()

    @property
    def _type(self) -> str:
        return "custom_output_parser"

chatOpenAI = ChatOpenAI(model_name = "gpt-4o")

customOutputParser = CustomOutputParser()

runnableSequence = chatOpenAI | customOutputParser

responseString = runnableSequence.invoke("say YES or NO")

print(responseString)

"""
True
"""

from dotenv import load_dotenv

from langchain_core.output_parsers import BaseOutputParser

from langchain_core.exceptions import OutputParserException

from langchain_openai import ChatOpenAI

load_dotenv()

class CustomOutputParser(BaseOutputParser[bool]):

"""Custom boolean parser."""

trueString : str = "YES"

falseString : str = "NO"

def parse(self, text : str) -> bool:

textCleaned = text.strip().upper()

if textCleaned not in (self.trueString.upper(), self.falseString.upper()):

raise OutputParserException(

f"BooleanOutputParser expected output value to either be "

f"{self.trueString} or {self.falseString} (case-insensitive). "

f"Received {textCleaned}."

)

return textCleaned == self.trueString.upper()

@property

def _type(self) -> str:

return "custom_output_parser"

chatOpenAI = ChatOpenAI(model_name = "gpt-4o")

customOutputParser = CustomOutputParser()

runnableSequence = chatOpenAI | customOutputParser

responseString = runnableSequence.invoke("say YES or NO")

print(responseString)

"""

True

"""

[PYTHON/LANGCHAIN] BaseOutputParser 클래스 : 커스텀 출력 파서 만들기

■ BaseOutputParser 클래스를 사용해 커스텀 출력 파서를 만드는 방법을 보여준다. ▶ main.py


from langchain_core.output_parsers import BaseOutputParser
from langchain_core.exceptions     import OutputParserException

# [bool]은 제네릭의 매개변수화를 설명한다.
# 기본적으로 parse의 반환 유형이 무엇인지 나타낸다. 이 경우 반환 유형은 True 또는 False이다.
class CustomOutputParser(BaseOutputParser[bool]):
    """Custom boolean parser."""

    trueString  : str = "YES"
    falseString : str = "NO"

    def parse(self, text : str) -> bool:
        textCleaned = text.strip().upper()
        if textCleaned not in (self.trueString.upper(), self.falseString.upper()):
            raise OutputParserException(
                f"BooleanOutputParser expected output value to either be "
                f"{self.trueString} or {self.falseString} (case-insensitive). "
                f"Received {textCleaned}."
            )
        return textCleaned == self.trueString.upper()

    @property
    def _type(self) -> str:
        return "custom_output_parser"

customOutputParser = CustomOutputParser()

responseValue1 = customOutputParser.invoke("YES")

print(responseValue1)
print("-" * 50)

try:
    customOutputParser.invoke("MEOW")
except Exception as exception:
    print(f"Triggered an exception of type: {type(exception)}")
print("-" * 50)

customOutputParser2 = CustomOutputParser(trueString = "OKAY")

responseValue2 = customOutputParser2.invoke("OKAY")

print(responseValue2)
print("-" * 50)

responseValueList = customOutputParser2.batch(["OKAY", "NO"])

print(responseValueList)
print("-" * 50)

"""
True
--------------------------------------------------
Triggered an exception of type: <class 'langchain_core.exceptions.OutputParserException'>
--------------------------------------------------
True
--------------------------------------------------
[True, False]
--------------------------------------------------
"""

from langchain_core.output_parsers import BaseOutputParser

from langchain_core.exceptions import OutputParserException

# [bool]은 제네릭의 매개변수화를 설명한다.

# 기본적으로 parse의 반환 유형이 무엇인지 나타낸다. 이 경우 반환 유형은 True 또는 False이다.

class CustomOutputParser(BaseOutputParser[bool]):

"""Custom boolean parser."""

trueString : str = "YES"

falseString : str = "NO"

def parse(self, text : str) -> bool:

textCleaned = text.strip().upper()

if textCleaned not in (self.trueString.upper(), self.falseString.upper()):

raise OutputParserException(

f"BooleanOutputParser expected output value to either be "

f"{self.trueString} or {self.falseString} (case-insensitive). "

f"Received {textCleaned}."

)

return textCleaned == self.trueString.upper()

@property

def _type(self) -> str:

return "custom_output_parser"

customOutputParser = CustomOutputParser()

responseValue1 = customOutputParser.invoke("YES")

print(responseValue1)

print("-" * 50)

try:

customOutputParser.invoke("MEOW")

except Exception as exception:

print(f"Triggered an exception of type: {type(exception)}")

print("-" * 50)

customOutputParser2 = CustomOutputParser(trueString = "OKAY")

responseValue2 = customOutputParser2.invoke("OKAY")

print(responseValue2)

print("-" * 50)

responseValueList = customOutputParser2.batch(["OKAY", "NO"])

print(responseValueList)

print("-" * 50)

"""

True

--------------------------------------------------

Triggered an exception of type: <class 'langchain_core.exceptions.OutputParserException'>

--------------------------------------------------

True

--------------------------------------------------

[True, False]

--------------------------------------------------

"""

▶ requirements.txt


aiohappyeyeballs==2.4.3
aiohttp==3.11.7
aiosignal==1.3.1
annotated-types==0.7.0
anyio==4.6.2.post1
attrs==24.2.0
certifi==2024.8.30
charset-normalizer==3.4.0
frozenlist==1.5.0
greenlet==3.1.1
h11==0.14.0
httpcore==1.0.7
httpx==0.27.2
idna==3.10
jsonpatch==1.33
jsonpointer==3.0.0
langchain==0.3.8
langchain-core==0.3.21
langchain-text-splitters==0.3.2
langsmith==0.1.145
multidict==6.1.0
numpy==1.26.4
orjson==3.10.12
packaging==24.2
propcache==0.2.0
pydantic==2.10.1
pydantic_core==2.27.1
PyYAML==6.0.2
requests==2.32.3
requests-toolbelt==1.0.0
sniffio==1.3.1
SQLAlchemy==2.0.36
tenacity==9.0.0
typing_extensions==4.12.2
urllib3==2.2.3
yarl==1.18.0

aiohappyeyeballs==2.4.3

aiohttp==3.11.7

aiosignal==1.3.1

annotated-types==0.7.0

anyio==4.6.2.post1

attrs==24.2.0

certifi==2024.8.30

charset-normalizer==3.4.0

frozenlist==1.5.0

greenlet==3.1.1

h11==0.14.0

httpcore==1.0.7

httpx==0.27.2

idna==3.10

jsonpatch==1.33

jsonpointer==3.0.0

langchain==0.3.8

langchain-core==0.3.21

langchain-text-splitters==0.3.2

langsmith==0.1.145

multidict==6.1.0

numpy==1.26.4

orjson==3.10.12

packaging==24.2

propcache==0.2.0

pydantic==2.10.1

pydantic_core==2.27.1

PyYAML==6.0.2

requests==2.32.3

requests-toolbelt==1.0.0

sniffio==1.3.1

SQLAlchemy==2.0.36

tenacity==9.0.0

typing_extensions==4.12.2

urllib3==2.2.3

yarl==1.18.0

※ pip install langchain 명령을 실행했다.

[PYTHON/LANGCHAIN] RunnableGenerator 클래스 : 커스텀 출력 파서 만들기

■ RunnableGenerator 클래스를 사용해 커스텀 출력 파서를 만드는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                   import load_dotenv
from langchain_openai         import ChatOpenAI
from langchain_core.messages  import AIMessageChunk
from typing                   import Iterable
from langchain_core.runnables import RunnableGenerator

load_dotenv()

chatOpenAI = ChatOpenAI(model_name = "gpt-4o")

def streamingParse(tee : Iterable[AIMessageChunk]) -> Iterable[str]: # tee의 데이터 타입은 itertools._tee이다.
    for chunk in tee: # chunk 데이터 타입은 AIMessage 또는 AIMessageChunk가 된다.
        yield chunk.content.swapcase()

runnableGenerator = RunnableGenerator(streamingParse)

runnableSequence = chatOpenAI | runnableGenerator

responseString = runnableSequence.invoke("hello")

print(responseString)
print("-" * 50)

for chunkString in runnableSequence.stream("tell me about yourself in one sentence"):
    print(chunkString, end = "|", flush = True)
print()
print("-" * 50)

"""
hELLO! hOW CAN i ASSIST YOU TODAY?
--------------------------------------------------
|i'M| A| LANGUAGE| MODEL| DESIGNED| BY| oPEN|ai| TO| ASSIST| WITH| A| WIDE| RANGE| OF| QUESTIONS| AND| TASKS| BY| PROVIDING| INFORMATION| AND| GENERATING| TEXT|-BASED| RESPONSES|.||
--------------------------------------------------
"""

from dotenv import load_dotenv

from langchain_openai import ChatOpenAI

from langchain_core.messages import AIMessageChunk

from typing import Iterable

from langchain_core.runnables import RunnableGenerator

load_dotenv()

chatOpenAI = ChatOpenAI(model_name = "gpt-4o")

def streamingParse(tee : Iterable[AIMessageChunk]) -> Iterable[str]: # tee의 데이터 타입은 itertools._tee이다.

for chunk in tee: # chunk 데이터 타입은 AIMessage 또는 AIMessageChunk가 된다.

yield chunk.content.swapcase()

runnableGenerator = RunnableGenerator(streamingParse)

runnableSequence = chatOpenAI | runnableGenerator

responseString = runnableSequence.invoke("hello")

print(responseString)

print("-" * 50)

for chunkString in runnableSequence.stream("tell me about yourself in one sentence"):

print(chunkString, end = "|", flush = True)

print()

print("-" * 50)

"""

hELLO! hOW CAN i ASSIST YOU TODAY?

--------------------------------------------------

|i'M| A| LANGUAGE| MODEL| DESIGNED| BY| oPEN|ai| TO| ASSIST| WITH| A| WIDE| RANGE| OF| QUESTIONS| AND| TASKS| BY| PROVIDING| INFORMATION| AND| GENERATING| TEXT|-BASED| RESPONSES|.||

--------------------------------------------------

"""

▶

[PYTHON/LANGCHAIN] RunnableLambda 클래스 : 커스텀 출력 파서 만들기

■ RunnableLambda 클래스를 사용해 커스텀 출력 파서를 만드는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ※ LCEL은 | 구문을

[PYTHON/LANGCHAIN] PydanticToolsParser 클래스 : 생성자에서 tools 인자를 사용해 도구 호출 정보 반환하기

■ PydanticToolsParser 클래스의 생성자에서 tools 인자를 사용해 도구 호출 정보를 반환하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶

[PYTHON/LANGCHAIN] StructuredQueryOutputParser 클래스 : from_components 정적 메소드를 사용해 StructuredQueryOutputParser 객체 만들기

■ StructuredQueryOutputParser 클래스의 from_components 정적 메소드를 사용해 StructuredQueryOutputParser 객체를 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


from langchain.chains.query_constructor.base import StructuredQueryOutputParser

structuredQueryOutputParser = StructuredQueryOutputParser.from_components()

from langchain.chains.query_constructor.base import StructuredQueryOutputParser

structuredQueryOutputParser = StructuredQueryOutputParser.from_components()

※ pip install langchain 명령을

[PYTHON/LANGCHAIN] OpenAI 클래스 : CommaSeparatedListOutputParser 객체 사용하기

■ OpenAI 클래스에서 CommaSeparatedListOutputParser 객체를 사용하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                        import load_dotenv
from langchain_core.output_parsers import CommaSeparatedListOutputParser
from langchain_core.prompts        import PromptTemplate
from langchain_openai              import OpenAI

load_dotenv()

commaSeparatedListOutputParser = CommaSeparatedListOutputParser()

formatInstructionString = commaSeparatedListOutputParser.get_format_instructions()

promptTemplate = PromptTemplate(
    template = "{주제} 5개를 추천해주세요.\n{format_instructions}",
    input_variables = ["주제"],
    partial_variables = {"format_instructions" : formatInstructionString}
)

openAI = OpenAI(temperature = 1)

runnableSequence = promptTemplate | openAI | commaSeparatedListOutputParser

responseList = runnableSequence.invoke({"주제" : "영화"})

for response in responseList:
    print(response)

from dotenv import load_dotenv

from langchain_core.output_parsers import CommaSeparatedListOutputParser

from langchain_core.prompts import PromptTemplate

from langchain_openai import OpenAI

load_dotenv()

commaSeparatedListOutputParser = CommaSeparatedListOutputParser()

formatInstructionString = commaSeparatedListOutputParser.get_format_instructions()

promptTemplate = PromptTemplate(

template = "{주제} 5개를 추천해주세요.\n{format_instructions}",

input_variables = ["주제"],

partial_variables = {"format_instructions" : formatInstructionString}

)

openAI = OpenAI(temperature = 1)

runnableSequence = promptTemplate | openAI | commaSeparatedListOutputParser

responseList = runnableSequence.invoke({"주제" : "영화"})

for response in responseList:

print(response)

▶ requirements.txt


annotated-types==0.7.0
anyio==4.4.0
certifi==2024.8.30
charset-normalizer==3.3.2
colorama==0.4.6
distro==1.9.0
h11==0.14.0
httpcore==1.0.5
httpx==0.27.2
idna==3.8
jiter==0.5.0
jsonpatch==1.33
jsonpointer==3.0.0
langchain-core==0.2.39
langchain-openai==0.1.23
langsmith==0.1.117
openai==1.44.1
orjson==3.10.7
packaging==24.1
pydantic==2.9.1
pydantic_core==2.23.3
python-dotenv==1.0.1
PyYAML==6.0.2
regex==2024.7.24
requests==2.32.3
sniffio==1.3.1
tenacity==8.5.0
tiktoken==0.7.0
tqdm==4.66.5
typing_extensions==4.12.2
urllib3==2.2.2

annotated-types==0.7.0

anyio==4.4.0

certifi==2024.8.30

charset-normalizer==3.3.2

colorama==0.4.6

distro==1.9.0

h11==0.14.0

httpcore==1.0.5

httpx==0.27.2

idna==3.8

jiter==0.5.0

jsonpatch==1.33

jsonpointer==3.0.0

langchain-core==0.2.39

langchain-openai==0.1.23

langsmith==0.1.117

openai==1.44.1

orjson==3.10.7

packaging==24.1

pydantic==2.9.1

pydantic_core==2.23.3

python-dotenv==1.0.1

PyYAML==6.0.2

regex==2024.7.24

requests==2.32.3

sniffio==1.3.1

tenacity==8.5.0

tiktoken==0.7.0

tqdm==4.66.5

typing_extensions==4.12.2

urllib3==2.2.2

[PYTHON/LANGCHAIN] CommaSeparatedListOutputParser 클래스 : get_format_instructions 메소드를 사용해 포맷 명령어 문자열 구하기

■ CommaSeparatedListOutputParser 클래스의 get_format_instructions 메소드를 사용해 포맷 명령어 문자열을 구하는 방법을 보여준다. ▶ main.py


from langchain_core.output_parsers import CommaSeparatedListOutputParser

commaSeparatedListOutputParser = CommaSeparatedListOutputParser()

formatInstructionString = commaSeparatedListOutputParser.get_format_instructions()

from langchain_core.output_parsers import CommaSeparatedListOutputParser

commaSeparatedListOutputParser = CommaSeparatedListOutputParser()

formatInstructionString = commaSeparatedListOutputParser.get_format_instructions()

▶ requirements.txt


aiohappyeyeballs==2.4.0
aiohttp==3.10.5
aiosignal==1.3.1
annotated-types==0.7.0
anyio==4.4.0
attrs==24.2.0
certifi==2024.8.30
charset-normalizer==3.3.2
frozenlist==1.4.1
greenlet==3.1.0
h11==0.14.0
httpcore==1.0.5
httpx==0.27.2
idna==3.8
jsonpatch==1.33
jsonpointer==3.0.0
langchain==0.2.16
langchain-core==0.2.39
langchain-text-splitters==0.2.4
langsmith==0.1.117
multidict==6.1.0
numpy==1.26.4
orjson==3.10.7
packaging==24.1
pydantic==2.9.1
pydantic_core==2.23.3
PyYAML==6.0.2
requests==2.32.3
sniffio==1.3.1
SQLAlchemy==2.0.34
tenacity==8.5.0
typing_extensions==4.12.2
urllib3==2.2.2
yarl==1.11.1

aiohappyeyeballs==2.4.0

aiohttp==3.10.5

aiosignal==1.3.1

annotated-types==0.7.0

anyio==4.4.0

attrs==24.2.0

certifi==2024.8.30

charset-normalizer==3.3.2

frozenlist==1.4.1

greenlet==3.1.0

h11==0.14.0

httpcore==1.0.5

httpx==0.27.2

idna==3.8

jsonpatch==1.33

jsonpointer==3.0.0

langchain==0.2.16

langchain-core==0.2.39

langchain-text-splitters==0.2.4

langsmith==0.1.117

multidict==6.1.0

numpy==1.26.4

orjson==3.10.7

packaging==24.1

pydantic==2.9.1

pydantic_core==2.23.3

PyYAML==6.0.2

requests==2.32.3

sniffio==1.3.1

SQLAlchemy==2.0.34

tenacity==8.5.0

typing_extensions==4.12.2

urllib3==2.2.2

yarl==1.11.1

※ pip install langchain

[PYTHON/LANGCHAIN] BaseOutputParser 클래스 : 커스텀 출력 파서 만들기

■ BaseOutputParser 클래스를 사용해 커스텀 출력 파서를 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


from typing import List

from langchain_core.output_parsers import BaseOutputParser

class LineListOutputParser(BaseOutputParser[List[str]]):
    """Output parser for a list of lines."""

    def parse(self, text : str) -> List[str]:
        lineList = text.strip().split("\n")
        return list(filter(None, lineList))

from typing import List

from langchain_core.output_parsers import BaseOutputParser

class LineListOutputParser(BaseOutputParser[List[str]]):

"""Output parser for a list of lines."""

def parse(self, text : str) -> List[str]:

lineList = text.strip().split("\n")

return list(filter(None, lineList))

[PYTHON/LANGCHAIN] BaseGenerationOutputParser 클래스 : 커스텀 문자열 반전 출력 파서 만들기

■ BaseGenerationOutputParser 클래스를 사용해 커스텀 문자열 반전 출력 파서를 만드는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py

[PYTHON/LANGCHAIN] BaseOutputParser 클래스 : 커스텀 논리값 출력 파서를 체인에서 실행하기

■ BaseOutputParser 클래스를 사용해 커스텀 논리값 출력 파서를 체인에서 실행하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py

[PYTHON/LANGCHAIN] BaseOutputParser 클래스 : 커스텀 논리값 출력 파서 만들기

■ BaseOutputParser 클래스를 사용해 커스텀 논리값 출력 파서를 만드는 방법을 보여준다. ▶ main.py


from langchain_core.exceptions     import OutputParserException
from langchain_core.output_parsers import BaseOutputParser

# [bool]에서는 제네릭의 매개변수화에 대해 설명한다.
# 기본적으로 구문 분석의 반환 유형이 무엇인지 나타낸다.
# 이 경우 반환 유형은 True 또는 False이다.
class BooleanOutputParser(BaseOutputParser[bool]):
    """사용자 논리값 파서"""

    true_value  : str = "YES"
    false_value : str = "NO"

    def parse(self, sourceText : str) -> bool:
        targetText = sourceText.strip().upper()

        if targetText not in (self.true_value.upper(), self.false_value.upper()):
            raise OutputParserException(
                f"BooleanOutputParser expected output value to either be "
                f"{self.true_value} or {self.false_value} (case-insensitive). "
                f"Received {targetText}."
            )

        return targetText == self.true_value.upper()

    @property
    def _type(self) -> str:
        return "boolean_output_parser"

booleanOutputParser1 = BooleanOutputParser()

responseBool1 = booleanOutputParser1.invoke("yes")

print(responseBool1)

"""
True
"""

booleanOutputParser2 = BooleanOutputParser(true_value = "ON", false_value = "OFF")

responseBool2 = booleanOutputParser2.invoke("on")

print(responseBool2)

"""
True
"""

booleanOutputParser3 = BooleanOutputParser(true_value = "OPEN", false_value = "CLOSED")

responseBoolList3 = booleanOutputParser3.batch(["open", "closed"])

print(responseBoolList3)

"""
[True, False]
"""

from langchain_core.exceptions import OutputParserException

from langchain_core.output_parsers import BaseOutputParser

# [bool]에서는 제네릭의 매개변수화에 대해 설명한다.

# 기본적으로 구문 분석의 반환 유형이 무엇인지 나타낸다.

# 이 경우 반환 유형은 True 또는 False이다.

class BooleanOutputParser(BaseOutputParser[bool]):

"""사용자 논리값 파서"""

true_value : str = "YES"

false_value : str = "NO"

def parse(self, sourceText : str) -> bool:

targetText = sourceText.strip().upper()

if targetText not in (self.true_value.upper(), self.false_value.upper()):

raise OutputParserException(

f"BooleanOutputParser expected output value to either be "

f"{self.true_value} or {self.false_value} (case-insensitive). "

f"Received {targetText}."

)

return targetText == self.true_value.upper()

@property

def _type(self) -> str:

return "boolean_output_parser"

booleanOutputParser1 = BooleanOutputParser()

responseBool1 = booleanOutputParser1.invoke("yes")

print(responseBool1)

"""

True

"""

booleanOutputParser2 = BooleanOutputParser(true_value = "ON", false_value = "OFF")

responseBool2 = booleanOutputParser2.invoke("on")

print(responseBool2)

"""

True

"""

booleanOutputParser3 = BooleanOutputParser(true_value = "OPEN", false_value = "CLOSED")

responseBoolList3 = booleanOutputParser3.batch(["open", "closed"])

print(responseBoolList3)

"""

[True, False]

"""

▶ requirements.txt


aiohttp==3.9.5
aiosignal==1.3.1
annotated-types==0.7.0
async-timeout==4.0.3
attrs==23.2.0
certifi==2024.6.2
charset-normalizer==3.3.2
frozenlist==1.4.1
greenlet==3.0.3
idna==3.7
jsonpatch==1.33
jsonpointer==3.0.0
langchain==0.2.6
langchain-core==0.2.10
langchain-text-splitters==0.2.2
langsmith==0.1.82
multidict==6.0.5
numpy==1.26.4
orjson==3.10.5
packaging==24.1
pydantic==2.7.4
pydantic_core==2.18.4
PyYAML==6.0.1
requests==2.32.3
SQLAlchemy==2.0.31
tenacity==8.4.2
typing_extensions==4.12.2
urllib3==2.2.2
yarl==1.9.4

aiohttp==3.9.5

aiosignal==1.3.1

annotated-types==0.7.0

async-timeout==4.0.3

attrs==23.2.0

certifi==2024.6.2

charset-normalizer==3.3.2

frozenlist==1.4.1

greenlet==3.0.3

idna==3.7

jsonpatch==1.33

jsonpointer==3.0.0

langchain==0.2.6

langchain-core==0.2.10

langchain-text-splitters==0.2.2

langsmith==0.1.82

multidict==6.0.5

numpy==1.26.4

orjson==3.10.5

packaging==24.1

pydantic==2.7.4

pydantic_core==2.18.4

PyYAML==6.0.1

requests==2.32.3

SQLAlchemy==2.0.31

tenacity==8.4.2

typing_extensions==4.12.2

urllib3==2.2.2

yarl==1.9.4

※ pip install langchain 명령을

[PYTHON/LANGCHAIN] RunnableGenerator 클래스 : Iterable 입출력 인자를 갖는 커스텀 함수를 명시적으로 감싸기

■ RunnableGenerator 클래스를 사용해 Iterable 입출력 인자를 갖는 커스텀 함수를 명시적으로 감싸는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다.

[PYTHON/LANGCHAIN] Iterable 입출력 인자를 갖는 커스텀 함수를 사용해 커스텀 출력 파서 체인에서 스트리밍하기

■ Iterable 입출력 인자를 갖는 커스텀 함수를 사용해 커스텀 출력 파서 체인에서 스트리밍하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에

[PYTHON/LANGCHAIN] Iterable 입출력 인자를 갖는 커스텀 함수를 사용해 커스텀 출력 파서 만들기

■ Iterable 입출력 인자를 갖는 커스텀 함수를 사용해 커스텀 출력 파서를 만드는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다.

[PYTHON/LANGCHAIN] RunnableLambda 클래스 : 커스텀 함수를 암시적 변환을 통해 커스텀 출력 파서 만들기

■ RunnableLambda 클래스에서 커스텀 함수를 암시적 변환을 통해 커스텀 출력 파서를 만드는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다.

[PYTHON/LANGCHAIN] OutputFixingParser 클래스 : 파싱 오류 발생시 재시도하기

■ OutputFixingParser 클래스를 사용해 파싱 오류 발생시 재시도하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                        import load_dotenv
from langchain_core.pydantic_v1    import BaseModel
from langchain_core.pydantic_v1    import Field
from langchain_core.output_parsers import PydanticOutputParser
from langchain_core.prompts        import PromptTemplate
from langchain_openai              import OpenAI
from langchain.output_parsers      import OutputFixingParser
from langchain_core.runnables      import RunnableParallel
from langchain_core.runnables      import RunnableLambda

load_dotenv()

class Action(BaseModel):
    action       : str = Field(description = "action to take"     )
    action_input : str = Field(description = "input to the action")

pydanticOutputParser = PydanticOutputParser(pydantic_object = Action)

promptTemplate = PromptTemplate(
    template          = "Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables   = ["query"],
    partial_variables = {"format_instructions": pydanticOutputParser.get_format_instructions()}
)

openAI = OpenAI(temperature = 0)

completionRunnableSequence = promptTemplate | openAI

outputFixingParser = OutputFixingParser.from_llm(parser = pydanticOutputParser, llm = openAI)

executeRunnableSequence = RunnableParallel(completion = completionRunnableSequence, prompt_value = promptTemplate) \
    | RunnableLambda(lambda x : outputFixingParser.parse_with_prompt(**x))

action = executeRunnableSequence.invoke({"query" : "who is leo di caprios gf?"})

print(action)

"""
action='search' action_input='leo di caprios gf'
"""

from dotenv import load_dotenv

from langchain_core.pydantic_v1 import BaseModel

from langchain_core.pydantic_v1 import Field

from langchain_core.output_parsers import PydanticOutputParser

from langchain_core.prompts import PromptTemplate

from langchain_openai import OpenAI

from langchain.output_parsers import OutputFixingParser

from langchain_core.runnables import RunnableParallel

from langchain_core.runnables import RunnableLambda

load_dotenv()

class Action(BaseModel):

action : str = Field(description = "action to take" )

action_input : str = Field(description = "input to the action")

pydanticOutputParser = PydanticOutputParser(pydantic_object = Action)

promptTemplate = PromptTemplate(

template = "Answer the user query.\n{format_instructions}\n{query}\n",

input_variables = ["query"],

partial_variables = {"format_instructions": pydanticOutputParser.get_format_instructions()}

)

openAI = OpenAI(temperature = 0)

completionRunnableSequence = promptTemplate | openAI

outputFixingParser = OutputFixingParser.from_llm(parser = pydanticOutputParser, llm = openAI)

executeRunnableSequence = RunnableParallel(completion = completionRunnableSequence, prompt_value = promptTemplate) \

| RunnableLambda(lambda x : outputFixingParser.parse_with_prompt(**x))

action = executeRunnableSequence.invoke({"query" : "who is leo di caprios gf?"})

print(action)

"""

action='search' action_input='leo di caprios gf'

"""

▶

[PYTHON/LANGCHAIN] RetryOutputParser 클래스 : 파싱 오류 발생시 모델을 다시 실행해 새로운 출력을 얻어 재시도하기

■ RetryOutputParser 클래스를 사용해 파싱 오류 발생시 모델을 다시 실행해 새로운 출력을 얻어 재시도하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env

[PYTHON/LANGCHAIN] YamlOutputParser 클래스 : 체인에서 구조화된 데이터 구하기

■ YamlOutputParser 클래스를 사용해 체인에서 구조화된 데이터를 구하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                     import load_dotenv
from langchain_core.pydantic_v1 import BaseModel
from langchain_core.pydantic_v1 import Field
from langchain.output_parsers   import YamlOutputParser
from langchain_core.prompts     import PromptTemplate
from langchain_openai           import ChatOpenAI

load_dotenv()

class Joke(BaseModel):
    setup     : str = Field(description = "question to set up a joke" )
    punchline : str = Field(description = "answer to resolve the joke")

yamlOutputParser = YamlOutputParser(pydantic_object = Joke)

promptTemplate = PromptTemplate(
    template          = "Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables   = ["query"],
    partial_variables = {"format_instructions" : yamlOutputParser.get_format_instructions()}
)

chatOpenAI = ChatOpenAI(temperature = 0)

runnableSequence = promptTemplate | chatOpenAI | yamlOutputParser

joke = runnableSequence.invoke({"query" : "Tell me a joke."})

print(joke)

"""
setup="Why couldn't the bicycle find its way home?" punchline='Because it lost its bearings!'
"""

from dotenv import load_dotenv

from langchain_core.pydantic_v1 import BaseModel

from langchain_core.pydantic_v1 import Field

from langchain.output_parsers import YamlOutputParser

from langchain_core.prompts import PromptTemplate

from langchain_openai import ChatOpenAI

load_dotenv()

class Joke(BaseModel):

setup : str = Field(description = "question to set up a joke" )

punchline : str = Field(description = "answer to resolve the joke")

yamlOutputParser = YamlOutputParser(pydantic_object = Joke)

promptTemplate = PromptTemplate(

template = "Answer the user query.\n{format_instructions}\n{query}\n",

input_variables = ["query"],

partial_variables = {"format_instructions" : yamlOutputParser.get_format_instructions()}

)

chatOpenAI = ChatOpenAI(temperature = 0)

runnableSequence = promptTemplate | chatOpenAI | yamlOutputParser

joke = runnableSequence.invoke({"query" : "Tell me a joke."})

print(joke)

"""

setup="Why couldn't the bicycle find its way home?" punchline='Because it lost its bearings!'

"""

▶

[PYTHON/LANGCHAIN] XMLOutputParser 클래스 : 체인에서 구조화된 데이터 구하기

■ XMLOutputParser 클래스를 사용해 체인에서 구조화된 데이터를 구하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                        import load_dotenv
from langchain_core.prompts        import PromptTemplate
from langchain_openai              import OpenAI
from langchain_core.output_parsers import XMLOutputParser

load_dotenv()

xmlOutputParser = XMLOutputParser()

promptTemplate = PromptTemplate(
    template          = "{query}\n{format_instructions}",
    input_variables   = ["query"],
    partial_variables = {"format_instructions" : xmlOutputParser.get_format_instructions()},
)

openAI = OpenAI(temperature = 0.0, max_tokens = 512)

runnableSequence = promptTemplate | openAI | xmlOutputParser

responseDictionary = runnableSequence.invoke({"query" : "Generate the shortened filmography for Tom Hanks."})

print(responseDictionary)

"""
{'filmography': [{'film': [{'title': 'Forrest Gump'}, {'year': '1994'}]}, {'film': [{'title': 'Cast Away'}, {'year': '2000'}]}, {'film': [{'title': 'Saving Private Ryan'}, {'year': '1998'}]}, {'film': [{'title': 'Apollo 13'}, {'year': '1995'}]}, {'film': [{'title': 'The Green Mile'}, {'year': '1999'}]}, {'film': [{'title': 'Toy Story'}, {'year': '1995'}]}, {'film': [{'title': 'Toy Story 2'}, {'year': '1999'}]}, {'film': [{'title': 'Toy Story 3'}, {'year': '2010'}]}, {'film': [{'title': 'Philadelphia'}, {'year': '1993'}]}, {'film': [{'title': 'Big'}, {'year': '1988'}]}]}
"""

from dotenv import load_dotenv

from langchain_core.prompts import PromptTemplate

from langchain_openai import OpenAI

from langchain_core.output_parsers import XMLOutputParser

load_dotenv()

xmlOutputParser = XMLOutputParser()

promptTemplate = PromptTemplate(

template = "{query}\n{format_instructions}",

input_variables = ["query"],

partial_variables = {"format_instructions" : xmlOutputParser.get_format_instructions()},

)

openAI = OpenAI(temperature = 0.0, max_tokens = 512)

runnableSequence = promptTemplate | openAI | xmlOutputParser

responseDictionary = runnableSequence.invoke({"query" : "Generate the shortened filmography for Tom Hanks."})

print(responseDictionary)

"""

{'filmography': [{'film': [{'title': 'Forrest Gump'}, {'year': '1994'}]}, {'film': [{'title': 'Cast Away'}, {'year': '2000'}]}, {'film': [{'title': 'Saving Private Ryan'}, {'year': '1998'}]}, {'film': [{'title': 'Apollo 13'}, {'year': '1995'}]}, {'film': [{'title': 'The Green Mile'}, {'year': '1999'}]}, {'film': [{'title': 'Toy Story'}, {'year': '1995'}]}, {'film': [{'title': 'Toy Story 2'}, {'year': '1999'}]}, {'film': [{'title': 'Toy Story 3'}, {'year': '2010'}]}, {'film': [{'title': 'Philadelphia'}, {'year': '1993'}]}, {'film': [{'title': 'Big'}, {'year': '1988'}]}]}

"""

▶

[PYTHON/LANGCHAIN] JsonOutputParser 클래스 : 생성자에서 pydantic_object 인자 지정없이 체인에서 구조화된 데이터 구하기

■ JsonOutputParser 클래스의 생성자에서 pydantic_object 인자 지정없이 체인에서 구조화된 데이터를 구하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶

[PYTHON/LANGCHAIN] JsonOutputParser 클래스 : 체인에서 구조화된 데이터 구하기

■ JsonOutputParser 클래스를 사용해 체인에서 구조화된 데이터를 구하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                        import load_dotenv
from langchain_core.pydantic_v1    import BaseModel
from langchain_core.pydantic_v1    import Field
from langchain_core.prompts        import PromptTemplate
from langchain_openai              import OpenAI
from langchain_core.output_parsers import JsonOutputParser

load_dotenv()

class Joke(BaseModel):
    setup     : str = Field(description = "question to set up a joke" )
    punchline : str = Field(description = "answer to resolve the joke")

jsonOutputParser = JsonOutputParser(pydantic_object = Joke)

promptTemplate = PromptTemplate(
    template          = "Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables   = ["query"],
    partial_variables = {"format_instructions" : jsonOutputParser.get_format_instructions()},
)

openAI = OpenAI(model_name = "gpt-3.5-turbo-instruct", temperature = 0.0)

runnableSequence = promptTemplate | openAI | jsonOutputParser

responseDictionary = runnableSequence.invoke({"query" : "Tell me a joke."})

print(responseDictionary)

"""
{'setup' : 'Why did the tomato turn red?', 'punchline' : 'Because it saw the salad dressing!'}
"""

from dotenv import load_dotenv

from langchain_core.pydantic_v1 import BaseModel

from langchain_core.pydantic_v1 import Field

from langchain_core.prompts import PromptTemplate

from langchain_openai import OpenAI

from langchain_core.output_parsers import JsonOutputParser

load_dotenv()

class Joke(BaseModel):

setup : str = Field(description = "question to set up a joke" )

punchline : str = Field(description = "answer to resolve the joke")

jsonOutputParser = JsonOutputParser(pydantic_object = Joke)

promptTemplate = PromptTemplate(

template = "Answer the user query.\n{format_instructions}\n{query}\n",

input_variables = ["query"],

partial_variables = {"format_instructions" : jsonOutputParser.get_format_instructions()},

)

openAI = OpenAI(model_name = "gpt-3.5-turbo-instruct", temperature = 0.0)

runnableSequence = promptTemplate | openAI | jsonOutputParser

responseDictionary = runnableSequence.invoke({"query" : "Tell me a joke."})

print(responseDictionary)

"""

{'setup' : 'Why did the tomato turn red?', 'punchline' : 'Because it saw the salad dressing!'}

"""

▶

[PYTHON/LANGCHAIN] SimpleJsonOutputParser 클래스 : 체인에서 구조화된 데이터 구하기

■ SimpleJsonOutputParser 클래스를 사용해 체인에서 구조화된 데이터를 구하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                        import load_dotenv
from langchain_core.prompts        import PromptTemplate
from langchain_openai              import OpenAI
from langchain.output_parsers.json import SimpleJsonOutputParser

load_dotenv()

promptTemplat = PromptTemplate.from_template(
    "Return a JSON object with an `answer` key that answers the following question : {question}"
)

openAI = OpenAI(model_name = "gpt-3.5-turbo-instruct", temperature = 0.0)

runnableSequence = promptTemplat | openAI | SimpleJsonOutputParser()

responseDictionary = runnableSequence.invoke({"question" : "Who invented the microscope?"})

print(responseDictionary)

"""
{'answer': 'Antonie van Leeuwenhoek'}
"""

from dotenv import load_dotenv

from langchain_core.prompts import PromptTemplate

from langchain_openai import OpenAI

from langchain.output_parsers.json import SimpleJsonOutputParser

load_dotenv()

promptTemplat = PromptTemplate.from_template(

"Return a JSON object with an `answer` key that answers the following question : {question}"

)

openAI = OpenAI(model_name = "gpt-3.5-turbo-instruct", temperature = 0.0)

runnableSequence = promptTemplat | openAI | SimpleJsonOutputParser()

responseDictionary = runnableSequence.invoke({"question" : "Who invented the microscope?"})

print(responseDictionary)

"""

{'answer': 'Antonie van Leeuwenhoek'}

"""

▶

[PYTHON/LANGCHAIN] PydanticOutputParser 클래스 : 체인에서 사용해 구조화된 데이터 구하기

■ PydanticOutputParser 클래스를 체인에서 사용해 구조화된 데이터를 구하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                        import load_dotenv
from langchain_core.pydantic_v1    import BaseModel
from langchain_core.pydantic_v1    import Field
from langchain_core.pydantic_v1    import validator
from langchain_core.prompts        import PromptTemplate
from langchain_openai              import OpenAI
from langchain_core.output_parsers import PydanticOutputParser

load_dotenv()

class Joke(BaseModel):
    setup     : str = Field(description = "question to set up a joke" )
    punchline : str = Field(description = "answer to resolve the joke")

    @validator("setup")
    def valiedateSetup(cls, field):
        if field[-1] != "?":
            raise ValueError("Badly formed question!")
        return field

pydanticOutputParser = PydanticOutputParser(pydantic_object = Joke)

promptTemplate = PromptTemplate(
    template          = "Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables   = ["query"],
    partial_variables = {"format_instructions" : pydanticOutputParser.get_format_instructions()},
)

openAI = OpenAI(model_name = "gpt-3.5-turbo-instruct", temperature = 0.0)

runnableSequence = promptTemplate | openAI | pydanticOutputParser

joke = runnableSequence.invoke({"query" : "Tell me a joke."})

print(joke)

"""
setup='Why did the tomato turn red?' punchline='Because it saw the salad dressing!'
"""

from dotenv import load_dotenv

from langchain_core.pydantic_v1 import BaseModel

from langchain_core.pydantic_v1 import Field

from langchain_core.pydantic_v1 import validator

from langchain_core.prompts import PromptTemplate

from langchain_openai import OpenAI

from langchain_core.output_parsers import PydanticOutputParser

load_dotenv()

class Joke(BaseModel):

setup : str = Field(description = "question to set up a joke" )

punchline : str = Field(description = "answer to resolve the joke")

@validator("setup")

def valiedateSetup(cls, field):

if field[-1] != "?":

raise ValueError("Badly formed question!")

return field

pydanticOutputParser = PydanticOutputParser(pydantic_object = Joke)

promptTemplate = PromptTemplate(

template = "Answer the user query.\n{format_instructions}\n{query}\n",

input_variables = ["query"],

partial_variables = {"format_instructions" : pydanticOutputParser.get_format_instructions()},

)

openAI = OpenAI(model_name = "gpt-3.5-turbo-instruct", temperature = 0.0)

runnableSequence = promptTemplate | openAI | pydanticOutputParser

joke = runnableSequence.invoke({"query" : "Tell me a joke."})

print(joke)

"""

setup='Why did the tomato turn red?' punchline='Because it saw the salad dressing!'

"""

▶

[PYTHON/LANGCHAIN] PydanticOutputParser 클래스 : invoke 메소드를 사용해 객체 구하기

■ PydanticOutputParser 클래스의 invoke 메소드를 사용해 객체를 구하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                        import load_dotenv
from langchain_core.pydantic_v1    import BaseModel
from langchain_core.pydantic_v1    import Field
from langchain_core.pydantic_v1    import validator
from langchain_core.prompts        import PromptTemplate
from langchain_openai              import OpenAI
from langchain_core.output_parsers import PydanticOutputParser

load_dotenv()

class Joke(BaseModel):
    setup     : str = Field(description = "question to set up a joke" )
    punchline : str = Field(description = "answer to resolve the joke")

    # Pydantic을 사용하면 사용자 정의 검증 논리를 쉽게 추가할 수 있습니다.
    @validator("setup")
    def valiedateSetup(cls, field):
        if field[-1] != "?":
            raise ValueError("Badly formed question!")
        return field

# 파서를 설정하고 프롬프트 템플릿에 지침을 삽입한다.
pydanticOutputParser = PydanticOutputParser(pydantic_object = Joke)

promptTemplate = PromptTemplate(
    template          = "Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables   = ["query"],
    partial_variables = {"format_instructions" : pydanticOutputParser.get_format_instructions()},
)

openAI = OpenAI(model_name = "gpt-3.5-turbo-instruct", temperature = 0.0)

# 그리고 데이터 구조를 채우도록 언어 모델을 프롬프트하기 위한 쿼리이다.
runnableSequence = promptTemplate | openAI

responseDictionary = runnableSequence.invoke({"query" : "Tell me a joke."})

print(responseDictionary)

"""
{
    "setup"     : "Why did the tomato turn red?",
    "punchline" : "Because it saw the salad dressing!"
}
"""

joke = pydanticOutputParser.invoke(responseDictionary)

print(joke)

"""
setup='Why did the tomato turn red?' punchline='Because it saw the salad dressing!'
"""

from dotenv import load_dotenv

from langchain_core.pydantic_v1 import BaseModel

from langchain_core.pydantic_v1 import Field

from langchain_core.pydantic_v1 import validator

from langchain_core.prompts import PromptTemplate

from langchain_openai import OpenAI

from langchain_core.output_parsers import PydanticOutputParser

load_dotenv()

class Joke(BaseModel):

setup : str = Field(description = "question to set up a joke" )

punchline : str = Field(description = "answer to resolve the joke")

# Pydantic을 사용하면 사용자 정의 검증 논리를 쉽게 추가할 수 있습니다.

@validator("setup")

def valiedateSetup(cls, field):

if field[-1] != "?":

raise ValueError("Badly formed question!")

return field

# 파서를 설정하고 프롬프트 템플릿에 지침을 삽입한다.

pydanticOutputParser = PydanticOutputParser(pydantic_object = Joke)

promptTemplate = PromptTemplate(

template = "Answer the user query.\n{format_instructions}\n{query}\n",

input_variables = ["query"],

partial_variables = {"format_instructions" : pydanticOutputParser.get_format_instructions()},

)

openAI = OpenAI(model_name = "gpt-3.5-turbo-instruct", temperature = 0.0)

# 그리고 데이터 구조를 채우도록 언어 모델을 프롬프트하기 위한 쿼리이다.

runnableSequence = promptTemplate | openAI

responseDictionary = runnableSequence.invoke({"query" : "Tell me a joke."})

print(responseDictionary)

"""

{

"setup" : "Why did the tomato turn red?",

"punchline" : "Because it saw the salad dressing!"

}

"""

joke = pydanticOutputParser.invoke(responseDictionary)

print(joke)

"""

setup='Why did the tomato turn red?' punchline='Because it saw the salad dressing!'

"""

▶