LangChain 기초 튜토리얼 파트1

# OpenAI API Key - 유출되지 않게 조심해야함
openai_api_key='YOUR OPENAI API KEY'

# 간단한 문자열로 시작
my_text = "금요일 다음은 뭐지?"

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage, AIMessage

chat = ChatOpenAI(temperature=.7, openai_api_key=openai_api_key)

chat(
    [
        SystemMessage(content="당신은 짧은 문장 하나로 사용자가 무엇을 먹을지 알아내는 데 도움을 주는 AI 봇입니다."),
        HumanMessage(content="나는 토마토를 좋아해요. 나는 무엇을 먹을까요?")
    ]
)

chat(
    [   # 배경 컨텍스트
        SystemMessage(content="당신은 짧은 문장 하나로 사용자가 여행할 곳을 알아내는 데 도움을 주는 AI 봇입니다."),
        # 사람 질문 메세지
        HumanMessage(content="나는 해변을 좋아하는데 어디로 가는게 좋을까요?"),
        # AI 응답 메세지
        AIMessage(content="프랑스의 니스가 좋을것 같군요"),
        # 사람 질문 메세지
        HumanMessage(content="거기에 가면 무엇을 하면 좋을까요?")
    ]
)

from langchain.schema import Document

Document(page_content="이것은 나의 문서입니다. 다른 곳에서 수집한 글들로 가득해요",
         metadata={
             'my_document_id' : 234234,
             'my_document_source' : "LangChain 문서",
             'my_document_create_time' : 1680013019
         })

from langchain.llms import OpenAI

llm = OpenAI(model_name="gpt-3.5-turbo", openai_api_key=openai_api_key)

llm("너에 대해서 자세히 설명해줄래")

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage, AIMessage

chat = ChatOpenAI(temperature=1, openai_api_key=openai_api_key)

chat(
    [   # 배경 컨텍스트
        SystemMessage(content="너는 사용자가 무엇을 말하든 농담을 해서 도움이 되지 않는 AI 봇입니다."),
        # 사람 메세지
        HumanMessage(content="부산에 가고 싶은데 어떻게 해야 하나요?")
    ]
)

from langchain.embeddings import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)

text = "안녕!? 해변에 갈 시간이야!!"

text_embedding = embeddings.embed_query(text)
print (f"임베딩 길이: {len(text_embedding)}")
print (f"임베딩 샘플: {text_embedding[:5]}...")

from langchain.llms import OpenAI

llm = OpenAI(model_name="gpt-3.5-turbo", openai_api_key=openai_api_key)

# 세개의 큰 따옴표를 사용하는것을 읽고 쓰기 쉽기 때문에 선호합니다. 
prompt = """
오늘은 월요일, 내일은 수요일

이 내용에는 어떤 논리적 문제가 있나요?
"""

llm(prompt)

from langchain.llms import OpenAI
from langchain import PromptTemplate

llm = OpenAI(model_name="gpt-3.5-turbo", openai_api_key=openai_api_key)

# "{location}"에 주의하세요, 이것은 나중에 다른 값으로 대체됩니다.
template = """
나는 정말 {location}에 여행 가고 싶어. 어떻게 하면 갈 수 있을까??

짧은 한 문장으로 대답하세요.
"""

prompt = PromptTemplate(
    input_variables=["location"],
    template=template,
)

final_prompt = prompt.format(location="프랑스")

print (f"최종 프롬프트: {final_prompt}")
print ("-----------")
print (f"LLM 결과물: {llm(final_prompt)}")

from langchain.prompts.example_selector import SemanticSimilarityExampleSelector
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.prompts import FewShotPromptTemplate, PromptTemplate
from langchain.llms import OpenAI

llm = OpenAI(model_name="gpt-3.5-turbo", openai_api_key=openai_api_key)

example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="샘플 입력: {input}\n샘플 출력: {output}",
)

# 입출력 예시
examples = [
    {"input": "선원", "output": "배"},
    {"input": "파일럿", "output": "비행기"},
    {"input": "운전수", "output": "자동차"},
    {"input": "나무", "output": "땅"},
    {"input": "새", "output": "둥지"},
]

