MESSAGE Archives - icodebroker

[PYTHON/LANGCHAIN] ChatOpenAI 클래스 : model_kwargs 속성을 사용해 함수 설정하기

■ ChatOpenAI 클래스의 model_kwargs 속성을 사용해 함수를 설정하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


import json

from dotenv           import load_dotenv
from langchain_openai import ChatOpenAI
from typing           import Callable
from langchain.schema import HumanMessage
from langchain.schema import FunctionMessage

load_dotenv()

def getWeather(location : str) -> str:
    # 실제로는 날씨 API를 호출하거나 DB를 조회하겠지만, 예시를 위해 하드코딩된 값을 반환한다.
    weatherDictionary = {
        "location"    : location,
        "temperature" : "20도",
        "condition"   : "맑음"
    }
    return json.dumps(weatherDictionary)

functionList = [
    {
        "name"        : "getWeather",
        "description" : "특정 도시의 현재 날씨 정보를 조회합니다",
        "parameters"  : {
            "type"       : "object",
            "properties" : {
                "location" : {
                    "type"        : "string",
                    "description" : "도시 이름 (예 : 서울, 부산)"
                }
            },
            "required" : ["location"]
        }
    }
]

chatOpenAI = ChatOpenAI(temperature = 0)

chatOpenAI.model_kwargs = {"functions" : functionList}

def processConversation(humanMessageContent : str, availableFunctionDictionary : dict[str, Callable]):
    messageList = [HumanMessage(content = humanMessageContent)]

    while True:
        response = chatOpenAI.generate([messageList])

        responseAIMessage = response.generations[0][0].message

        if responseAIMessage.additional_kwargs.get("function_call"):
            functionName               = responseAIMessage.additional_kwargs["function_call"]["name"]
            functionArgumentDictionary = json.loads(responseAIMessage.additional_kwargs["function_call"]["arguments"])

            functionToCall   = availableFunctionDictionary[functionName]
            functionResponse = functionToCall(**functionArgumentDictionary)

            messageList.append(responseAIMessage)
            messageList.append(FunctionMessage(name = functionName, content = functionResponse))
        else:
            messageList.append(responseAIMessage)
            break

    return messageList

availableFunctionDictionary = {"getWeather" : getWeather}

responseMessageList = processConversation("서울의 현재 날씨를 알려줘", availableFunctionDictionary)

for responseMessage in responseMessageList:
    print(f"Type    : {type(responseMessage).__name__}")
    print(f"Content : {responseMessage.content}")
    if isinstance(responseMessage, FunctionMessage):
        print(f"Function : {responseMessage.name}")
    print()

"""
Type    : HumanMessage
Content : 서울의 현재 날씨를 알려줘

Type    : AIMessage
Content :

Type    : FunctionMessage
Content : {"location": "\uc11c\uc6b8", "temperature": "20\ub3c4", "condition": "\ub9d1\uc74c"}
Function : getWeather

Type    : AIMessage
Content : 서울의 현재 날씨는 20도이며, 맑은 날씨입니다.
"""

import json

from dotenv import load_dotenv

from langchain_openai import ChatOpenAI

from typing import Callable

from langchain.schema import HumanMessage

from langchain.schema import FunctionMessage

load_dotenv()

def getWeather(location : str) -> str:

# 실제로는 날씨 API를 호출하거나 DB를 조회하겠지만, 예시를 위해 하드코딩된 값을 반환한다.

weatherDictionary = {

"location" : location,

"temperature" : "20도",

"condition" : "맑음"

}

return json.dumps(weatherDictionary)

