1
2
3
4
5
6
7
8
from langchain_openai import OpenAI
model = OpenAI(
    model="gpt-4o-mini",
    temperature=0,
    api_key=OPEN_API_KEY, # 환경변수
)
output = model.invoke("hi")
print(output)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI

model = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
    api_key=OPEN_API_KEY
)

messages = [
    SystemMessage("You are a helpful assistant."), # "role": "system"에 대응
    HumanMessage("Hi, I'm Steven."), # "role": "user" 에 대응
    AIMessage(content="Hello, Steven. What can I do for you?"), # "role": "assistant"에 대응
    HumanMessage(content="What is my name?")
]
response = model.invoke(messages)
print(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
model = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
    api_key=OPEN_API_KEY
)

messages = [
    SystemMessage("You are a helpful assistant."),
    HumanMessage("Hi, I'm Steven."),
]

for chunk in model.stream(messages):
    print(chunk.content, end="", flush=True)

1
2
3
4
5
6
7
8
9
10
11
from langchain_core.prompts import PromptTemplate

prompt = PromptTemplate.from_template("""
Tell me the recipe for this dish. Name of the dish: {dish}
""")
prompt_value = prompt.invoke({
    "dish": "pizza"
})

# output: Tell me the recipe for this dish. Name of the dish: pizza
print(prompt_value.text)

1
2
3
4
5
6
7
8
9
10
11
12
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Tell me the recipe for the dish user entered"),
    ("human", "{dish}"),
])
prompt_value = prompt.invoke({
    "dish": "pizza"
})

# output: messages=[SystemMessage(content='Tell me the recipe for the dish user entered', additional_kwargs={}, response_metadata={}), HumanMessage(content='pizza', additional_kwargs={}, response_metadata={})]
print(prompt_value)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder("chat_history", optional=True),
    ("human", "{input}"),
])
prompt_value = prompt.invoke({
    "chat_history": [
        HumanMessage(content="Hello, I'm Steven."),
        AIMessage(content="Hello Steven. What can I do for you?"),
    ],
    "input": "What is my name?",
})

# output: messages=[SystemMessage(content='You are a helpful assistant.', additional_kwargs={}, response_metadata={}), HumanMessage(content="Hello, I'm Steven.", additional_kwargs={}, response_metadata={}), AIMessage(content='Hello Steven. What can I do for you?', additional_kwargs={}, response_metadata={}), HumanMessage(content='What is my name?', additional_kwargs={}, response_metadata={})]
print(prompt_value)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field

class Recipe(BaseModel):
    ingredients: list[str] = Field(description="Ingredients of the dish")
    steps: list[str] = Field(description="Steps to make the dish")