# SemanticSimilarityExampleSelector는 의미론적 의미로 입력과 유사한 예시를 선택합니다.
example_selector = SemanticSimilarityExampleSelector.from_examples(
    # 선택할 수 있는 예시의 목록입니다.
    examples, 
    
   # 의미론적 유사성을 측정하기 위해 사용되는 임베딩을 생성하는 데 사용되는 임베딩 클래스입니다.
    OpenAIEmbeddings(openai_api_key=openai_api_key), 
    
    # 이것은 임베딩을 저장하고 유사성 검색을 수행하는 데 사용되는 VectorStore 클래스입니다.
    FAISS, 
    
    # 생성할 예시의 수입니다.
    k=2
)

similar_prompt = FewShotPromptTemplate(
    # 예제를 선택하는 데 도움이 될 객체
    example_selector=example_selector,
    
    # 프롬프트
    example_prompt=example_prompt,
    
    # 프롬프트의 상단과 하단에 추가될 맞춤 설정
    prefix="아이템이 보통 어디에서 발견되는지 알려주세요.",
    suffix="Input: {noun}\nOutput:",
    
    # 프롬프트가 받을 입력 내용
    input_variables=["noun"],
)

# 명사 입력!
my_noun = "학생"

print(similar_prompt.format(noun=my_noun))

llm(similar_prompt.format(noun=my_noun))

from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate
from langchain.llms import OpenAI

llm = OpenAI(model_name="gpt-3.5-turbo", openai_api_key=openai_api_key)

# 응답을 어떻게 구조화하길 원하는지에 대한 가벼운 기본 프롬프트 템플릿입니다.
response_schemas = [
    ResponseSchema(name="bad_string", description="이것은 잘못 포맷된 사용자 입력 문자열입니다."),
    ResponseSchema(name="good_string", description="이것은 당신의 응답, 재구성된 응답입니다.")
]

# 출력을 어떻게 파싱하길 원하는지.
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)

# 출력 파서 프롬프로 템플릿 확인
format_instructions = output_parser.get_format_instructions()
print (format_instructions)

template = """
사용자로부터 잘못 작성된 문자열을 받게 될 것입니다.
다시 작성하고 모든 단어의 철자가 올바른지 확인하세요.

{format_instructions}

% 사용자 입력:
{user_input}

% 응답:
"""

prompt = PromptTemplate(
    input_variables=["user_input"],
    partial_variables={"format_instructions": format_instructions},
    template=template
)

promptValue = prompt.format(user_input="한극에 오신것을 환영합니다.")

print(promptValue)

llm_output = llm(promptValue)
llm_output

output_parser.parse(llm_output)

from langchain.document_loaders import HNLoader

loader = HNLoader("https://news.ycombinator.com/item?id=34422627")

data = loader.load()

print (f"{len(data)}개의 댓글")
print (f"샘플:\n\n{''.join([x.page_content[:150] for x in data[:2]])}")

from langchain.text_splitter import RecursiveCharacterTextSplitter

import requests
url = "https://raw.githubusercontent.com/hmkim312/datas/main/Langchain/worked.txt"
response = requests.get(url)
pg_work = response.text
print (f"{len([pg_work])}개의 문서")

text_splitter = RecursiveCharacterTextSplitter(
    # 보여주기 위해 작은 크기로 설정합니다.
    chunk_size = 150,
    chunk_overlap  = 20,
)

texts = text_splitter.create_documents([pg_work])

print (f"{len(texts)}개의 문서")

print ("미리보기:")
print (texts[0].page_content, "\n")
print (texts[1].page_content)

import requests

url = "https://raw.githubusercontent.com/hmkim312/datas/main/Langchain/disc.txt"
response = requests.get(url)

# 파일을 저장하기
file_name = "disc.txt"
with open(file_name, 'w', encoding="utf-8") as f:
    f.write(response.text)

from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

loader = TextLoader(file_name)
documents = loader.load()

# 분할기 준비
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=50)

# 문서 분할
texts = text_splitter.split_documents(documents)