functionList = [

{

"name" : "getWeather",

"description" : "특정 도시의 현재 날씨 정보를 조회합니다",

"parameters" : {

"type" : "object",

"properties" : {

"location" : {

"type" : "string",

"description" : "도시 이름 (예 : 서울, 부산)"

}

"required" : ["location"]

}

]

chatOpenAI = ChatOpenAI(temperature = 0)

chatOpenAI.model_kwargs = {"functions" : functionList}

def processConversation(humanMessageContent : str, availableFunctionDictionary : dict[str, Callable]):

messageList = [HumanMessage(content = humanMessageContent)]

while True:

response = chatOpenAI.generate([messageList])

responseAIMessage = response.generations[0][0].message

if responseAIMessage.additional_kwargs.get("function_call"):

functionName = responseAIMessage.additional_kwargs["function_call"]["name"]

functionArgumentDictionary = json.loads(responseAIMessage.additional_kwargs["function_call"]["arguments"])

functionToCall = availableFunctionDictionary[functionName]

functionResponse = functionToCall(**functionArgumentDictionary)

messageList.append(responseAIMessage)

messageList.append(FunctionMessage(name = functionName, content = functionResponse))

else:

messageList.append(responseAIMessage)

break

return messageList

availableFunctionDictionary = {"getWeather" : getWeather}

responseMessageList = processConversation("서울의 현재 날씨를 알려줘", availableFunctionDictionary)

for responseMessage in responseMessageList:

print(f"Type : {type(responseMessage).__name__}")

print(f"Content : {responseMessage.content}")

if isinstance(responseMessage, FunctionMessage):

print(f"Function : {responseMessage.name}")

print()

"""

Type : HumanMessage

Content : 서울의 현재 날씨를 알려줘

Type : AIMessage

Content :

Type : FunctionMessage

Content : {"location": "\uc11c\uc6b8", "temperature": "20\ub3c4", "condition": "\ub9d1\uc74c"}

Function : getWeather

Type : AIMessage

Content : 서울의 현재 날씨는 20도이며, 맑은 날씨입니다.

"""

▶

[PYTHON/LANGCHAIN] FunctionMessage 클래스 : 생성자에서 name/content 인자 사용하기

■ FunctionMessage 클래스의 생성자에서 name/content 인자를 사용하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv           import load_dotenv
from langchain.schema import HumanMessage
from langchain.schema import FunctionMessage
from langchain_openai import ChatOpenAI

load_dotenv()

messageList = [
    HumanMessage(content = "오늘 서울의 날씨는 어때?"),
    FunctionMessage(
        name    = "get_weather",
        content = "{'location' : '서울', 'temperature' : '20도', 'condition' : '맑음'}"
    )
]

chatOpenAI = ChatOpenAI()

responseAIMessage = chatOpenAI.invoke(messageList)

print(responseAIMessage)

"""
content='서울의 오늘 날씨는 맑고 기온은 20도입니다. 날씨가 매우 좋아 보입니다!' additional_kwargs={'refusal': None} response_metadata={'token_usage': {'completion_tokens': 40, 'prompt_tokens': 53, 'total_tokens': 93, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None} id='run-1a28b731-fc7c-4dfd-abaf-1694c83bb0fa-0' usage_metadata={'input_tokens': 53, 'output_tokens': 40, 'total_tokens': 93, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}}
"""

from dotenv import load_dotenv

from langchain.schema import HumanMessage

from langchain.schema import FunctionMessage

from langchain_openai import ChatOpenAI

load_dotenv()

messageList = [

HumanMessage(content = "오늘 서울의 날씨는 어때?"),

FunctionMessage(

name = "get_weather",

content = "{'location' : '서울', 'temperature' : '20도', 'condition' : '맑음'}"

)

]

chatOpenAI = ChatOpenAI()

responseAIMessage = chatOpenAI.invoke(messageList)

print(responseAIMessage)

"""

content='서울의 오늘 날씨는 맑고 기온은 20도입니다. 날씨가 매우 좋아 보입니다!' additional_kwargs={'refusal': None} response_metadata={'token_usage': {'completion_tokens': 40, 'prompt_tokens': 53, 'total_tokens': 93, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None} id='run-1a28b731-fc7c-4dfd-abaf-1694c83bb0fa-0' usage_metadata={'input_tokens': 53, 'output_tokens': 40, 'total_tokens': 93, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}}

"""

▶ requirements.txt

[PYTHON/LANGCHAIN] AIMessageChunk 클래스 : 스트림으로 수신되는 AIMessageChunk 객체에서 도구 호출 리스트 구하기

■ AIMessageChunk 클래스 관련해 스트림으로 수신되는 AIMessageChunk 객체에서 도구 호출 리스트를 구하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다.

[PYTHON/LANGCHAIN] merge_message_runs 함수 : 동일한 유형의 메시지 병합하기

■ merge_message_runs 함수를 사용해 동일한 유형의 메시지를 병합하는 방법을 보여준다. ▶ main.py


from langchain_core.messages import SystemMessage
from langchain_core.messages import HumanMessage
from langchain_core.messages import AIMessage
from langchain_core.messages import merge_message_runs

sourceMessageList = [
    SystemMessage("you're a good assistant."),
    SystemMessage("you always respond with a joke."),
    HumanMessage([{"type": "text", "text": "i wonder why it's called langchain"}]),
    HumanMessage("and who is harrison chasing anyways"),
    AIMessage('Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!'),
    AIMessage("Why, he's probably chasing after the last cup of coffee in the office!")
]

targetMessageList = merge_message_runs(sourceMessageList)

print("\n\n".join([repr(x) for x in targetMessageList]))

"""
SystemMessage(content="you're a good assistant.\nyou always respond with a joke.")

HumanMessage(content=[{'type': 'text', 'text': "i wonder why it's called langchain"}, 'and who is harrison chasing anyways'])

AIMessage(content='Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!\nWhy, he\'s probably chasing after the last cup of coffee in the office!')
"""

from langchain_core.messages import SystemMessage

from langchain_core.messages import HumanMessage

from langchain_core.messages import AIMessage

from langchain_core.messages import merge_message_runs

sourceMessageList = [

SystemMessage("you're a good assistant."),

SystemMessage("you always respond with a joke."),

HumanMessage([{"type": "text", "text": "i wonder why it's called langchain"}]),

HumanMessage("and who is harrison chasing anyways"),

AIMessage('Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!'),

AIMessage("Why, he's probably chasing after the last cup of coffee in the office!")

]

targetMessageList = merge_message_runs(sourceMessageList)

print("\n\n".join([repr(x) for x in targetMessageList]))

"""

SystemMessage(content="you're a good assistant.\nyou always respond with a joke.")

HumanMessage(content=[{'type': 'text', 'text': "i wonder why it's called langchain"}, 'and who is harrison chasing anyways'])

AIMessage(content='Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!\nWhy, he\'s probably chasing after the last cup of coffee in the office!')

"""

▶ 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.5
langchain-core==0.2.9
langchain-text-splitters==0.2.1
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.5

langchain-core==0.2.9

langchain-text-splitters==0.2.1

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] filter_messages 함수 : RunnableLambda 객체를 만들고 체인에서 사용하기

■ filter_messages 함수를 사용해 RunnableLambda 객체를 만들고 체인에서 사용하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                  import load_dotenv
from langchain_core.messages import SystemMessage
from langchain_core.messages import HumanMessage
from langchain_core.messages import AIMessage
from langchain_core.messages import filter_messages
from langchain_openai        import ChatOpenAI

load_dotenv()

messageList = [
    SystemMessage("you are a good assistant", id="1"                            ),
    HumanMessage ("example input"           , id="2", name = "example_user"     ),
    AIMessage    ("example output"          , id="3", name = "example_assistant"),
    HumanMessage ("real input"              , id="4", name = "bob"              ),
    AIMessage    ("real output"             , id="5", name = "alice"            ),
]

filterRunnableLambda = filter_messages(exclude_names = ["example_user", "example_assistant"])

chatOpenAI = ChatOpenAI(temperature = 0)

runnableSequence = filterRunnableLambda | chatOpenAI

responseAIMessage = runnableSequence.invoke(messageList)

print(responseAIMessage.content)

"""
I'm sorry, I'm not sure what you mean by "bob real input." Can you please provide more context or clarify your request?
"""

from dotenv import load_dotenv

from langchain_core.messages import SystemMessage

from langchain_core.messages import HumanMessage

from langchain_core.messages import AIMessage

from langchain_core.messages import filter_messages

from langchain_openai import ChatOpenAI

load_dotenv()

messageList = [

SystemMessage("you are a good assistant", id="1" ),

HumanMessage ("example input" , id="2", name = "example_user" ),

AIMessage ("example output" , id="3", name = "example_assistant"),

HumanMessage ("real input" , id="4", name = "bob" ),

AIMessage ("real output" , id="5", name = "alice" ),

]

filterRunnableLambda = filter_messages(exclude_names = ["example_user", "example_assistant"])

chatOpenAI = ChatOpenAI(temperature = 0)

runnableSequence = filterRunnableLambda | chatOpenAI

responseAIMessage = runnableSequence.invoke(messageList)

print(responseAIMessage.content)

"""

I'm sorry, I'm not sure what you mean by "bob real input." Can you please provide more context or clarify your request?

"""

[PYTHON/LANGCHAIN] filter_messages 함수 : include_types/exclude_ids 인자를 사용해 메시지 필터링하기

■ filter_messages 함수의 include_types/exclude_ids 인자를 사용해 메시지를 필터링하는 방법을 보여준다. ▶ main.py


from langchain_core.messages import SystemMessage
from langchain_core.messages import HumanMessage
from langchain_core.messages import AIMessage
from langchain_core.messages import filter_messages

sourceMessageList = [
    SystemMessage("you are a good assistant", id="1"                            ),
    HumanMessage ("example input"           , id="2", name = "example_user"     ),
    AIMessage    ("example output"          , id="3", name = "example_assistant"),
    HumanMessage ("real input"              , id="4", name = "bob"              ),
    AIMessage    ("real output"             , id="5", name = "alice"            ),
]

targetMessageList = filter_messages(sourceMessageList, include_types = [HumanMessage, AIMessage], exclude_ids = ["3"])

print(targetMessageList)

"""
[
    HumanMessage(content = 'example input', name = 'example_user', id = '2'),
    HumanMessage(content = 'real input'   , name = 'bob'         , id = '4'),
    AIMessage   (content = 'real output'  , name = 'alice'       , id = '5')
]
"""

from langchain_core.messages import SystemMessage

from langchain_core.messages import HumanMessage

from langchain_core.messages import AIMessage

from langchain_core.messages import filter_messages

sourceMessageList = [

SystemMessage("you are a good assistant", id="1" ),

HumanMessage ("example input" , id="2", name = "example_user" ),

AIMessage ("example output" , id="3", name = "example_assistant"),

HumanMessage ("real input" , id="4", name = "bob" ),

AIMessage ("real output" , id="5", name = "alice" ),

]

targetMessageList = filter_messages(sourceMessageList, include_types = [HumanMessage, AIMessage], exclude_ids = ["3"])

print(targetMessageList)

"""

[

HumanMessage(content = 'example input', name = 'example_user', id = '2'),

HumanMessage(content = 'real input' , name = 'bob' , id = '4'),

AIMessage (content = 'real output' , name = 'alice' , id = '5')

]

"""

▶ 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.5
langchain-core==0.2.9
langchain-text-splitters==0.2.1
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.5

langchain-core==0.2.9

langchain-text-splitters==0.2.1

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] filter_messages 함수 : exclude_names 인자를 사용해 메시지 필터링하기