output_parser = PydanticOutputParser(pydantic_object=Recipe)
# Recipe 클래스에 대응하는 출력 형식을 지정하는 문자열에 대한 출력 형식 설명문
format_instructions = output_parser.get_format_instructions()
print(format_instructions)
# 출력 설명문:
'''
The output should be formatted as a JSON instance that conforms to the JSON schema below.

As an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
the object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted.

Here is the output schema:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Recipe(BaseModel):
    ingredients: list[str] = Field(description="Ingredients of the dish")
    steps: list[str] = Field(description="Steps to make the dish")

prompt = ChatPromptTemplate.from_messages([
    (
        "system",
        "Please think of the recipe for the dish you entered.\n\n"
    ),
    ("human", "{dish}"),
])

model = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
    api_key=OPEN_API_KEY
)

chain = prompt | model.with_structured_output(Recipe)

recipe = chain.invoke({"dish": "pizza"})
print(type(recipe))
print(recipe)
# 출력:
'''
<class '__main__.Recipe'>
ingredients=['2 1/4 cups all-purpose flour', '1 packet (2 1/4 tsp) active dry yeast', '1 tsp sugar', '1 tsp salt', '3/4 cup warm water (110°F)', '1 tbsp olive oil', '1 cup pizza sauce', '2 cups shredded mozzarella cheese', 'Toppings of choice (pepperoni, bell peppers, onions, mushrooms, etc.)'] steps=['In a small bowl, combine warm water, sugar, and yeast. Let it sit for about 5-10 minutes until frothy.', 'In a large mixing bowl, combine flour and salt. Make a well in the center and add the yeast mixture and olive oil.', 'Mix until a dough forms, then knead on a floured surface for about 5-7 minutes until smooth and elastic.', 'Place the dough in a greased bowl, cover with a damp cloth, and let it rise in a warm place for about 1 hour or until doubled in size.', 'Preheat your oven to 475°F (245°C).', 'Once the dough has risen, punch it down and roll it out on a floured surface to your desired thickness.', 'Transfer the rolled-out dough to a pizza stone or baking sheet.', 'Spread pizza sauce evenly over the dough, leaving a small border around the edges.', 'Sprinkle shredded mozzarella cheese over the sauce, then add your desired toppings.', 'Bake in the preheated oven for 12-15 minutes or until the crust is golden and the cheese is bubbly.', 'Remove from the oven, let it cool for a few minutes, slice, and serve.']
'''

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    ("system", "Please think of the recipe for the dish you entered.\n"),
    ("human", "{dish}")
])
model = ChatOpenAI(model="gpt-4o-mini", temperature=0, api_key=OPEN_API_KEY)

# model로 prompt 실행 후 결과를 StrOutputParser로 파싱
chain = prompt | model | StrOutputParser()

# invoke 반환은 AIMessage 객체이지만 
# Chain에서 StrOutputParser를 사용해 AIMessage를 문자열로 변환
output = chain.invoke({"dish", "pizza"})
print(output)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class Recipe(BaseModel):
    ingredients: list[str] = Field(description="Ingredients of the dish")
    steps: list[str] = Field(description="Steps to make the dish")

output_parser = PydanticOutputParser(pydantic_object=Recipe)
# Recipe 클래스에 대응하는 출력 형식을 지정하는 문자열에 대한 출력 형식 설명문
format_instructions = output_parser.get_format_instructions()
print(format_instructions)

prompt = ChatPromptTemplate.from_messages([
    (
        "system",
        "Please think of the recipe for the dish you entered.\n\n"
        "{format_instructions}",
    ),
    ("human", "{dish}"),
])
prompt_with_format_instructions = prompt.partial(
    format_instructions = format_instructions
)

model = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
    api_key=OPEN_API_KEY
).bind(
    response_format = {"type": "json_object"}
)

chain = prompt_with_format_instructions | model | output_parser

recipe = chain.invoke({"dish": "pizza"})
print(type(recipe))
print(recipe)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from langchain_openai import OpenAIEmbeddings

# OpenAI Embeddings API를 사용해서 text-embedding-3-small 이라는 모델로 벡터화한다.
embeddings = OpenAIEmbeddings(
    model="text-embedding-3-small",
    api_key=OPEN_API_KEY,
)

query = "Is there any document loader for reading data from AWS s3?"

# 벡터화 시도, 실제 문서 벡터화 처리는 Vector store 클래스에서 데이터 저장 시 자동 실행된다.
vector = embeddings.embed_query(query)
print(len(vector))
print(vector)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Chroma 라는 로컬에서 사용 가능한 vector store 사용
# 이 외에도 Faiss, Elasticsearch, Redis 등을 vector store로 사용할 수 있다.
from langchain_chroma import Chroma

# 청크로 분할한 문서와 embedding model을 기반으로 Vector store 초기화
db = Chroma.from_documents(docs, embeddings)
# vector store의 인스턴스 생성
retriever = db.as_retriever()

query = "Is there any document loader for reading data from AWS s3?"
context_docs = retriever.invoke(query) # 쿼리와 가까운 문서 검색

print(f"len = {len(context_docs)}")

first_doc = context_docs[0]
print(f"metadata = {first_doc.metadata}")
print(first_doc.page_content)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_template('''\
다음 문맥만을 바탕으로 질문에 답변해 주세요.

문맥: """
{context}
"""

질문: """
{question}
"""
''')

model = ChatOpenAI(
    model_name="gpt-4o-mini",
    temperature=0,
    api_key=OPEN_API_KEY,
)

chain = (
		# 입력이 retriever에 전달되면서 prompt에도 전달된다.
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)

output = chain.invoke(query)

print(output)