# 임베딩 준비
embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)

# 텍스트 임베딩
db = FAISS.from_documents(texts, embeddings)

# 검색기를 초기화하세요. 단지 1개의 문서만 반환하도록 요청하세요.
retriever = db.as_retriever()

retriever

docs = retriever.get_relevant_documents("저자는 어떤 종류의 것들을 만들고 싶었나요?")

print("\n\n".join([x.page_content[:200] for x in docs[:2]]))

import requests

url = "https://github.com/hmkim312/datas/blob/main/Langchain/worked.txt"
response = requests.get(url)

# 파일을 저장하기
file_name = "worked.txt"
with open(file_name, 'w', encoding="utf-8") as f:
    f.write(response.text)

from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

loader = TextLoader(file_name)
documents = loader.load()

# 분할기 준비
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=50)

# 텍스트 분할
texts = text_splitter.split_documents(documents)

# 임베딩 준비
embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)

print (f"{len(texts)}개의 문서")

embedding_list = embeddings.embed_documents([text.page_content for text in texts])

print (f"{len(embedding_list)}개의 임베딩")
print (f"샘플: {embedding_list[0][:3]}...")

from langchain.memory import ChatMessageHistory
from langchain.chat_models import ChatOpenAI

chat = ChatOpenAI(temperature=0, openai_api_key=openai_api_key)

history = ChatMessageHistory()

history.add_ai_message("안녕!")

history.add_user_message("한국의 수도는 어디야?")

history.messages

ai_response = chat(history.messages)
ai_response

history.add_ai_message(ai_response.content)
history.messages

from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.chains import SimpleSequentialChain

llm = OpenAI(temperature=1, openai_api_key=openai_api_key, max_tokens=1048)

template = """당신은 사용자가 제안하는 지역의 전통적인 요리를 제안합니다..
% 사용자 위치
{user_location}

% 응답:
"""
prompt_template = PromptTemplate(input_variables=["user_location"], template=template)

# 지역
location_chain = LLMChain(llm=llm, prompt=prompt_template)

template = """음식을 주면 집에서 어떻게 만드는지 간단하고 쉬운 레시피를 제공하세요.
% 음식
{user_meal}

% 응답:
"""
prompt_template = PromptTemplate(input_variables=["user_meal"], template=template)

# 음식
meal_chain = LLMChain(llm=llm, prompt=prompt_template)

overall_chain = SimpleSequentialChain(chains=[location_chain, meal_chain], verbose=True)

review = overall_chain.run("rome")

import requests

url = "https://raw.githubusercontent.com/hmkim312/datas/main/Langchain/disc_ko.txt"
response = requests.get(url)

# 파일을 저장하기
file_name = "disc_ko.txt"
with open(file_name, 'w', encoding="utf-8") as f:
    f.write(response.text)

from langchain.chains.summarize import load_summarize_chain
from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

loader = TextLoader('disc_ko.txt')
documents = loader.load()

# 분할기 준비
text_splitter = RecursiveCharacterTextSplitter(chunk_size=700, chunk_overlap=50)

# 분할
texts = text_splitter.split_documents(documents)

chain = load_summarize_chain(llm, chain_type="map_reduce", verbose=True)
chain.run(texts)

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.llms import OpenAI
import json

llm = OpenAI(temperature=0, openai_api_key=openai_api_key)

# SerpApi는 "Search Engine Results Page API"의 약어로, 검색 엔진 결과 페이지에 대한 데이터를 추출하기 위한 서비스나 도구입니다
serpapi_api_key="YOUR SERPAPI API KEY"

toolkit = load_tools(["serpapi"], llm=llm, serpapi_api_key=serpapi_api_key)

agent = initialize_agent(toolkit, llm, agent="zero-shot-react-description", verbose=True, return_intermediate_steps=True)

response = agent({"input":"creep은 누구의 노래인가요?"})

print(response["intermediate_steps"])

# 하입보이가 웨이크원 노래라는걸 보면, 성능은 그닥인걸로..
response = agent({"input":"하입보이는 누구의 노래인가요?"})

print(response["intermediate_steps"])