■ filter_messages 함수의 exclude_names 인자를 사용해 메시지를 필터링하는 방법을 보여준다. ▶ main.py


from langchain_core.messages import SystemMessage
from langchain_core.messages import HumanMessage
from langchain_core.messages import AIMessage
from langchain_core.messages import filter_messages

sourceMessageList = [
    SystemMessage("you are a good assistant", id="1"                            ),
    HumanMessage ("example input"           , id="2", name = "example_user"     ),
    AIMessage    ("example output"          , id="3", name = "example_assistant"),
    HumanMessage ("real input"              , id="4", name = "bob"              ),
    AIMessage    ("real output"             , id="5", name = "alice"            ),
]

targetMessageList = filter_messages(sourceMessageList, exclude_names = ["example_user", "example_assistant"])

print(targetMessageList)

"""
[
    SystemMessage(content = 'you are a good assistant', id = '1'                ),
    HumanMessage (content = 'real input'              , id = '4', name = 'bob'  ),
    AIMessage    (content = 'real output'             , id = '5', name = 'alice')
]
"""

from langchain_core.messages import SystemMessage

from langchain_core.messages import HumanMessage

from langchain_core.messages import AIMessage

from langchain_core.messages import filter_messages

sourceMessageList = [

SystemMessage("you are a good assistant", id="1" ),

HumanMessage ("example input" , id="2", name = "example_user" ),

AIMessage ("example output" , id="3", name = "example_assistant"),

HumanMessage ("real input" , id="4", name = "bob" ),

AIMessage ("real output" , id="5", name = "alice" ),

]

targetMessageList = filter_messages(sourceMessageList, exclude_names = ["example_user", "example_assistant"])

print(targetMessageList)

"""

[

SystemMessage(content = 'you are a good assistant', id = '1' ),

HumanMessage (content = 'real input' , id = '4', name = 'bob' ),

AIMessage (content = 'real output' , id = '5', name = 'alice')

]

"""

▶ 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.5
langchain-core==0.2.9
langchain-text-splitters==0.2.1
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.5

langchain-core==0.2.9

langchain-text-splitters==0.2.1

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] filter_messages 함수 : include_types 인자를 사용해 메시지 필터링하기

■ filter_messages 함수의 include_types 인자를 사용해 메시지를 필터링하는 방법을 보여준다. ▶ main.py


from langchain_core.messages import SystemMessage
from langchain_core.messages import HumanMessage
from langchain_core.messages import AIMessage
from langchain_core.messages import filter_messages

sourceMessageList = [
    SystemMessage("you are a good assistant", id="1"                            ),
    HumanMessage ("example input"           , id="2", name = "example_user"     ),
    AIMessage    ("example output"          , id="3", name = "example_assistant"),
    HumanMessage ("real input"              , id="4", name = "bob"              ),
    AIMessage    ("real output"             , id="5", name = "alice"            ),
]

targetMessageList = filter_messages(sourceMessageList, include_types = "human")

print(targetMessageList)

"""
[
    HumanMessage(content = 'example input', name = 'example_user', id = '2'),
    HumanMessage(content = 'real input'   , name = 'bob'         , id = '4')
]
"""

from langchain_core.messages import SystemMessage

from langchain_core.messages import HumanMessage

from langchain_core.messages import AIMessage

from langchain_core.messages import filter_messages

sourceMessageList = [

SystemMessage("you are a good assistant", id="1" ),

HumanMessage ("example input" , id="2", name = "example_user" ),

AIMessage ("example output" , id="3", name = "example_assistant"),

HumanMessage ("real input" , id="4", name = "bob" ),

AIMessage ("real output" , id="5", name = "alice" ),

]

targetMessageList = filter_messages(sourceMessageList, include_types = "human")

print(targetMessageList)

"""

[

HumanMessage(content = 'example input', name = 'example_user', id = '2'),

HumanMessage(content = 'real input' , name = 'bob' , id = '4')

]

"""

▶ 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.5
langchain-core==0.2.9
langchain-text-splitters==0.2.1
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.5

langchain-core==0.2.9

langchain-text-splitters==0.2.1

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] trim_messages 함수 : RunnableLambda 객체를 만들고 RunnableWithMessageHistory 객체와 함께 체인에서 사용하기

■ trim_messages 함수를 사용해 RunnableLambda 객체를 만들고 RunnableWithMessageHistory 객체와 함께 체인에서 사용하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다.

[PYTHON/LANGCHAIN] trim_messages 함수 : RunnableLambda 객체를 만들고 체인에서 사용하기

■ trim_messages 함수를 사용해 RunnableLambda 객체를 만들고 체인에서 사용하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv                  import load_dotenv
from langchain_core.messages import SystemMessage
from langchain_core.messages import HumanMessage
from langchain_core.messages import AIMessage
from langchain_openai        import ChatOpenAI
from langchain_core.messages import trim_messages

load_dotenv()

messageList = [
    SystemMessage("you're a good assistant, you always respond with a joke."),
    HumanMessage("i wonder why it's called langchain"),
    AIMessage('Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!'),
    HumanMessage("and who is harrison chasing anyways"),
    AIMessage("Hmmm let me think.\n\nWhy, he's probably chasing after the last cup of coffee in the office!"),
    HumanMessage("what do you call a speechless parrot")
]

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

trimMessagesRunnableLambda = trim_messages(
    max_tokens    = 45,
    strategy      = "last",
    token_counter = chatOpenAI
)

runnableSequence = trimMessagesRunnableLambda | chatOpenAI

responseAIMessage = runnableSequence.invoke(messageList)

print(responseAIMessage.content)

"""
A speechless parrot? You might call it a "polly-gone quiet"!
"""

from dotenv import load_dotenv

from langchain_core.messages import SystemMessage

from langchain_core.messages import HumanMessage

from langchain_core.messages import AIMessage

from langchain_openai import ChatOpenAI

from langchain_core.messages import trim_messages

load_dotenv()

messageList = [

SystemMessage("you're a good assistant, you always respond with a joke."),

HumanMessage("i wonder why it's called langchain"),

AIMessage('Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!'),

HumanMessage("and who is harrison chasing anyways"),

AIMessage("Hmmm let me think.\n\nWhy, he's probably chasing after the last cup of coffee in the office!"),

HumanMessage("what do you call a speechless parrot")

]

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

trimMessagesRunnableLambda = trim_messages(

max_tokens = 45,

strategy = "last",

token_counter = chatOpenAI

)

runnableSequence = trimMessagesRunnableLambda | chatOpenAI

responseAIMessage = runnableSequence.invoke(messageList)

print(responseAIMessage.content)

"""

A speechless parrot? You might call it a "polly-gone quiet"!

"""

[PYTHON/LANGCHAIN] 커스텀 토큰 카운터 만들기

■ 커스텀 토큰 카운터를 만드는 방법을 보여준다. ▶ main.py


import tiktoken

from typing import List

from langchain_core.messages import BaseMessage
from langchain_core.messages import SystemMessage
from langchain_core.messages import HumanMessage
from langchain_core.messages import ToolMessage
from langchain_core.messages import AIMessage
from langchain_core.messages import trim_messages

sourceMessageList = [
    SystemMessage("you're a good assistant, you always respond with a joke."),
    HumanMessage("i wonder why it's called langchain"),
    AIMessage('Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!'),
    HumanMessage("and who is harrison chasing anyways"),
    AIMessage("Hmmm let me think.\n\nWhy, he's probably chasing after the last cup of coffee in the office!"),
    HumanMessage("what do you call a speechless parrot")
]

def getTokenCounterFromString(text : str) -> int:
    encoding = tiktoken.get_encoding("o200k_base")
    return len(encoding.encode(text))

def getTokenCounterFromMessageList(messageList : List[BaseMessage]) -> int:
    tokenCount           = 3  # 모든 응답은 <|start|>assistant<|message|>로 시작된다.
    tokenCountPerMessage = 3
    tokenCountPerName    = 1

    for message in messageList:
        if isinstance(message, SystemMessage):
            role = "system"
        elif isinstance(message, HumanMessage):
            role = "user"
        elif isinstance(message, ToolMessage):
            role = "tool"
        elif isinstance(message, AIMessage):
            role = "assistant"
        else:
            raise ValueError(f"Unsupported messages type {message.__class__}")

        tokenCount += (tokenCountPerMessage + getTokenCounterFromString(role) + getTokenCounterFromString(message.content))

        if message.name:
            tokenCount += tokenCountPerName + getTokenCounterFromString(message.name)

    return tokenCount

targetMessageList = trim_messages(
    sourceMessageList,
    max_tokens    = 45,
    strategy      = "last",
    token_counter = getTokenCounterFromMessageList,
)

print(targetMessageList)

"""
[
    AIMessage(content = "Hmmm let me think.\n\nWhy, he's probably chasing after the last cup of coffee in the office!"),
    HumanMessage(content = 'what do you call a speechless parrot')
]
"""----------------------------------------------------------------------------------------------------

▶ requirements.txt

import tiktoken

from typing import List

from langchain_core.messages import BaseMessage

from langchain_core.messages import SystemMessage

from langchain_core.messages import HumanMessage

from langchain_core.messages import ToolMessage

from langchain_core.messages import AIMessage

from langchain_core.messages import trim_messages

sourceMessageList = [

SystemMessage("you're a good assistant, you always respond with a joke."),

HumanMessage("i wonder why it's called langchain"),

AIMessage('Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!'),

HumanMessage("and who is harrison chasing anyways"),

AIMessage("Hmmm let me think.\n\nWhy, he's probably chasing after the last cup of coffee in the office!"),

HumanMessage("what do you call a speechless parrot")

]

def getTokenCounterFromString(text : str) -> int:

encoding = tiktoken.get_encoding("o200k_base")

return len(encoding.encode(text))

def getTokenCounterFromMessageList(messageList : List[BaseMessage]) -> int:

tokenCount = 3 # 모든 응답은 <|start|>assistant<|message|>로 시작된다.

tokenCountPerMessage = 3

tokenCountPerName = 1

for message in messageList:

if isinstance(message, SystemMessage):

role = "system"

elif isinstance(message, HumanMessage):

role = "user"

elif isinstance(message, ToolMessage):

role = "tool"

elif isinstance(message, AIMessage):

role = "assistant"

else:

raise ValueError(f"Unsupported messages type {message.__class__}")

tokenCount += (tokenCountPerMessage + getTokenCounterFromString(role) + getTokenCounterFromString(message.content))

if message.name:

tokenCount += tokenCountPerName + getTokenCounterFromString(message.name)

return tokenCount

targetMessageList = trim_messages(

sourceMessageList,

max_tokens = 45,

strategy = "last",

token_counter = getTokenCounterFromMessageList,

)

print(targetMessageList)

"""

[

AIMessage(content = "Hmmm let me think.\n\nWhy, he's probably chasing after the last cup of coffee in the office!"),

HumanMessage(content = 'what do you call a speechless parrot')

]

"""----------------------------------------------------------------------------------------------------

▶ 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

[PYTHON/LANGCHAIN] trim_messages 함수 : max_tokens/strategy 인자를 사용해 최대 토큰 수를 기준으로 메시지 길이 제한하기 2

■ trim_messages 함수에서 max_tokens/strategy 인자를 사용해 최대 토큰 수를 기준으로 메시지 길이를 제한하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에

[PYTHON/LANGCHAIN] trim_messages 함수 : start_on 인자를 사용해 첫번째 메시지가 항상 특정 유형인지 확인하기

■ trim_messages 함수의 start_on 인자를 사용해 첫번째 메시지가 항상 특정 유형인지 확인하는 방법을 보여준다. ※ start_on 인자는 시스템 메시지는 제외한다. ※ OPENAI_API_KEY

[PYTHON/LANGCHAIN] trim_messages 함수 : include_system 인자를 사용해 초기 시스템 메시지 유지하기

■ trim_messages 함수의 include_system 인자를 사용해 초기 시스템 메시지를 유지하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py

[PYTHON/LANGCHAIN] trim_messages 함수 : max_tokens/strategy 인자를 사용해 최대 토큰 수를 기준으로 메시지 길이 제한하기 1

[PYTHON/LANGCHAIN] AIMessage 클래스 : response_metadata 속성 사용하기 (ChatFireworks 객체 사용시)

■ AIMessage 클래스의 response_metadata 속성을 사용하는 방법을 보여준다. (ChatFireworks 객체 사용시) ▶ 예제 코드 (PY)


from langchain_fireworks import ChatFireworks

chatFireworks = ChatFireworks(model = "accounts/fireworks/models/mixtral-8x7b-instruct")

aiMessage = chatFireworks.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""
{
    'token_usage'        : {'prompt_tokens' : 19, 'total_tokens' : 219, 'completion_tokens' : 200},
    'model_name'         : 'accounts/fireworks/models/mixtral-8x7b-instruct',
    'system_fingerprint' : '',
    'finish_reason'      : 'length',
    'logprobs'           : None
}
"""

from langchain_fireworks import ChatFireworks

chatFireworks = ChatFireworks(model = "accounts/fireworks/models/mixtral-8x7b-instruct")

aiMessage = chatFireworks.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""

{

'token_usage' : {'prompt_tokens' : 19, 'total_tokens' : 219, 'completion_tokens' : 200},

'model_name' : 'accounts/fireworks/models/mixtral-8x7b-instruct',

'system_fingerprint' : '',

'finish_reason' : 'length',

'logprobs' : None

}

"""

[PYTHON/LANGCHAIN] AIMessage 클래스 : response_metadata 속성 사용하기 (ChatOpenAI 객체 사용시)

■ AIMessage 클래스의 response_metadata 속성을 사용하는 방법을 보여준다. (ChatOpenAI 객체 사용시) ▶ 예제 코드 (PY)


import os

from langchain_openai import ChatOpenAI

chatOpenAI = ChatOpenAI(
    base_url = "https://api.together.xyz/v1",
    api_key  = os.environ["TOGETHER_API_KEY"],
    model    = "mistralai/Mixtral-8x7B-Instruct-v0.1"
)

aiMessage = chatOpenAI.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""
{
    'token_usage'        : {'completion_tokens' : 208, 'prompt_tokens' : 20, 'total_tokens' : 228},
    'model_name'         : 'mistralai/Mixtral-8x7B-Instruct-v0.1',
    'system_fingerprint' : None,
    'finish_reason'      : 'eos',
    'logprobs'           : None
}
"""

import os

from langchain_openai import ChatOpenAI

chatOpenAI = ChatOpenAI(

base_url = "https://api.together.xyz/v1",

api_key = os.environ["TOGETHER_API_KEY"],

model = "mistralai/Mixtral-8x7B-Instruct-v0.1"

)

aiMessage = chatOpenAI.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""

{

'token_usage' : {'completion_tokens' : 208, 'prompt_tokens' : 20, 'total_tokens' : 228},

'model_name' : 'mistralai/Mixtral-8x7B-Instruct-v0.1',

'system_fingerprint' : None,

'finish_reason' : 'eos',

'logprobs' : None

}

"""

[PYTHON/LANGCHAIN] AIMessage 클래스 : response_metadata 속성 사용하기 (ChatGroq 객체 사용시)

■ AIMessage 클래스의 response_metadata 속성을 사용하는 방법을 보여준다. (ChatGroq 객체 사용시) ▶ 예제 코드 (PY)


from langchain_groq import ChatGroq

chatGroq = ChatGroq()

aiMessage = chatGroq.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""
{
    'token_usage' : {
        'completion_time'   : 0.243,
        'completion_tokens' : 132,
        'prompt_time'       : 0.022,
        'prompt_tokens'     : 22,
        'queue_time'        : None,
        'total_time'        : 0.265,
        'total_tokens'      : 154
    },
    'model_name'         : 'mixtral-8x7b-32768',
    'system_fingerprint' : 'fp_7b44c65f25',
    'finish_reason'      : 'stop',
    'logprobs'           : None
}
"""

from langchain_groq import ChatGroq

chatGroq = ChatGroq()

aiMessage = chatGroq.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""

{

'token_usage' : {

'completion_time' : 0.243,

'completion_tokens' : 132,

'prompt_time' : 0.022,

'prompt_tokens' : 22,

'queue_time' : None,

'total_time' : 0.265,

'total_tokens' : 154

'model_name' : 'mixtral-8x7b-32768',

'system_fingerprint' : 'fp_7b44c65f25',

'finish_reason' : 'stop',

'logprobs' : None

}

"""

[PYTHON/LANGCHAIN] AIMessage 클래스 : response_metadata 속성 사용하기 (ChatMistralAI 객체 사용시)

■ AIMessage 클래스의 response_metadata 속성을 사용하는 방법을 보여준다. (ChatMistralAI 객체 사용시) ▶ 예제 코드 (PY)


from langchain_mistralai import ChatMistralAI

chatMistralAI = ChatMistralAI()

aiMessage = chatMistralAI.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""
{
    'token_usage' : {
        'prompt_tokens'     : 19,
        'total_tokens'      : 141,
        'completion_tokens' : 122
    },
    'model'         : 'mistral-small',
    'finish_reason' : 'stop'
}
"""

from langchain_mistralai import ChatMistralAI

chatMistralAI = ChatMistralAI()

aiMessage = chatMistralAI.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""

{

'token_usage' : {

'prompt_tokens' : 19,

'total_tokens' : 141,

'completion_tokens' : 122

'model' : 'mistral-small',

'finish_reason' : 'stop'

}

"""

[PYTHON/LANGCHAIN] AIMessage 클래스 : response_metadata 속성 사용하기 (ChatBedrock 객체 사용시)

■ AIMessage 클래스의 response_metadata 속성을 사용하는 방법을 보여준다. (ChatBedrock 객체 사용시) ▶ 예제 코드 (PY)


from langchain_aws import ChatBedrock

chatBedrock = ChatBedrock(model_id = "anthropic.claude-v2")

aiMessage = chatBedrock.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""
{
    'model_id' : 'anthropic.claude-v2',
    'usage' : {'prompt_tokens' : 19, 'completion_tokens' : 371, 'total_tokens' : 390}
}
"""

from langchain_aws import ChatBedrock

chatBedrock = ChatBedrock(model_id = "anthropic.claude-v2")

aiMessage = chatBedrock.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""

{

'model_id' : 'anthropic.claude-v2',

'usage' : {'prompt_tokens' : 19, 'completion_tokens' : 371, 'total_tokens' : 390}

}

"""

[PYTHON/LANGCHAIN] AIMessage 클래스 : response_metadata 속성 사용하기 (ChatVertexAI 객체 사용시)

■ AIMessage 클래스의 response_metadata 속성을 사용하는 방법을 보여준다. (ChatVertexAI 객체 사용시) ▶ 예제 코드 (PY)


from langchain_google_vertexai import ChatVertexAI

chatVertexAI = ChatVertexAI(model = "gemini-pro")

aiMessage = chatVertexAI.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""
{
    'is_blocked'     : False,
    'safety_ratings' : [
        {
            'category'          : 'HARM_CATEGORY_HATE_SPEECH',
            'probability_label' : 'NEGLIGIBLE',
            'blocked'           : False
        },
        {
            'category'          : 'HARM_CATEGORY_DANGEROUS_CONTENT',
            'probability_label' : 'NEGLIGIBLE',
            'blocked'           : False
        },
        {
            'category'          : 'HARM_CATEGORY_HARASSMENT',
            'probability_label' : 'NEGLIGIBLE',
            'blocked'           : False
        },
        {
            'category'          : 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
            'probability_label' : 'NEGLIGIBLE',
            'blocked'           : False
        }
    ],
    'citation_metadata' : None,
    'usage_metadata'    : {'prompt_token_count' : 10, 'candidates_token_count' : 30, 'total_token_count' : 40}
}
"""

from langchain_google_vertexai import ChatVertexAI

chatVertexAI = ChatVertexAI(model = "gemini-pro")

aiMessage = chatVertexAI.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""

{

'is_blocked' : False,

'safety_ratings' : [

{

'category' : 'HARM_CATEGORY_HATE_SPEECH',

'probability_label' : 'NEGLIGIBLE',

'blocked' : False

{

'category' : 'HARM_CATEGORY_DANGEROUS_CONTENT',

'probability_label' : 'NEGLIGIBLE',

'blocked' : False

{

'category' : 'HARM_CATEGORY_HARASSMENT',

'probability_label' : 'NEGLIGIBLE',

'blocked' : False

{

'category' : 'HARM_CATEGORY_SEXUALLY_EXPLICIT',

'probability_label' : 'NEGLIGIBLE',

'blocked' : False

}

'citation_metadata' : None,

'usage_metadata' : {'prompt_token_count' : 10, 'candidates_token_count' : 30, 'total_token_count' : 40}

}

"""

[PYTHON/LANGCHAIN] AIMessage 클래스 : response_metadata 속성 사용하기 (ChatAnthropic 객체 사용시)

■ AIMessage 클래스의 response_metadata 속성을 사용하는 방법을 보여준다. (ChatAnthropic 객체 사용시) ▶ 예제 코드 (PY)


from langchain_anthropic import ChatAnthropic

chatAnthropic = ChatAnthropic(model = "claude-3-sonnet-20240229")

aiMessage = chatAnthropic.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""
{
    'id'            : 'msg_01CzQyD7BX8nkhDNfT1QqvEp',
    'model'         : 'claude-3-sonnet-20240229',
    'stop_reason'   : 'end_turn',
    'stop_sequence' : None,
    'usage'         : {'input_tokens' : 17, 'output_tokens' : 296}
}
"""

from langchain_anthropic import ChatAnthropic

chatAnthropic = ChatAnthropic(model = "claude-3-sonnet-20240229")

aiMessage = chatAnthropic.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""

{

'id' : 'msg_01CzQyD7BX8nkhDNfT1QqvEp',

'model' : 'claude-3-sonnet-20240229',

'stop_reason' : 'end_turn',

'stop_sequence' : None,

'usage' : {'input_tokens' : 17, 'output_tokens' : 296}

}

"""

[PYTHON/LANGCHAIN] AIMessage 클래스 : response_metadata 속성 사용하기 (ChatOpenAI 객체 사용시)

■ AIMessage 클래스의 response_metadata 속성을 사용하는 방법을 보여준다. (ChatOpenAI 객체 사용시) ▶ 예제 코드 (PY)


from langchain_openai import ChatOpenAI

chatOpenAI = ChatOpenAI(model = "gpt-4-turbo")

aiMessage = chatOpenAI.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""
{
    'token_usage' : {
        'completion_tokens' : 164,
        'prompt_tokens'     : 17,
        'total_tokens'      : 181
    },
    'model_name'         : 'gpt-4-turbo',
    'system_fingerprint' : 'fp_76f018034d',
    'finish_reason'      : 'stop',
    'logprobs'           : None
}
"""

from langchain_openai import ChatOpenAI

chatOpenAI = ChatOpenAI(model = "gpt-4-turbo")

aiMessage = chatOpenAI.invoke([("human", "What's the oldest known example of cuneiform")])

print(aiMessage.response_metadata)

"""

{

'token_usage' : {

'completion_tokens' : 164,

'prompt_tokens' : 17,

'total_tokens' : 181

'model_name' : 'gpt-4-turbo',

'system_fingerprint' : 'fp_76f018034d',

'finish_reason' : 'stop',

'logprobs' : None

}

"""

[PYTHON/LANGCHAIN] AIMessage 클래스 : response_metadata 속성을 사용해 토큰 사용량 구하기

■ AIMessage 클래스의 response_metadata 속성을 사용해 토큰 사용량을 구하는 방법을 보여준다. ※ 모델 응답의 메타 데이터도 AIMessage 클래스의 response_metadata 속성에 포함된다. ※

[PYTHON/LANGCHAIN] AIMessage 클래스 : usage_metadata 속성을 사용해 토큰 사용량 구하기

■ AIMessage 클래스의 usage_metadata 속성을 사용해 토큰 사용량을 구하는 방법을 보여준다. ※ OPENAI_API_KEY 환경 변수 값은 .env 파일에 정의한다. ▶ main.py


from dotenv           import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv()

chatOpenAI = ChatOpenAI(model = "gpt-3.5-turbo-0125")

responseAIMessage = chatOpenAI.invoke("hello")

print(responseAIMessage.usage_metadata)

"""
{'input_tokens': 8, 'output_tokens': 9, 'total_tokens': 17}
"""

from dotenv import load_dotenv

from langchain_openai import ChatOpenAI

load_dotenv()

chatOpenAI = ChatOpenAI(model = "gpt-3.5-turbo-0125")

responseAIMessage = chatOpenAI.invoke("hello")

print(responseAIMessage.usage_metadata)

"""

{'input_tokens': 8, 'output_tokens': 9, 'total_tokens': 17}

"""