The Yellow Lion King 데이터와 함께 살아가기

DeepSeek 충격의 배경과 현상 및 원인 이해해기

The Yellow Lion King — Sat, 1 Feb 2025 21:42:54 +0900

최근 이슈가되는 DeepSeek에 대한 그 현상과 원인 설명을 통해 내용 이해에 도움을 드리고자 합니다.

동영상 설명은 아래링크 참고
https://youtu.be/uJuIuCvENQo?si=2JiU1WPhVu_4trpK

현상
- NVIDIA 주가 폭락
- 나스닥 지수 폭락
원인분석
1. DeepSeek App이 Download 1위해서
2. (1위 한 이유는) 좋은 서비스를 무료로 제공해서
3. (좋은 서비스를 무료로 제공할 수 있었던 이유는) 좋은 모델을 싸게 만들어서
4. ~~(좋은 모델을 싸게 만들 수 있었던 이유는) 엔지니어링을 통해 저사양의 서버를 효과적으로 사용해서 (엔지니어링 기법 등 별도 포스팅)~~
5. (저사양의 서버를 효과적으로 사용할 수 있었던 이유는) 좋은 엔지니어들이 있어서
영향도 분석

현상

NVIDIA 주가 폭락

2025년 1월 27일 월요일 하루만에 NVIDIA의 주가가 약 17%가까이 급락했습니다. 거의 6000억 달러의 시장가격이 사라졌다고 합니다.

1월 27일 NVIDIA 주가 16.97% 급락

엔비디아 주가의 차트(1월 27일 급락)

나스닥 지수 폭락

뿐만아니라 특기 기술 주식들이 상장되어있는 나스닥도 급락했습니다.

원인분석

1. DeepSeek App Download 1위

위에서 처럼 왜 이렇게 급락한 것 일까요?
여러가지가 있겠지만 그 주요 이유는 미국 App Store 에서 무료 App중에서 다운로드 1등을 찍은 앱이 DeepSeek라는 앱이었기 때문입니다. DeepSeek라는 앱은 ChatGPT 앱 또는 Perplexity 앱과 같은 AI Assistant App 입니다.

DeepSeek라는 회사나 이름은 잘 모르겠지만 다운로드 1등한 것이 뭐가 큰 문제여서 엔비디아 주가가 폭락한 걸까요?

2. (DeepSeek App이 1위 한 이유는) 좋은 서비스를 무료로 제공해서

먼저 왜 DeepSeek가 미국 앱스토어에서 다운로드 1등을 했는가를 알아볼 필요가 있습니다.
DeepSeek가 성능 좋은 서비스를 무료로 제공했기 때문에 많은 앱 다운로드가 있었고 그래서 다운로드 1등을 했습니다.
DeepSeek 앱은 DeepSeek-V3를 기본으로 하는데 이 모델의 성능이 아래와 같이 다른 모델과 비교해서 동등하거나 보다 우수한 부분도 있거든요.

특히 놀라운 점은 1월 20일에 발표한 DeepSeek-R1의 경우 수학문제풀이와 코딩 밴치마크 테스트에서 OpenAI를 능가하는 성능을 보인 것 입니다.

MATH-300(수학)과 SWE-bench(코딩)에서 우수합니다.

특히 수학(MATH-500)에서 OpenAI의 o1-mini보다 좋은 점수를 보입니다.

이처럼 좋은 모델을 (ChatGPT 에서는 별도 비용을 지불해야하지만) DeepSeek 앱에서는 무료로 사용할 수 있기 때문에 DeepSeek App이 미국 App Store에서 다운로드 1위를 할 수 있었습니다.

조금 다른 이야기이지만 API 비용도 저렴합니다.
DeepSeek는 훈련도 싸게하고 추론(서비스)도 저렴하게 할 수 있기 때문에 서비스도 무료나 저렴하게 제공합니다. 예를들어 OpenAI ChatGPT에서는 유료 가입회원에게만 제공하는 o1 모델과 유사한 성능의 서비스를 무료로 제공하고 있습니다.

OpenAI는 o1모델이용을 위해 Plus 요금제 가입이 필요

OpenAI에서 제공하는o1-mini 모델의 API 비용

DeepSeek-R1 모델의 API비용 및 OpenAI o1-mini와 비교

3. (좋은 서비스를 무료로 제공할 수 있었던 이유는) 좋은 모델을 싸게 만들어서

DeepSeek는 OpenAI의 Chat-GPT나 Meta의 Llama의 성능을 낼 수 있는 또 다른 모델(DeepSeek-R1)을 매우 적은 비용으로 만들었습니다. 무려 10분의 1 도 안되는 비용으로 말이지요. DeepSeek에서는 5.6M 달러가 들었다고 발표했는데 다른 회사에서는 수억 달러 또는 수십억 달러 정도 들었다고 했거든요.

4. (좋은 모델을 싸게 만들 수 있었던 이유는) 엔지니어링을 통해 저사양의 서버를 효과적으로 사용해서

이렇게 저비용으로 모델을 만들고 서비스할 수 있었던 이유에는 (데이터, 환경, 인프라, 리소스 등) 여려가지가 있겠지만 저는 한마디로 말하면

DeepSeek가 엔지니어링을 잘했다

라고 말할 수 있겠습니다. 모델을 개발하고 서비스할 때 하드웨어를 효율적으로 운영할 수 있도록 여러 테크닉을 적용해서 개발했기 때문입니다. DeepSeep에서 발표한 모델은 많은 제약과 한계를 극복하기 위해 다양한 아이디어의 기술을 적용했습니다.
어떻게 엔지니어링을 했는지는 별도 포스팅
엔지니어링을 잘해서 비용 효율적인 모델과 서비스를 만들었습니다.
이처럼 좋은 모델을 만든 것도 대단한데 더욱 놀라운 것은 이러한 모델을 NVIDIA H800이라는 서버를 이용해서 만들었다는 것 입니다.
DeepSeek는

NVIDIA H800서버 2048대를 클러스터로 만들어서 훈련

했습니다. 그 이유는 미국의 규제로 인하여 중국에 납품하는 NVIDIA 서버는 제한되어있기 때문입니다. 그래서 더 좋은 서버를 사용할 수 없었습니다. H800서버는 H100서버의 다운 스펙서버입니다. 그럼에도 불구하고 더 짧은 시간의 훈련시간과 좋은 성능을 달성했으니 놀라지 않을 수 없습니다.

나무위키 설명 내용중 일부

클리앙 글

위 클리앙의 내용을 보니 구체적으로, FP64일때의 성능과 NVLink, Interconnection bandwidth에서 차이가 나네요.

5. (저사양의 서버를 효과적으로 사용할 수 있었던 이유는) 좋은 엔지니어들이 있어서

그럴 수 있었던 것은 DeepSeek회사 직원들의 배경이 주식자동거래 프로그램을 만드는 퀀트들이었다고 하네요. 그래서 최적화를 위한 다양한 레벨의 인지니어링이 가능했다고 생각합니다.

영향도 분석(별도 포스팅)

미국 정부
먼저 이번 DeepSeek 이슈로 인하여 AI에 대해서 미국 리더십을 확실하게 가져 가려고 했던 트럼프 정부를 긴장시킨 것은 맞는 것 같습니다. 트럼프가 미국 기업에게 알람이 되어야 한다고 이야기 했으니까요. 기존에는 AI 개발을 위해서 인프라가 중요하고, 인프라에서 우위를 점하고 있는 미국이 당연히 계속해서 앞서 나갈 것으로 생각했는데, 그리고 그래서 더욱 앞서 나가기 위해서 향후 투자 계획도 발표했는데 안좋은 인프라에서도 AI개발이 가능하다고하는 사례가 나왔기 때문이지요. 그렇기 때문에 중국에 대한 견제는 더욱 심해질 것으로 예상됩니다. 새로운 규제가 더 나올 수도 있겠지요. 그리고 AI 경쟁에서의 스푸트니크 쇼크를(소련이 먼저 인공위성을 쏘아올려서 미국을 깜짝 놀라게 만들었던 사건을) 방지하기위해 AI 관련 투자에 더욱 노력할 수 있습니다.
AI 관련 미국 기업
위에서 말한 것처럼 저사양의 서버로도 훈련하고 서비스할 수 있다면 굳이 비싼 서버를 사용할 필요가 없지요. 고사양의 비싼 서버를 구매할 필요가 당분간은 줄어들 것으로 예상됩니다. 그래서 엔비디아 같은 기업의 경우 매출 감소가 예상이되니 주가가 하락한 것이죠. 그러나 반대로 적은 비용으로도 AI 모델 개발이 가능해지니 더 많은 기업들이 뛰어들어서 전체적인 서버 수요는 늘어날 것이라는 예상도 있습니다.
Software 중심의 Big Tech기업의 경우 당연히 엔지니어링에 더욱 집중 할 것으로 예상됩니다. 좋은 사례를 보았으니 유사하거나 더 좋은 방법을 찾고자 노력할 것으로 예상됩니다.
AI 관련 한국 기업
같은 맥락에서 한국의 Software 기업에게도 기회가 생겼다고 할수 있습니다. 적은 비용으로 고성능의 품질 좋은 AI서비스를 만들 수 있게되었으니
SK하이닉스나 삼정전자 같은 Hardware 기업은 단기적으로 엔비디아와 같이 실적이 줄어들 수 있을 것 같습니다. 서버 수요가 늘어난다고 해도 저사양, 낮은 단가의 서버이기 때문에 높은 부가가치를 바라기는 어렵게 되는 거죠. 그러나 이건 단기적인 추세일 것 같고 결국 먼 미래에는 더 많은 수요가 생길 것 같습니다.

Source

NVIDIA 주가 조회
나스닥 지수 조회
DeepSeek 1등 뉴스

DeepSeek hits No. 1 on Apple's app store

DeepSeek, a Chinese startup, rocked the AI world after debuting a model that rivaled the capabilities of OpenAI's ChatGPT for a fraction of the price.

www.businessinsider.com

DeepSeek API Docs(버전 릴리즈 공지 내용)

Introducing DeepSeek-V3 | DeepSeek API Docs

Biggest leap forward yet

api-docs.deepseek.com

관련 CNN 뉴스

나무위키 DeepSeek

DeepSeek

DeepSeek( 深度求索 , 심도구색)는 중국의 헤지펀드 회사 환팡 퀀트 ( ) 소속 인공지능 연구

namu.wiki

클리앙 H100, H800 비교

Nvidia H100 vs H800 : 클리앙

구형이라길래 A100 수준인줄 알았는게 그게아니라 H100을 중국 규제에 맞춰서 만든 저가형 모델이네요. 메모리 대역폭이 반이라는데 제가 보기에는 실제로 성능에는 큰 차이가 없어 보여요. H100

www.clien.net

mbread

The Yellow Lion King — Sat, 10 Aug 2024 15:56:00 +0900

{

"target": 2,

"1":{ "type": "경비", "to_company": "워크넷", "to_addr": "replay7013@gmail.com", "subject": "경비 테스트 이메일 제목입니다.", "contents": "안녕하세요,\n빵맨용역입니다.\n 경비원 모집공고를 첨부와 같이 요청드립니다.\n감사합니다.", "replace_words": ["모집직종_1_SEP_경비", "임금_1_SEP_3,500,000", "아파트명_1_SEP_아파트 꽃매버들지능", "근무시간_1_SEP_09:00~23:00"] },

"2":{ "type": "미화", "to_company": "인크루트", "to_addr": "xlangclass@gmail.com", "subject": "미화 테스트 이메일 제목입니다.", "contents": "안녕하세요,\n빵맨용역입니다.\n 미화원 미화원 모집공고를 첨부와 같이 요청드립니다.\n감사합니다.", "replace_words": ["모집직종_1_SEP_미화", "임금_1_SEP_1,500,000", "아파트명_1_SEP_아파트 꽃매버들지능", "근무시간_1_SEP_09:00~16:00"] } ,

"3":{ "type": "테스트 사용하지 말것", "to_company": "인크루트", "to_addr": "test@gmail.com", "subject": "테스트 이메일 제목입니다.", "contents": "안녕하세요,\n빵맨용역입니다.\n모집공고를 첨부와 같이 요청드립니다.\n감사합니다.", "replace_words": ["모집직종_1_SEP_미화", "임금_1_SEP_1,500,000", "아파트명_1_SEP_테스트주소", "근무시간_1_SEP_09:00~16:00"] }

}

AWS Partner Tech Grue Community

The Yellow Lion King — Fri, 19 Apr 2024 13:36:23 +0900

안녕하세요

지난 주 AWS Partner Tech Grue Community Meet-up 에 다녀 왔습니다.

TGC는 AWS 에서 Partner Engineer를 대상으로 기술 관련 공유 토의하는 모임 입니다.
올해 그 첫번째 모임으로 지난주 강남 센터필드에서 열렸어요. 오신 분들 모두 파트너사의 기술 관련 업무를 (한가닥?) 하시는 분들이었어요. 조건이 파트너사의 직원이고 AWS 자격증 요건 또는 AWS Ambassador 등 여러가지가 있었습니다. 어려울 것 같았는데 저도 운 좋게 참여하게 되었습니다.

이번은 올해 첫 모임으로 전반적인 계획을 공유하는 시간이었고요, 기술 모임인 만큼 Ambassador 분들의 발표도 있었습니다.

저녁 퇴근후에 모임이다보니 출출함을 달래줄 피자와 치킨, 맥주와 음료 등도 제공해 주셨습니다.

새로운 기술과 트랜드 그리고 이에 대한 AWS의 새로운 기능 들을 먼저 만나볼 수있을 것 같아서 기분이 설래입니다.
앞으로 따끈따끈한 소식 전하겠습니다.
감사합니당~~~

LCEL-왜 LCEL을 사용하는가?

The Yellow Lion King — Sun, 21 Jan 2024 15:28:52 +0900

지난 시간에는 LCEL Get-started를 통해서 LCEL의 간단하면서 다양한 예시를 알아보았습니다.

이번 시간에는 LCEL을 사용하는 이유에 대해서 알아보도록 하겠습니다. 즉, 사용하면 무엇이 좋은지 어떤 가치가 있는지 알아보겠습니다. 참고로 LCEL Get-started를 먼저 보고 오시면 이해에 도움이 됩니다. 혹시 안보셨다면 먼저 읽어보시기를 추천 드립니다.

LCEL은 간단한 콤포넌트 부터 복잡한 체인을 쉽게 만들 수 있게 합니다. 바로 다음과 같은 것들을 이용해서 만듭니다.

1. 통일된 인터페이스:

모든 LCEL 객체는 Runnable 인터페이스를 구현합니다. Runnable은 호출하는 메소드들의 공통 집합을 정의합니다.(invoke, batch, stream, ainvoke,...등과 같은...) 이것은 LCEL객체가 자동적으로 이러한 호출들을 지원할 수 있게 만듭니다. 즉, LCEL 객체로 만든 모든 체인은 하나의 LCEL객체라는 것을 말합니다.

2. 원시도구들의 구성:

LCEL의 가치를 이해하기 위해서, LCEL 없이 비슷한 기능을 어떻게 개발하는 지 생각해보고 동작하는 지를 살펴보는 것은 도움이 됩니다. LCEL은 콤포넌트들을 병렬화하고, fallbacks을 추가하고, 체인 내부의 구성을 동적으로 바꾸는 등을 통해서 체인을 쉽게 구성하게 해줍니다. 이번 포스팅에서는 지난 번 LCEL Get-started의 내용에 있던 기본 예시를 다루어 보겠습니다. 간단한 프롬프트와 모델이 결합된 체인을 다루어 볼껀데요, 이것은 이미 많은 기능들이 정의되어 있습니다. 이것을 재생성하는 데 필요한 것이 무엇인지 살펴보겠습니다.

준비

먼저 공통적으로 필요한 체인 하나를 만들어 보겠습니다.

%pip install –upgrade –quiet langchain-core langchain-openai

관련된 패키지를 설치 합니다.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser


prompt = ChatPromptTemplate.from_template("Tell me a short joke about {topic}")
model = ChatOpenAI(model="gpt-3.5-turbo")
output_parser = StrOutputParser()

chain = prompt | model | output_parser

프롬프트, 모델, 아웃풋 파서를 연결한 체인을 만듭니다.

이제부터 다음 내용을 구현할 때 두가지 경우의 코드를 비교하겠습니다. 즉, LCEL 없이 구현할 때와 LCEL로 구현할 때의 코드를 보겠습니다.

invoke, stream, batch, async, changing model provider, runtime configuration, logging, Fallback

Invoke

제일 간단한 사용예를 보면, 토픽(주제) 문자열을 전달해 주 농담 문자열을 받는 것 입니다. 아래는 이러한 내용을 LCEL 없이 개발했을 때와 LCEL로 개발했을 때의 차이를 보여 줍니다.

LCEL 없이 만드는 경우

from typing import List

import openai


prompt_template = "Tell me a short joke about {topic}"
client = openai.OpenAI()

def call_chat_model(messages: List[dict]) -> str:
    response = client.chat.completions.create(
        model="gpt-3.5-turbo", 
        messages=messages,
    )
    return response.choices[0].message.content

def invoke_chain(topic: str) -> str:
    prompt_value = prompt_template.format(topic=topic)
    messages = [{"role": "user", "content": prompt_value}]
    return call_chat_model(messages)

invoke_chain("ice cream")

LCEL로 만드는 경우

from langchain_core.runnables import RunnablePassthrough


prompt = ChatPromptTemplate.from_template(
    "Tell me a short joke about {topic}"
)
output_parser = StrOutputParser()
model = ChatOpenAI(model="gpt-3.5-turbo")
chain = (
    {"topic": RunnablePassthrough()} 
    | prompt
    | model
    | output_parser
)

chain.invoke("ice cream")

비교 이미지

Stream

만약에 결과로 스트림을 원한다면 위에서 LCEL 없이 만든 함수의 내용을 수정해야 합니다.

LCEL 없이 만드는 경우

from typing import Iterator


def stream_chat_model(messages: List[dict]) -> Iterator[str]:
    stream = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        stream=True,
    )
    for response in stream:
        content = response.choices[0].delta.content
        if content is not None:
            yield content

def stream_chain(topic: str) -> Iterator[str]:
    prompt_value = prompt.format(topic=topic)
    return stream_chat_model([{"role": "user", "content": prompt_value}])


for chunk in stream_chain("ice cream"):
    print(chunk, end="", flush=True)

LCEL로 만드는 경우

for chunk in chain.stream("ice cream"):
    print(chunk, end="", flush=True)

LCEL로 만드는 경우는 그저 두 줄의 코드면 충분합니다.

Batch

병렬적으로 여러 입력을 배치로 실행하기 원한다면 또 다시 새로운 함수가 필요합니다.

LCEL 없이 만드는 경우

from concurrent.futures import ThreadPoolExecutor


def batch_chain(topics: list) -> list:
    with ThreadPoolExecutor(max_workers=5) as executor:
        return list(executor.map(invoke_chain, topics))

batch_chain(["ice cream", "spaghetti", "dumplings"])

LCEL로 만드는 경우

chain.batch(["ice cream", "spaghetti", "dumplings"])

Async

비동기 버전을 원한다면,

LCEL 없이 만드는 경우

async_client = openai.AsyncOpenAI()

async def acall_chat_model(messages: List[dict]) -> str:
    response = await async_client.chat.completions.create(
        model="gpt-3.5-turbo", 
        messages=messages,
    )
    return response.choices[0].message.content

async def ainvoke_chain(topic: str) -> str:
    prompt_value = prompt_template.format(topic=topic)
    messages = [{"role": "user", "content": prompt_value}]
    return await acall_chat_model(messages)

LCEL로 만드는 경우

chain.ainvoke("ice cream")

Chat Model 대신 LLM 사용

chat 엔드포인트 대신에 completion 엔드포인트를 사용하기 원한다면,

LCEL없이 만드는 경우

def call_llm(prompt_value: str) -> str:
    response = client.completions.create(
        model="gpt-3.5-turbo-instruct",
        prompt=prompt_value,
    )
    return response.choices[0].text

def invoke_llm_chain(topic: str) -> str:
    prompt_value = prompt_template.format(topic=topic)
    return call_llm(prompt_value)

invoke_llm_chain("ice cream")

LCEL로 만드는 경우

from langchain_openai import OpenAI

llm = OpenAI(model="gpt-3.5-turbo-instruct")
llm_chain = (
    {"topic": RunnablePassthrough()} 
    | prompt
    | llm
    | output_parser
)

llm_chain.invoke("ice cream")

모델 제공자가 다른 경우

OpenAI 대신에 Anthropic을 사용하기 원하면,

LCEL 없이 만드는 경우

import anthropic

anthropic_template = f"Human:\n\n{prompt_template}\n\nAssistant:"
anthropic_client = anthropic.Anthropic()

def call_anthropic(prompt_value: str) -> str:
    response = anthropic_client.completions.create(
        model="claude-2",
        prompt=prompt_value,
        max_tokens_to_sample=256,
    )
    return response.completion    

def invoke_anthropic_chain(topic: str) -> str:
    prompt_value = anthropic_template.format(topic=topic)
    return call_anthropic(prompt_value)

invoke_anthropic_chain("ice cream")

LCEL로 만드는 경우

from langchain_community.chat_models import ChatAnthropic

anthropic = ChatAnthropic(model="claude-2")
anthropic_chain = (
    {"topic": RunnablePassthrough()} 
    | prompt 
    | anthropic
    | output_parser
)

anthropic_chain.invoke("ice cream")

실행 환경 설정(Runtime configurability)

LCEL 없이 만드는 경우

def invoke_configurable_chain(
    topic: str, 
    *, 
    model: str = "chat_openai"
) -> str:
    if model == "chat_openai":
        return invoke_chain(topic)
    elif model == "openai":
        return invoke_llm_chain(topic)
    elif model == "anthropic":
        return invoke_anthropic_chain(topic)
    else:
        raise ValueError(
            f"Received invalid model '{model}'."
            " Expected one of chat_openai, openai, anthropic"
        )

def stream_configurable_chain(
    topic: str, 
    *, 
    model: str = "chat_openai"
) -> Iterator[str]:
    if model == "chat_openai":
        return stream_chain(topic)
    elif model == "openai":
        # Note we haven't implemented this yet.
        return stream_llm_chain(topic)
    elif model == "anthropic":
        # Note we haven't implemented this yet
        return stream_anthropic_chain(topic)
    else:
        raise ValueError(
            f"Received invalid model '{model}'."
            " Expected one of chat_openai, openai, anthropic"
        )

def batch_configurable_chain(
    topics: List[str], 
    *, 
    model: str = "chat_openai"
) -> List[str]:
    # You get the idea
    ...

async def abatch_configurable_chain(
    topics: List[str], 
    *, 
    model: str = "chat_openai"
) -> List[str]:
    ...

invoke_configurable_chain("ice cream", model="openai")
stream = stream_configurable_chain(
    "ice_cream", 
    model="anthropic"
)
for chunk in stream:
    print(chunk, end="", flush=True)

# batch_configurable_chain(["ice cream", "spaghetti", "dumplings"])
# await ainvoke_configurable_chain("ice cream")

LCEL로 만드는 경우

from langchain_core.runnables import ConfigurableField


configurable_model = model.configurable_alternatives(
    ConfigurableField(id="model"), 
    default_key="chat_openai", 
    openai=llm,
    anthropic=anthropic,
)
configurable_chain = (
    {"topic": RunnablePassthrough()} 
    | prompt 
    | configurable_model 
    | output_parser
)



configurable_chain.invoke(
    "ice cream", 
    config={"model": "openai"}
)
stream = configurable_chain.stream(
    "ice cream", 
    config={"model": "anthropic"}
)
for chunk in stream:
    print(chunk, end="", flush=True)

configurable_chain.batch(["ice cream", "spaghetti", "dumplings"])

# await configurable_chain.ainvoke("ice cream")

로깅(Logging)

LCEL 없이 만드는 경우

def invoke_anthropic_chain_with_logging(topic: str) -> str:
    print(f"Input: {topic}")
    prompt_value = anthropic_template.format(topic=topic)
    print(f"Formatted prompt: {prompt_value}")
    output = call_anthropic(prompt_value)
    print(f"Output: {output}")
    return output

invoke_anthropic_chain_with_logging("ice cream")

LCEL 로 만드는 경우

import os

os.environ["LANGCHAIN_API_KEY"] = "..."
os.environ["LANGCHAIN_TRACING_V2"] = "true"

anthropic_chain.invoke("ice cream")

Fallbacks

LCEL 없이 만드는 경우

def invoke_chain_with_fallback(topic: str) -> str:
    try:
        return invoke_chain(topic)
    except Exception:
        return invoke_anthropic_chain(topic)

async def ainvoke_chain_with_fallback(topic: str) -> str:
    try:
        return await ainvoke_chain(topic)
    except Exception:
        # Note: we haven't actually implemented this.
        return ainvoke_anthropic_chain(topic)

async def batch_chain_with_fallback(topics: List[str]) -> str:
    try:
        return batch_chain(topics)
    except Exception:
        # Note: we haven't actually implemented this.
        return batch_anthropic_chain(topics)

invoke_chain_with_fallback("ice cream")
# await ainvoke_chain_with_fallback("ice cream")
batch_chain_with_fallback(["ice cream", "spaghetti", "dumplings"]))

LCEL 로 만드는 경우

fallback_chain = chain.with_fallbacks([anthropic_chain])

fallback_chain.invoke("ice cream")
# await fallback_chain.ainvoke("ice cream")
fallback_chain.batch(["ice cream", "spaghetti", "dumplings"])

전체 코드 비교

이렇게 단순한 경우에도 LCEL 체인이 많은 기능들을 잘 압축해서 제공합니다. 체인들이 더 복잡해 줄 수록 이런 간단함은 더욱 특별한 가치를 가지게 됩니다.

LCEL 없이 만드는 경우

from concurrent.futures import ThreadPoolExecutor
from typing import Iterator, List, Tuple

import anthropic
import openai


prompt_template = "Tell me a short joke about {topic}"
anthropic_template = f"Human:\n\n{prompt_template}\n\nAssistant:"
client = openai.OpenAI()
async_client = openai.AsyncOpenAI()
anthropic_client = anthropic.Anthropic()

def call_chat_model(messages: List[dict]) -> str:
    response = client.chat.completions.create(
        model="gpt-3.5-turbo", 
        messages=messages,
    )
    return response.choices[0].message.content

def invoke_chain(topic: str) -> str:
    print(f"Input: {topic}")
    prompt_value = prompt_template.format(topic=topic)
    print(f"Formatted prompt: {prompt_value}")
    messages = [{"role": "user", "content": prompt_value}]
    output = call_chat_model(messages)
    print(f"Output: {output}")
    return output

def stream_chat_model(messages: List[dict]) -> Iterator[str]:
    stream = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        stream=True,
    )
    for response in stream:
        content = response.choices[0].delta.content
        if content is not None:
            yield content

def stream_chain(topic: str) -> Iterator[str]:
    print(f"Input: {topic}")
    prompt_value = prompt.format(topic=topic)
    print(f"Formatted prompt: {prompt_value}")
    stream = stream_chat_model([{"role": "user", "content": prompt_value}])
    for chunk in stream:
        print(f"Token: {chunk}", end="")
        yield chunk

def batch_chain(topics: list) -> list:
    with ThreadPoolExecutor(max_workers=5) as executor:
        return list(executor.map(invoke_chain, topics))

def call_llm(prompt_value: str) -> str:
    response = client.completions.create(
        model="gpt-3.5-turbo-instruct",
        prompt=prompt_value,
    )
    return response.choices[0].text

def invoke_llm_chain(topic: str) -> str:
    print(f"Input: {topic}")
    prompt_value = promtp_template.format(topic=topic)
    print(f"Formatted prompt: {prompt_value}")
    output = call_llm(prompt_value)
    print(f"Output: {output}")
    return output

def call_anthropic(prompt_value: str) -> str:
    response = anthropic_client.completions.create(
        model="claude-2",
        prompt=prompt_value,
        max_tokens_to_sample=256,
    )
    return response.completion   

def invoke_anthropic_chain(topic: str) -> str:
    print(f"Input: {topic}")
    prompt_value = anthropic_template.format(topic=topic)
    print(f"Formatted prompt: {prompt_value}")
    output = call_anthropic(prompt_value)
    print(f"Output: {output}")
    return output

async def ainvoke_anthropic_chain(topic: str) -> str:
    ...

def stream_anthropic_chain(topic: str) -> Iterator[str]:
    ...

def batch_anthropic_chain(topics: List[str]) -> List[str]:
    ...

def invoke_configurable_chain(
    topic: str, 
    *, 
    model: str = "chat_openai"
) -> str:
    if model == "chat_openai":
        return invoke_chain(topic)
    elif model == "openai":
        return invoke_llm_chain(topic)
    elif model == "anthropic":
        return invoke_anthropic_chain(topic)
    else:
        raise ValueError(
            f"Received invalid model '{model}'."
            " Expected one of chat_openai, openai, anthropic"
        )

def stream_configurable_chain(
    topic: str, 
    *, 
    model: str = "chat_openai"
) -> Iterator[str]:
    if model == "chat_openai":
        return stream_chain(topic)
    elif model == "openai":
        # Note we haven't implemented this yet.
        return stream_llm_chain(topic)
    elif model == "anthropic":
        # Note we haven't implemented this yet
        return stream_anthropic_chain(topic)
    else:
        raise ValueError(
            f"Received invalid model '{model}'."
            " Expected one of chat_openai, openai, anthropic"
        )

def batch_configurable_chain(
    topics: List[str], 
    *, 
    model: str = "chat_openai"
) -> List[str]:
    ...

async def abatch_configurable_chain(
    topics: List[str], 
    *, 
    model: str = "chat_openai"
) -> List[str]:
    ...

def invoke_chain_with_fallback(topic: str) -> str:
    try:
        return invoke_chain(topic)
    except Exception:
        return invoke_anthropic_chain(topic)

async def ainvoke_chain_with_fallback(topic: str) -> str:
    try:
        return await ainvoke_chain(topic)
    except Exception:
        return ainvoke_anthropic_chain(topic)

async def batch_chain_with_fallback(topics: List[str]) -> str:
    try:
        return batch_chain(topics)
    except Exception:
        return batch_anthropic_chain(topics)

LCEL로 만드는 경우

import os

from langchain_community.chat_models import ChatAnthropic
from langchain_openai import ChatOpenAI
from langchain_openai import OpenAI
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough, ConfigurableField

os.environ["LANGCHAIN_API_KEY"] = "..."
os.environ["LANGCHAIN_TRACING_V2"] = "true"

prompt = ChatPromptTemplate.from_template(
    "Tell me a short joke about {topic}"
)
chat_openai = ChatOpenAI(model="gpt-3.5-turbo")
openai = OpenAI(model="gpt-3.5-turbo-instruct")
anthropic = ChatAnthropic(model="claude-2")
model = (
    chat_openai
    .with_fallbacks([anthropic])
    .configurable_alternatives(
        ConfigurableField(id="model"),
        default_key="chat_openai",
        openai=openai,
        anthropic=anthropic,
    )
)

chain = (
    {"topic": RunnablePassthrough()} 
    | prompt 
    | model 
    | StrOutputParser()
)

요약

이번 시간에는 LCEL을 실제로 사용할 때와 안했을 때의 차이 비교를 통해서 LCEL이 제공하는 가치에 대해서 알아보았습니다. LCEL이 통일된 인터페이스를 제공하고 많은 원시 구성 요소들을 제공하기 때문에 간단한 메소드 호출 만으로 많은 기능을 대신할 수 있음을 사례로 살표 보았습니다. 이러한 사례를 통해서 단순하고 간결한 코드 작성으로 구현이 가능함을 확인 하였습니다.

Next Steps

LCEL에 대한 학습을 계속하려면 다음을 권장합니다:

여기서 부분적으로 다룬 LCEL 인터페이스에 대해 전체 내용을 자세히 읽어보세요.

LCEL이 제공하는 추가적인 구성 기본 요소에 대해 학습하기 위해서 How-to 섹션을 탐험하세요.

공통 사용 사례에 대한 LCEL 동작을 보려면 Cookbook 섹션을 확인하세요. 그 다음에 살펴볼 좋은 사용 사례는 검색 증강 생성입니다.

LCEL-Get started : 시작해 보기

The Yellow Lion King — Sat, 13 Jan 2024 13:29:41 +0900

LangChain 표현 언어 또는 LCEL은 체인을 쉽게 조립하는 선언적인 방법입니다. LCEL은 상용 서비스부터 프로토 타입을 구현하는 데 코드 변경 없이 지원하도록 처음부터 설계되었습니다. 가장 간단한 "프롬프트 + LLM" 체인에서부터 가장 복잡한 체인까지(사람들이 100개 이상의 단계로 구성된 LCEL 체인을 성공적으로 운영했습니다) 모두 지원합니다. LCEL을 사용하려는 이유 중에서 몇 가지를 강조해보겠습니다:

스트리밍 지원: LCEL로 체인을 빌드하면 첫 번째 출력이 나올 때까지의 경과 시간 최대한 줄일 수 있습니다. 일부 체인의 경우, LLM에서 스트리밍 출력 파서로 토큰을 직접 전송하고, LLM이 원시 토큰을 출력하는 속도와 동일한 속도로 파싱된 증분 출력 묶음(청크)를 얻을 수 있습니다.
비동기 지원: LCEL로 작성된 모든 체인은 동기식 API(예: 프로토타입을 만들 때 Jupyter 노트북에서) 및 비동기식 API(예: LangServe 서버에서)로 호출할 수 있습니다. 이는 프로토타입 및 프로덕션에서 동일한 코드를 사용하여 훌륭한 성능을 내고, 동일한 서버에서 많은 동시 요청을 처리할 수 있게 해줍니다.
최적화된 병렬 실행: LCEL 체인에 병렬로 실행할 수 있는 단계가 있는 경우(예: 여러 Retriver에서 문서를 가져오는 경우), 대기 시간을 최소화 하기 위해서 동기 및 비동기 인터페이스를 자동으로 실행됩니다.
재시도 및 예비 기능: LCEL 체인의 어떤 부분이든 재시도 및 예비 기능을 구성할 수 있습니다. 이것은 규모가 큰 체인을 더 신뢰할 수 있게 만드는 좋은 방법입니다. 현재 재시도/예비 기능에 대한 스트리밍 지원을 추가 중이므로 나중에는 추가된 신뢰성을 얻을 수 있으면서도 동시에 추가 대기 시간이 필요 없습니다.
중간 결과에 대한 액세스: 더 복잡한 체인의 경우 종종 최종 출력이 생성되기 전에 중간 단계의 결과에 액세스하는 것이 매우 유용합니다. 이는 최종 사용자에게 무언가가 발생하고 있음을 알리거나 체인을 디버그하는 데 사용될 수 있습니다. 중간 결과를 스트리밍할 수 있으며 모든 LangServe 서버에서 사용 가능합니다.
입력 및 출력 스키마: 입력 및 출력 스키마는 각 LCEL 체인에 대한 Pydantic 및 JSONSchema 스키마를 제공하며 체인의 구조에서 유추됩니다. 이는 입력 및 출력의 유효성 검사에 사용될 수 있으며 LangServe의 중요한 부분입니다.
원활한 LangSmith 추적 통합: 체인이 더 복잡해질수록 모든 단계를 정확히 이해하는 것이 점점 중요해집니다. LCEL을 사용하면 모든 단계가 최대의 가시성과 디버깅 가능성을 위해 자동으로 LangSmith에 로그됩니다.
원활한 LangServe 배포 통합: LCEL로 생성된 모든 체인은 LangServe를 사용하여 쉽게 배포할 수 있습니다.

LCEL 시작하기 : Get started

LCEL은 기본 콤포넌트를 가지고 복잡한 체인을 쉽게 만들 수 있게 합니다. 그리고 로깅과 병렬처리, 스트리밍과 같은 외부 기능으로의 확대를 지원 합니다.

기본 예제 : 프롬프트 + 모델 + 출력 파서

가장 기본적이고 일반적인 사용 예제는 프롬프트 템플릭과 모델을 함께 체인으로 묶는 것 입니다. 이것이 어떻게 동작하는지 보기 위해서 하나의 토픽을 받아서 하나의 농담을 생성하는 체인을 만들어 보시지요.

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template("tell me a short joke about {topic}")
model = ChatOpenAI()
output_parser = StrOutputParser()

chain = prompt | model | output_parser

chain.invoke({"topic": "ice cream"})

"Why did the ice cream go to therapy?\n\nBecause it had too many toppings and couldn't find its cone-fidence!"

아래의 코드를 통해서 우리는 다른 콤포넌트들을 LCEL을 이용해서 하나로 묶을 수 있습니다.

chain = prompt | model | output_parser

여기서 | 기호는 유닉스의 파이프 연산자 입니다. 이것은 하나의 콤포넌트에서 나온 아웃풋을 다 음 콤포넌트의 입력으로 제공하여 체인을 만듭니다.

이 체인의 입력은 프롬프트 템플릿으로 전달 됩니다. 그리고 그 프롬프트 템플릿의 출력은 모델로 전달 됩니다. 그리고 모델의 출력은 아웃풋 파서에게 전달 됩니다. 무슨일이 벌어지는지 정확히 이해하기 위해서 콤포넌트들을 각각 알아보시죠.

1. Prompt

프롬프트는 BasePromptTemplate입니다. 이것은 템플릿 변수로 사전(dictionary)을 받아서 PromptValue를 생성합니다. PromptValue는 (입력으로 문자열을 받는) LLM 이나 (입력으로 연속된 메시지를 받는) ChatModel에 전달될 수 있는 완성된 프롬프트로 만드는 랩퍼입니다. 이것은 BaseMessages나 문자열을 만드는 로직을 정의하기 때문에 두 언어모델과 함께 사용 할 수 있습니다.

prompt_value = prompt.invoke({"topic": "ice cream"})
prompt_value

# 출력 내용
ChatPromptValue(messages=[HumanMessage(content='tell me a short joke about ice cream')])

prompt_value.to_messages()

# 출력 내용 : HumanMessage 객체
[HumanMessage(content='tell me a short joke about ice cream')]

prompt_value.to_string()

# 출력 내용: 문자열
'Human: tell me a short joke about ice cream'

2. Model

그리고나서 PromptValue 는 모델에게 전달 됩니다. 이번에 우리가 사용한 모델 이 ChatModel이기 때문에 아웃풋은 BaseMessage일 껍니다.

message = model.invoke(prompt_value)
message

# 출력 내용
AIMessage(content="Why did the ice cream go to therapy? \n\nBecause it had too many toppings and couldn't find its cone-fidence!")

만약에 우리의 모델이 LLM이라면 이것의 출력은 문자열일 껍니다.

from langchain.llms import OpenAI

llm = OpenAI(model="gpt-3.5-turbo-instruct")
llm.invoke(prompt_value)

3. Output parser

그리고 마지막으로 우리는 우리의 모델 아웃풋을 아웃풋 파서에 전달 합니다. 아웃풋 파써가 BaseOutputParser라는 것은 문자열이나 BaseMessage를 입력으로 받는 다는 것을 의미합니다.

output_parser.invoke(message)

# 출력 내용
"Why did the ice cream go to therapy? \n\nBecause it had too many toppings and couldn't find its cone-fidence!"

4. 전체 Pipeline

다음의 단계를을 따라 갑니다.:

{"topic": "ice cream"}과 같이 원하는 토픽을 사용자 입력으로 전달합니다.
프롬프트는 사용자 입력을 받는데 이것은 토픽을 이용해서 프롬프트를 만든 다음 PromptValue를 생성하는데 사용합니다.
모델 콤포넌트는 생성된 프롬프트를 받아서 OpenAI LLM 모델에 전달합니다. 이 모델의 출력으로 생성된 것은 ChatMessage 오브젝트입니다.
마지막으로, output_parser 콤포넌트는 ChatMessage 오브젝트를 입력 받고 파이썬 문자열로 변환하여 invoke 메소드로 반환합니다.

만약에 어떤 콤포넌트든지 출력에 대해서 궁금한 점이 있다면 이 체인의 작은 버전을 언제든지 테스트 할 수 있습니다. 예를 들면 중간 결과를 보기 위해서 prompt 또는 prompt | model 같은 것을 테스트 할 수 있습니다.

input = {"topic": "ice cream"}

# 프롬프트만 실행
prompt.invoke(input)
# > ChatPromptValue(messages=[HumanMessage(content='tell me a short joke about ice cream')])

# 프롬프트와 모델만 실행
(prompt | model).invoke(input)
# > AIMessage(content="Why did the ice cream go to therapy?\nBecause it had too many toppings and couldn't cone-trol itself!")

RAG 검색 예시

다음 예시로 우리는 질문에 대답할 때 어떤 내용을 추가하는 retrieval-augmented generation 체인을 만들기 원합니다.

# Requires:
# pip install langchain docarray tiktoken

from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.prompts import ChatPromptTemplate
from langchain.vectorstores import DocArrayInMemorySearch
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableParallel, RunnablePassthrough

vectorstore = DocArrayInMemorySearch.from_texts(
    ["harrison worked at kensho", "bears like to eat honey"],
    embedding=OpenAIEmbeddings(),
)
retriever = vectorstore.as_retriever()

template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
model = ChatOpenAI()
output_parser = StrOutputParser()

setup_and_retrieval = RunnableParallel(
    {"context": retriever, "question": RunnablePassthrough()}
)
chain = setup_and_retrieval | prompt | model | output_parser

chain.invoke("where did harrison work?")

이 경우에 구성된 체인은 다음과 같습니다.

chain = setup_and_retrieval | prompt | model | output_parser

이 것을 설명하려면 우리는 먼저 프롬프트에서 제공되는 값으로, 콘텍스트와 질문을 받아들이는 프롬프트 템플릿에 대해서 알아볼 수 있습니다. 프롬프트 템플릿을 만들기 전에 우리는 관련된 문서를 가져오고 검색해서 이렇게 가져온 것들을 컨텍스트의 일부로 포함하기를 원합니다.

제일 첫번째 단계로 우리는 메모리 저장소를 이용해서 retriever를 설정할 수 있습니다. 이 retriever는 질문에 기반해서 문서를 가져올 수 있습니다. 이것은 다른 콤포넌트들과 함께 묶여질 수 있을 뿐만 아니라 실행될 수 있는 콤포넌트입니다. 뿐만아니라 여러분 은 retriever 만 분리해서 실행 할 수도 있습니다.

retriever.invoke("where did harrison work?")

그리고나서 우리는 사용자 입력 뿐만 아니라 가져온 문서 전체를 프롬프트의 기대 입력값으로 준비하기 위해서 RunnableParallel을 사용할 수 있습니다. 즉, 문서 검색을 위해 retriever를 사용하고 사용자 질문을 RunnablePassthrough를 사용해서 전달합니다.

setup_and_retrieval = RunnableParallel(
    {"context": retriever, "question": RunnablePassthrough()}
)

다시 정리하면, 완성된 체인은 다음과 같습니다.

setup_and_retrieval = RunnableParallel(
    {"context": retriever, "question": RunnablePassthrough()}
)
chain = setup_and_retrieval | prompt | model | output_parser

흐름은 다음과 같습니다:

첫 번째 단계에서는 두 항목을 포함하는 RunnableParallel 객체를 만듭니다. 첫 번째 항목인 "context"에는 retriever에 의해 가져온 문서 결과가 포함됩니다. 두 번째 항목인 "question"에는 사용자의 원래 질문이 포함됩니다. 질문을 전달하기 위해 RunnablePassthrough를 사용하여 복사합니다.
위 단계에서 생성된 사전을 프롬프트 컴포넌트에 전달합니다. 그런 다음 사용자 입력인 "question" 과 검색된 문서인 "context"를 사용하여 프롬프트를 구성하고 PromptValue를 출력합니다.
모델 컴포넌트는 생성된 프롬프트를 가져와 OpenAI LLM 모델에 전달하여 실행 평가합니다. 모델에서 생성된 출력은 ChatMessage 객체입니다.
마지막으로 output_parser 구성 요소는 ChatMessage를 입력으로 받아서 이를 Python 문자열로 변환하고, invoke 메서드에 반환합니다.

Next steps

동일한 기능을 LCEL로 구현할 때의 코드와 LCEL 없이 구현할 때의, 두 코드를 나란히 놓고 비교하는 내용이 있는 '왜 LCEL을 사용하는지'를 읽어 보시기 바랍니다.

이번 시간을 통해서 LCEL이 무엇인지 알아 보았습니다. 그리고 prompt + model + output_parsert 형태의 기본 예제를 만들고 이해했으며, 마지막에는 RAG 예제를 통해서 관련된 문서를 입력 프롬프트에서 함께 사용하도록 하는 방법에 대해서 알아 보았습니다.

Langserve ERROR: [Errno 99] error while attempting to bind on address ('::1', 8000, 0, 0): cannot assign requested address

The Yellow Lion King — Fri, 12 Jan 2024 13:38:15 +0900

LangServe Error

현상:

LangServe 파일을 실행시 서버가 올라오지 못하고 아래의 에러를 출력하면서 종료되는 현상 발생

ERROR: [Errno 99] error while attempting to bind on address ('::1', 8000, 0, 0): cannot assign requested address

원인:

if __name__ == "__main__":

import uvicorn

uvicorn.run(app, host="localhost", port=8000)

위와 같은 langserve 파일에서 localhost를 OS가 제대로 할당해주지 못해서 발생하는 에러입니다.

조치:

따라서, 위의 코드에서 localhost 문자 대신에 0.0.0.0 으로 바꾸어 주면 잘 동작 합니다.

LangServe Endpoint Test Error: {"detail":"Not Found"}%

The Yellow Lion King — Fri, 12 Jan 2024 13:13:05 +0900

현상:

LangChain을 용해서 간단한 LLM 어플리케이션 챗봇을 만들고 LangServe를 활용해서 Endpoint를 만들었습니다.

그리고 테스트를 위해서 HTTP request call을 테스트 하다가 발생한 로그 입니다.

아래와 같은 curl 명령으로 테스트를 했습니다.

curl --location --request POST 'http://localhost:8000/agent/' \
    --header 'Content-Type: application/json' \
    --data '{
        "input": {
            "input": "안녕"
        }
    }'

request forwarding을 /agent로 langserve 파일에서 설정해 주었기 때문에 'http://~~~ 뒤에 /agent/가 붙었습니다.

그런데 이를 실행 하면 아래와 같이 에러가 발생합니다. 아니 리턴 값이 옴니다.

{"detail":"Not Found"}%

LangServe를 실행시킨 화면에서는 아래와 같이 404 에러가 발생합니다.

원인:

결국에는 Endpoint를 잘 못찾아서 그런 것입니다. 알고보니 langserve의 기본 endpoint는 invoke 입니다. 물론 Runnable 객체로 연결되어있는 경우를 말합니다.

해결 방법:

따라서 아래와 같이, 연결해준 endpoint에 invoke를 추가해서 호출해야 합니다. 그러면 정상적으로 호출되고 체인이 invoke 되어 최종 결과를 잘 리턴 합니다.

(참고: 당연하지만 data에 추가되는 내용은 Runnable에서의 정의와 일치해야합니다.)

$ curl --location --request POST 'http://localhost:8000/agent/invoke' \
>     --header 'Content-Type: application/json' \
>     --data '{
>         "input": {
>             "input": "안녕"
>         }
>     }'
{"output":{"output":"안녕하세요! 저는 Agent 입니다. 무엇을 도와드릴까요?"},"callback_events":[],"metadata":{"run_id":"72ddafgb8-ef17-4b4a-bb79-6f80c3f205ef"}}
$

LangChain Error : ModuleNotFoundError: No module named 'docarray'

The Yellow Lion King — Sun, 7 Jan 2024 20:37:47 +0900

에러 메시지:

from docarray import BaseDoc
ModuleNotFoundError: No module named 'docarray'

pip install docarray를 실행하고

아주 간단하게 from docarray import BaseDoc 을 사용했는데

바로 위와 같으 에러 메시지가 발생했습니다.

아무리 재 설치하고 다른 버전으로 설치해 봐도 안됬습니다.

원인 :

패키지를 설치한 경로를 찾지 못해서 임포트하지 못한 것 같음.

해결 방법 :

먼저 설치된 패키지의 경로가 어떻게 되는지 확인하고

아래와 같은 명령으로 PATH에 해당 패키지가 설치된 경로를 추가해 주었습니다.

경로 확인 방법 :

pip show docarray

패스 추가 방법 :

import sys

sys.path.append("/package/path")

LangChain Error: ImportError: cannot import name 'create_retriever_tool' from 'langchain_community.agent_toolkits'

The Yellow Lion King — Sun, 7 Jan 2024 18:34:53 +0900

에러 발생 코딩 내용 :

from langchain_community.agent_toolkits import create_retriever_tool

에러 내용 :

from langchain_community.agent_toolkits import create_retriever_tool 5 6 tool_description = """

ImportError: cannot import name 'create_retriever_tool' from 'langchain_community.agent_toolkits' (/usr/local/lib/python3.10/dist-packages/langchain_community/agent_toolkits/__init__.py)

원인 :

langchain의 버전이 올라가면서 해당 모듈의 경로가 바뀌었기 때문에 발생. old version에서는 위의 경로(langchain_community.agent_toolkits)가 맞지만

최신버전(0.0.354)에서는 아래의 경로(langchain.tools.retriever)에 모듈이 설치됨

해결 방법 :

따라서 버전에 맞는 모듈 경로를 설정해 주어서 해결할 수 있음.

from langchain.tools.retriever import create_retriever_tool

참고 주소 : https://github.com/langchain-ai/langchain/issues/1023

import errors · Issue #1023 · langchain-ai/langchain

thanks for creating this amazing tool. Just a stupid question from newbie, could anyone help me to fix it? Thanks I run from langchain.agents import load_tools and encounter with ImportError Traceb...

github.com

LangChain-Get started- Security

The Yellow Lion King — Sun, 7 Jan 2024 14:22:12 +0900

목차 LangChain - Get started

Introduction
Installation
Quickstart
Security (이번 포스팅 내용)

동영상 설명은 아래 링크를 참고해 주세요.

https://youtu.be/pSjEz7PD_6s

이전 포스팅까지 잘 따라오셨다면 LangChain에 대해서 이미 많은 것을 이해하고 기본적인 내용을 활용할 수 있게 되었다고 할 수 있겠습니다. 직전 내용인 Quickstart의 내용이 살짝 많은 것 처럼 생각될 수 있는데, 이것은 다양한 형태의 사용을 설명하다 보니 조금 복잡해 진것 같습니다. 하여간 집중해서 보셨다면 이제 LangChain을 이용해서 어느정도 간단한 어플리케이션을 개발/ 구성 을 하실 수 있게 됐을 것 같습니다.

이번 시간에는 보안(Security)에 대해서 다루어 보겠습니다.

보안(Security)

LangChain은 로컬 및 원격 파일 시스템, API 및 데이터베이스와 같은 다양한 외부 리소스와 통합된 대규모 생태계를 보유하고 있습니다. 이러한 통합은 개발자가 LLM의 강력한 기능을 활용하면서 외부 리소스(서비스)에 액세스하고 상호 작용 할 수 있는 다양한 응용 프로그램을 만들 수 있게 합니다.

예를 들면 아이언맨에 나오는 자비스 같은 것을 말합니다. 자비스는 랭체인을 기반으로 구현할 수 있는 언어 모델 어플리케이션의 좋은 예라고 할 수 있겠습니다. (LLM 이) 사용자(토니)의 말을 잘 알아 듣고 대답을 생성하며, 필요하면 (LangChain 이 하는 것 처럼) 외부의 시스템/서비스에 접속해서 필요한 정보를 가져오거나 필요한 동작을 실행 합니다. 이런 어플리케이션의 특징이 있기 때문에 전통적인 보안의 관점에서 좀더 확장된 시각의 접근이 필요한 것 같습니다. 왜냐하면 하나의 서비스 완성을 위해서 여러 기능의 연결점이 많고, 내부와 외부 서비스로 다양하기 때문입니다. 즉, LLM의 특징과 언제 어떻게 사용될 지 모르는 불확실 성에서 오는 잠재적 위험이라고 할 수 있겠습니다.

최적의 방법

이러한 응용 프로그램을 개발할 때 개발자는 다음과 같은 좋은 보안 관행을 따르는 것이 중요합니다.

권한 제한: 응용 프로그램이 필요한 권한을 구체적으로 제한하세요. 넓거나 과도한 권한 부여는 중대한 보안 취약점이 될 수 있습니다. 이러한 취약점을 피하려면 읽기 전용 자격 증명을 사용하거나 민감한 리소스에 대한 액세스를 금지하거나 적절한 샌드박싱 기술(컨테이너 내에서 실행)을 사용하는 것을 고려하십시오. 이처럼 권한을 제한하는 것은 어찌보면 당연한 일이지만 어플리케이션의 구성이 더 복잡해 짐에 따라 더 중요한 포인트입니다.
잠재적인 남용 예측: 인간이 실수할 수 있듯이 대형 언어 모델(LLM)도 실수 할 수 있습니다. 어떤 시스템 액세스 또는 자격 증명이든지 간에 할당된 권한이 허용하는 모든 방식으로 사용될 수 있다고 가정하십시오. 예를 들어 데이터베이스 자격 증명이 데이터 삭제를 허용한다면 해당 자격 증명을 사용할 수 있는 모든 LLM이 실제로 데이터를 삭제할 수 있다고 가정하는 것이 가장 안전합니다.
깊이 있는 방어: 어떤 보안 기술도 완벽하지 않습니다. Fine-tuning 및 좋은 체인 디자인은 대형 언어 모델(LLM)이 실수를 할 확률을 줄일 수 있지만 완전히 제거할 수는 없습니다. 보안을 보장하기 위해 단일 방어 계층에 의존하는 대신 여러 겹의 보안 접근 방식을 결합하는 것이 가장 좋습니다. 예를 들어 읽기 전용 권한과 샌드박싱을 모두 사용하여 LLM이 명시적으로 사용하도록 허용된 데이터에만 액세스할 수 있도록 보장할 수 있습니다.

보안 관행을 따르지 않으면 다음과 같은 리스크가 발생할 수 있습니다(당연하지만 이보다 더할 수 있습니다.):

데이터 손상 또는 손실.
기밀 정보에 대한 무단 액세스.
핵심 리소스의 성능 또는 가용성에 대한 손상.

예시 시나리오 및 완화 전략:

사용자가 파일 시스템에 액세스 권한이 있는 에이전트에게 삭제해서는 안 될 파일을 삭제하거나 민감한 정보가 포함된 파일의 내용을 읽도록 요청할 수 있습니다. 완화를 위해 에이전트를 특정 디렉토리만 사용하도록 제한하고 읽거나 쓸 수 있는 안전한 파일만 허용하도록 합니다. 에이전트를 컨테이너 내에서 실행하여 추가로 샌드박스 처리하는 것도 고려합니다.
사용자가 외부 API에 쓰기 권한이 있는 에이전트에게 악의적인 데이터를 API에 기록하거나 해당 API에서 데이터를 삭제할 수 있습니다. 완화를 위해 에이전트에게 읽기 전용 API 키를 부여하거나 이미 그런 남용에 대한 견딜 수 있는 엔드포인트만 사용하도록 제한할 수 있습니다.
사용자가 데이터베이스에 액세스할 수 있는 에이전트에게 테이블을 삭제하거나 스키마를 변형할 수 있습니다. 완화를 위해 에이전트가 액세스해야 하는 테이블에 권한을 제한하고 읽기 전용 자격 증명을 발급하는 것을 고려합니다.

만약 여러분이 회사에서 외부 리소스에 액세스하는 응용 프로그램을 개발 중이라면 회사의 보안 팀과 상의하여 응용 프로그램을 최적으로 설계하고 보안을 강화하는 방법을 결정하는 것이 좋습니다.

취약점 보고하기

보안 취약점이 있다면 security@langchain.dev 로 이메일을 통해 신고해 주세요. 이렇게 하면 문제가 즉각적으로 처리되고 필요한 대응이 이루어집니다.

기업 솔루션

LangChain은 추가적인 보안 요구사항을 가지고 있는 고객을 위해 기업 솔루션을 제공할 수 있습니다. sales@langchain.dev로 연락주시기 바랍니다.

기타

가장 기본적이면서, 중요하면서, 잊기 쉬운 것이 바로 Key 관리 아닌가 싶습니다. 자체 모델과 서비스를 이용해서 통합하고 어플리케이션을 만들면 Key 관리 Risk가 적겠지만, 쉽고, 빠르고, 높은 품질 의 어플리케이션을 만들려면 외부 서비스와의 통합이 필수적이게 되고 이때 Key와 Credential을 사용하게됩니다. 그래서 위의 예시 시나리오에서도 나왔지만 API 사용시 적절한 Key 관리가 매우 중요합니다. 코드에 Key를 포함하지 않는 것은 기본이고, 용도와 최소한의 권한을 부여한 Key를 사용하고 주기적으로 점검하고 관리하는 것이 중요합니다.

이것으로 LangChain을 사용할 때 보안 관점에서의 필요성과 보안 모범 사례를 알아보았고,

예상 시나리오에 대한 적절한 완화 전략과 기타 보안 관련 내용에 대해서 이야기해 보았습니다.

동영상 설명 : https://youtu.be/pSjEz7PD_6s

LangChain Quickstart(2024년 1월 기준)

The Yellow Lion King — Mon, 1 Jan 2024 14:38:49 +0900

이 포스팅은 2024년 1월 기준으로 새롭게 변경된 LangChain Quickstart에 대한 내용입니다. 이전 버전의 Quickstart 내용보다 상위 수준에서 설명하면서도 동시에 구체적인 예제 코드를 제시하고 있습니다. 예를 들어 이전버전에서는 가장 간단한 prompte + LLM 버전의 체인을 만드는 것에 집중했다면 새로운 Quickstart에서는 LLM Chain, Retrieval Chain, Conversation Retrieval Chain, Agent 등의 내용과 예제를 제공합니다. 다루는 폭이 넓어지고 다양해 졌다고 할 수 있겠네요.

이전 포스팅을 통해서 OpenAI API를 사용하는 방법에 대해서 배웠으며, 랭체인이 무엇인지를 알아보았고, 그리고 랭체인을 설치하는 방법에 대해서 알아보았습니다.

이번 시간에는 랭체인을 이용해서 간단한 어플리케이션을 만들고 서빙을(배포를) 해 보겠습니다. 다시 말하면, (이전의 내용들을 잘 따라오셨다면) 랭체인을 이용해서 간단한 언어 모델 어플리케이션을 만들 수 있다는 의미 입니다. 아주 멋지고 유용한 어플리케이션을 만들기 위해서 먼저, 간단한 어플리케이션을 만들어보는 과정이라고 하겠습니다.

주된 내용은 다음을 참고했고 추가로 설명을 작성하였습니다. https://python.langchain.com/docs/get_started/quickstart

Quickstart | ️ Langchain

In this quickstart we'll show you how to:

python.langchain.com

본 포스팅의 친절한 설명 동영상과 실제 동작하는 코드 내용은 제일 하단에 있는 링크를 참고해 주세요.

이번 포스팅(Quickstart)에서는 다음과 같은 것들을 보실 수 있습니다.

LangChain, LangSmith, LangServe 설정방법
랭체인에서 가장 기본적이고 공통적인 요소의 사용법: prompt templates, models, 그리고 output parser 같은 것들
LCEL(LangChain Expression Language)의 사용법: LCEL은 LangChain이 구축된 프로토콜로, 구성 요소들을 체이닝(묶는 것)을 용이하게 합니다.
랭체인을 이용한 간단한 어플리케이션 개발 방법
랭스미스를 이용한 어플리케이션 추적 방법(이 내용은 많이 없습니다.)
랭서브를 이용한 어플리케이션 서빙(배포) 방법

살짝 많아보이긴 하지만 매우 기본적이고 중요한 내용입니다. 가보실까요!~~~

전체 내용은 이렇습니다. 먼저 환경 및 필요한 내용을 Setup 하고, LangChain을 만들어보고, LangServe로 서빙해 보겠습니다.

Setup

Jupyter Notebook

이 페이지에 있는 다른 자료를 포함해서 이 가이드에서도 Jupyter notebooks(주피터 노트북)을 이용하고 여러분도 그럴 것이라고 가정합니다. 주피터 노트북은 LLM 시스템이 어떻게 동작하는지 배우기에 완벽한 도구입니다. 왜냐하면 기대하지 않던 출력이나 API 다운 과 같이 잘못될 때가 종종 있기 때문입니다. 그래서 이와 같은 상호 작용하는 환경에서 가이드를 진행하는 것이 LLM시스템을 더 잘 이해하는데 좋은 방법입니다.

이 가이드를 반드시 주피터 노트북에서 진행할 필요는 없지만 그렇게 할 것을 추천 드립니다. 노트북을 어떻게 설치하는지 궁금하시면 여기를 참고해주세요.

Installation

이 내용은 랭체인 설치 방법으로 바로 지난 포스팅에서 다룬 내용입니다. 아래의 명령어를 실행합니다.

pip install langchain

conda 환경에서는 아래를 실행합니다.

conda install langchain -c conda-forge

LangSmith

여러분이 만드시는 많은 어플리케이션은 LLM(LargeLanguageModel) 호출을 여러번 실행하는 멀티 스텝을 갖게 될 것입니다. 이러한 어플리케이션이 점점더 복잡해 짐에 따라서 여러분의 체인과 에이전트가 정확하게 무엇을 하고 있는지 조사하는 것 또한 점점 더 중요해 집니다. 이를 위해 가장 좋은 방법이 바로 LangSmith를 이용하는 것 입니다.

LangSmith가 반드시 필요한 것은 아닙니다. 그러나 도움이 됩니다. 바로 위의 링크를 통해 LangSmith에 접속해서 LangSmith Key를 받고, 아래와 같이 설정해서 사용할 수 있습니다. 참고로 LangSmith는 베타버전의 서비스 입니다. 따라서 품질에 대한 보증은 어렵습니다. 그래도 방금 페이지에 접속해보니 사용을 위해서는 대기해야할 정도로 인기가 있네요.

export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="..."

참고로 LangSmith는 베타버전의 서비스 입니다. 따라서 품질에 대한 보증은 어렵습니다. 그래도 방금 페이지에 접속해보니 사용을 위해서는 대기해야할 정도로 인기가 있네요.

Building with LangChain

LangChain은 개발하는 어플리케이션이 데이터의 외부 소스와 LLMs 모델 의 처리를 연결 할 수 있게 합니다. 이 가이드에서 우리는 이와 같은 연결을 하는 몇가지 다른 방법을 진행할 것입니다. 우리는 먼저 간단한 LLM 체인으로 시작할 것인데 이 체인은 프롬프트 템플릿에 있는 정보에 의존해서 반응(회신)합니다. 그 다음에 retrieval chain(회수 체인)을 만들껀데요, 이것은 분리된 데이터 베이스로 부터 데이터를 가져와서 프롬프트 템플릿으로 전달합니다. 우리는 그리고나서 chat history를 추가할 것인데요, 이것은 이전 질문들을 기억하는 것입니다. 마지막으로는 에이전트를 만들 예정입니다. 이 에이전트는 질문에 대답하기 위해서 데이터를 가져와야 하는지 아닌지를 결정하기 위해서 LLM을 이용합니다. 우리는 이와 같은 내용을 상위 수준에서 다룰 예정이지만 사실 많은 상세 내용들이 있습니다. 이런 상세 내용은 링크로 연결/제공하겠습니다.

LLM Chain

공식 문서 가이드에서는 두가지 옵션을 제공 니다. 하나는 OpenAI를 이용하는 것이고 다른 하나는 로컬에 저장된 오픈소스모델을 이용하는 것입니다. 그러나 이 문서에서는 쉬운 사용법 이해를 위해 OpenAI를 이용하도록 하겠습니다. 로컬 모델을 이용하실 분은 공식문서를 참고해주세요.

OpenAI 이용을 위해서는 아래와 같이 파이썬 패키지 설치가 필요합니다.

pip install openai

그리고 API에 접근하기 위해서는 OpenAI API Key가 필요합니다. OpenAI의 API Key를 받기 위해서는 OpenAI 계정이 필요하구요. 없으신 분은 다음의 링크를 따라가서 만드실 수 있습니다.(https://platform.openai.com/account/api-keys)

OpenAI API Key에 대해서 낮설으신 분은 이전 포스팅 내용인 다음의 링크를 통해 먼저 이해하고 진행하시면 좋겠네요.(https://bigdatamaster.tistory.com/203)

키를 발급 받으신 다음에는 아래와 같은 명령어를 이용해서 환경번수에 Key 값을 설정해 주세요.

export OPENAI_API_KEY="..."

그리고나서 다음과 같이 모델을 초기화 할 수 있습니다.

from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI()

만약에 환경변수에 설정하고 싶지 않은 경우에는 OpenAI LLM 클래스를 초기화할 때 openai_api_key라는 파라메터를 통해 직접 전달할 수 있습니다.

from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(openai_api_key="...")

여러분이 선택한 LLM을 설치하고 초기화 했다면, 이제 그 모델을 사용할 수 있습니다. 자, 이제 모델에게 LangSmith가 테스팅할 때 어떤 도움을 줄 수 있는지("how can langsmith help with testing?") 물어 보겠습니다. - 참, 이런 질문은 모델 훈련 데이터에 없었기 때문에 좋은 대답을 받기는 어려울 껍니다.

llm.invoke("how can langsmith help with testing?")

우리는 또한 프롬프트 템플릿을 가지고 이것의 응답을 가이드 할 수 있습니다. 프롬프트 템플릿은 사용자 입력 내용을 LLM에게 더 좋은 입력으로 변환 하는데 사용됩니다.

from langchain.prompts import ChatPromptTemplate
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are world class technical documentation writer."),
    ("user", "{input}")
])

자, 이제 우리는 이렇게 만든 것들을 간단한 LLM 체인으로 묶을 수 있습니다.

chain = prompt | llm

이렇게 프롬프트와 LLM 모델을 하나의 체인으로 묶을 수 있습니다. 이제 우리는 이렇게 만든 체인을 invoke 시키고 동일한 질문을 할 수 있습니다. 아마 체인은 아직도 정확한 답변을 모를 껍니다. 하지만 마치 기술문서 작성자와 같은 더 적절한 톤으로 답변할 껍니다.

ChatModel의(즉, 이 체인의) 출력은 메시지 입니다. 그럼에도, 문자열을 가지고 작업하는게 훨씬 편할 때가 종종 있습니다. 그러니 chat message를 문자열로 바꾸어주는 간단한 output parser를 만들어 보시죠.

from langchain_core.output_parsers import StrOutputParser

output_parser = StrOutputParser()

이렇게 만든 output parser를 이전에 만든 체인에 추가할 수 있습니다.

chain = prompt | llm | output_parser

자, 이제 다시 invoke 시키고 동일한 질문을 할 수 있습니다. 이 질문에 대한 답변은 ChatMessage가 아니라 하나의 문자열일 껍니다.

chain.invoke({"input": "how can langsmith help with testing?"})

Diving Deeper

우리는 지금까지 기본 LLM 체인을 성공적으로 설정했습니다. 우리는 기본적인 프로프트와 모델, 그리고 아웃풋 파서(output parser) 만을 다루었습니다. 더 깊이 있는 것들이 궁금하신 분들은 여기 문서를 참고해 주세요.

Retrieval Chain

앞선 질문("how can langsmith help with testing?")에 적절한 답변을 만들기 위해서 우리는 LLM에거 추가 context를 제공할 필요가 있습니다. 우리는 이것을 retrieval로 할 수 있습니다. Retrieval이란 데이터가 너무 많아서 LLM에게 직접적으로 전달하지 못할 때 유용합니다. 그래서 여러분은 가장 관련된 데이터 조각을 가져오고 모델에 전달하기 위해서 retriever를 사용할 수 있습니다.

이 처리에서 우리는 Retriever로 부터 관련된 문서를 찾아보고 프롬프트에 전달 할 껍니다. Retriever는 SQL 테이블이나 인터넷 등과 같은 것을 지원 받을 수 있습니다. 그러나 이번에는 벡터 스토어(Vector Store)를 만들고 retriever로 이용 할 껍니다. vectorstore에 대한 정보는 여기를 참고해 주세요.

먼저 인덱스가 필요한 데이터를 프로그램(메모리)에 로드할(가져올) 필요가 있습니다.

from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://docs.smith.langchain.com/overview")

docs = loader.load()

그다음, vectorstore에 데이터를 인덱스하는 것이 필요합니다. 이것은 몇개의 콤포넌트를 필요로 하는데 가장 유명한 것이 embedding model과 vectorstore입니다.

embedding models을 위해서 OpenAI와 로컬 모델을 통해서 사용하는 예시를 제공합니다. (이것도 로컬 모델을 이용하는 방법은 공식 문서를 참고해주세요)

OpenAI

LLM에서 필요로 하는 것과 같이 Openai 패키지가 잘 설치되어 있고 적절한 환경 변수가 설정되어 있는 것이 필요합니다.

from langchain_community.embeddings import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()

이제 이 embedding model을 가지고 vectorstore에 문서들을 주입해 넣을 수 있습니다. 우리는 단순화를 목적으로 간단한 로컬 vectorstore인 DocArray InMemorySearch를 사용 할 예정입니다.

먼저 필요한 패키지 설치가 필요합니다.

pip install docarray

그리고나서 인텍스를 만들 수 있습니다.

from langchain_community.vectorstores import DocArrayInMemorySearch
from langchain.text_splitter import RecursiveCharacterTextSplitter


text_splitter = RecursiveCharacterTextSplitter()
documents = text_splitter.split_documents(docs)
vector = DocArrayInMemorySearch.from_documents(documents, embeddings)

이렇게 함으로써 우리는 vectorstore안에 인덱스된 데이터를 만들었습니다. 이제 retrieval chain을 만들어 보시죠. 이 체인은 들어오는 질문을 받아서, 관련된 문서들을 찾고, 그리고나서 최초 입력된 질문과 함께 이 문서들을 LLM에 전달하고, 원초 질문의 답을 LLM에게 물어볼 껍니다.

먼저 원초 질문과 회수된 문서, 그리고 답변을 생성하는 체인을 설정합니다.

from langchain.chains.combine_documents import create_stuff_documents_chain

prompt = ChatPromptTemplate.from_template("""Answer the following question based only on the provided context:

<context>
{context}
</context>

Question: {input}""")

document_chain = create_stuff_documents_chain(llm, prompt)

우리가 원한다면 문서를 직접 전달해서 이 것을 실행할 수도 있습니다.

from langchain_core.documents import Document

document_chain.invoke({
    "input": "how can langsmith help with testing?",
    "context": [Document(page_content="langsmith can let you visualize test results")]
})

그럼에도 불구하고, 우리는 우리가 설정한 것처럼 retriever로 부터 먼저온 문서들을 원합니다. 그러기 위해서 주어진 질문에 대하여 retriever를 이용해서 동적으로 가장 관련 높은 문서를 선택해서 가져오고 전달 할 수 있습니다.

from langchain.chains import create_retrieval_chain

retriever = vector.as_retriever()
retrieval_chain = create_retrieval_chain(retriever, document_chain)

우리는 이제 이 체인을 invoke 할 수 있습니다. 이 체인은 LLM으로 부터 받은 응답 을 dictionary로 반환하는데 answer key를 이용해서 그 내용을 확인 할 수 있습니다.

response = retrieval_chain.invoke({"input": "how can langsmith help with testing?"})
print(response["answer"])

// LangSmith offers several features that can help with testing:...

이렇게 나온 답변은 훨씬 더 정확할 껍니다.

Diving Deeper

지금까지 기본적인 retrieval chain을 성공적으로 만들어 보았습니다. 기본적인 retrieval 만 다루었기 때문에 더 깊이있는 내용을 원하시면 여기를 참고하세요.

Conversation Retrieval Chain

지금까지 만들어본 체인은 하나의 질문에 답변하기 위한 것이었습니다. 사람들이 만드는 LLM어플리케이션의 주요 유형중 하나는 챗봇입니다. 그래서 어떻게 하면 하나의 체인을 이어지는 질문에 대답할 수 있게 만들 수 있을까요?

우리는 계속해서 create_retrieval_chain 함수를 이용할 것 입니다. 다만 두가지 변경이 필요합니다.

1. retrieval method는 가장 최근의 입력에 동작하지 말고 계정의 전체 기록을 받아서 동작해야 합니다.

2.최종 LLM 체인은 계정의 전체 기록과 같은 형태여야 합니다.

Updating Retrieval

retrieval을 업데이트하기 위해서 우리는 새로운 체인을 만들 겠습니다. 이 체인은 최근의 입력(input)과 대화 기록(chat_history)을 받고 검색 질문을 만들기 위해 LLM을 사용하도록 만들겠습니다.

from langchain.chains import create_history_aware_retriever
from langchain_core.prompts import MessagesPlaceholder

# First we need a prompt that we can pass into an LLM to generate this search query

prompt = ChatPromptTemplate.from_messages([
    MessagesPlaceholder(variable_name="chat_history"),
    ("user", "{input}"),
    ("user", "Given the above conversation, generate a search query to look up in order to get information relevant to the conversation")
])
retriever_chain = create_history_aware_retriever(llm, retriever, prompt)

사용자가 이어지는 질문을 물어보는 것과 같은 인스턴스를 전달해서 이 체인을 테스트해 볼 수 있습니다.

from langchain_core.messages import HumanMessage, AIMessage

chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
retrieval_chain.invoke({
    "chat_history": chat_history,
    "input": "Tell me how"
})

당신은 이 체인이 LangSmith를 가지고 테스팅하는 것에 대한 문서들을 반환하는지 확인해야 합니다. 왜냐하면 이것은 LLM이 chat history와 이어지는 질문을 연결하는 새로운 질문을 생성하기 때문입니다.

이로써 우리는 새로운 retriever를 만들었습니다. 이제 생각했던 것과 같이 회수된 문서(retrieved documents)를 가지고 대화를 계속하는 새로운 체인을 만들 수 있습니다.

prompt = ChatPromptTemplate.from_messages([
    ("system", "Answer the user's questions based on the below context:\n\n{context}"),
    MessagesPlaceholder(variable_name="chat_history"),
    ("user", "{input}"),
])
document_chain = create_stuff_documents_chain(llm, prompt)

retrieval_chain = create_retrieval_chain(retriever_chain, document_chain)

이제 처음부터 끝까지 테스트할 수 잇습니다.

chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
retrieval_chain.invoke({
    "chat_history": chat_history,
    "input": "Tell me how"
})

우리는 이것이 연관된 대답을 준다는 것을 볼 수 있습니다. 이로써 우리는 우리의 retreival chain을 챗봇으로 성공적으로 변경 시켰습니다.

Agent

우리는 지금까지 각 단계가 미리알려진 그런 chain들의 예제를 만들어 보았습니다. 이제 마지막으로 LLM이 어떤 단계를 취해야하는지 판단하는 에이전트를 만들겠습니다.

에이전트를 만들때 해야할 것 중 가장 먼저인 것은 어떤 툴에 접속할 수 있게 할 것인지를 정하는 것입니다. 예들어면, 에이전트에게 다음과 같은 두개의 툴에 접속할 수 있도록 할 수 있습니다.

1. 방금 만들었던 retriever. 이것은 LangSmith에 대한 질문에 쉽게 답할 수 있게 합니다.

2. 검색 툴. 이것은 최신 정보가 필요한 질문에 쉽게 대답 할 수 있게 합니다.

먼저 우리가 만든 retriever를 툴로 설정해 보겠습니다.

from langchain.tools.retriever import create_retriever_tool

retriever_tool = create_retriever_tool(
    retriever,
    "langsmith_search",
    "Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",
)

검색 툴은 Tavily를 이용하겠습니다. 이 것은 별도의 API가 필요합니다.(무료 등급으로도 제공하네요) API Key를 생성한 뒤에는 환경변수에 설정이 필요합니다.

export TAVILY_API_KEY=...

API Key를 설정하고 싶지 않다면 이툴을 생성하는 것을 스킵할 수 있습니다.

from langchain_community.tools.tavily_search import TavilySearchResults

search = TavilySearchResults()

이제 우리가 동작하기 원하는 툴들의 리스트를 생성할 수 있습니다.

tools = [retriever_tool, search]

이로써 우리 tools를 만들었으니 이제 이 것들을 이용 할 에이전트를 만들 수 있습니다. 좀 빠르게 이부분을 넘어가겠습니다. 더 자세한 내용은 여기를 참고해주세요.

from langchain.chat_models import ChatOpenAI
from langchain import hub
from langchain.agents import create_openai_functions_agent
from langchain.agents import AgentExecutor

# Get the prompt to use - you can modify this!
prompt = hub.pull("hwchase17/openai-functions-agent")
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

이제 에이전트를 불러서 어떻게 답변하는지 보겠습니다. 아래와 같이 LangSmith에 대한 질문을 할 수 있습니다.

agent_executor.invoke({"input": "how can langsmith help with testing?"})

날씨에 대해서도 물어볼 수 있습니다.

agent_executor.invoke({"input": "what is the weather in SF?"})

이런 것에 대한 대화를 할 수도 있습니다.

chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
agent_executor.invoke({
    "chat_history": chat_history,
    "input": "Tell me how"
})

Diving Deeper

이로써 기본 에이전트를 만들어 보았습니다. 여기서는 에이전트에 대한 기본적인 내용만 다루었습니다. 더 자세한 내용은 여기를 참고해주세요.

Serving with LangServe

지금까지 하나의 어플리케이션을 만들었습니다. 이제 저장하고 서빙이 필요합니다. 바로 이때 LangServe가 필요합니다. LangServe는 LangChain chain들을 REST API로 배포할 수 있도록 도와줍니다. LangChain을 사용하기 위해서 LangServe를 사용할 필요는 없지만 이 가이드에서는 LangServe를 가지고 어떻게 여러분의 앱을 배포할 수 있는지 보여드리겠습니다.

이 가이드의 초반에 주피터 노트북에서 실행을 가정했기 때문에 이제 우리는 노트북에서 나와야 합니다. 우리는 파이썬 파일을 하나 만들고 이것을 명령 라인에서 동작할 수 있도록 하겠습니다.

먼저 langserve를 설치 합니다.

pip install "langserve[all]"

Server

우리가 만든 어플리케이션을 위한 서버를 만들기 위해서 serve.py라는 파일을 만들겠습니다. 이 파일은 어플리케이션을 서빙하기위한 로직을 담게 될 것입니다. 이것은 3가지로 구성됩니다.

1. 위에서 우리가 만든 체인의 정의

2. 우리의 FastAPI 앱

3. 어디에서 어느 체인으로 서비스될 것인지에 대한 경로 정의(langserve.app_routes에 의해 정의됩니다.)

#!/usr/bin/env python
from typing import List

from fastapi import FastAPI
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain_community.document_loaders import WebBaseLoader
from langchain_community.embeddings import OpenAIEmbeddings
from langchain_community.vectorstores import DocArrayInMemorySearch
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.tools.retriever import create_retriever_tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.chat_models import ChatOpenAI
from langchain import hub
from langchain.agents import create_openai_functions_agent
from langchain.agents import AgentExecutor
from langchain.pydantic_v1 import BaseModel, Field
from langchain_core.messages import BaseMessage
from langserve import add_routes

# 1. Load Retriever
loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
docs = loader.load()
text_splitter = RecursiveCharacterTextSplitter()
documents = text_splitter.split_documents(docs)
embeddings = OpenAIEmbeddings()
vector = DocArrayInMemorySearch.from_documents(documents, embeddings)
retriever = vector.as_retriever()

# 2. Create Tools
retriever_tool = create_retriever_tool(
    retriever,
    "langsmith_search",
    "Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",
)
search = TavilySearchResults()
tools = [retriever_tool, search]


# 3. Create Agent
prompt = hub.pull("hwchase17/openai-functions-agent")
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)


# 4. App definition
app = FastAPI(
  title="LangChain Server",
  version="1.0",
  description="A simple API server using LangChain's Runnable interfaces",
)

# 5. Adding chain route

# We need to add these input/output schemas because the current AgentExecutor
# is lacking in schemas.

class Input(BaseModel):
    input: str
    chat_history: List[BaseMessage] = Field(
        ...,
        extra={"widget": {"type": "chat", "input": "location"}},
    )


class Output(BaseModel):
    output: str

add_routes(
    app,
    agent_executor.with_types(input_type=Input, output_type=Output),
    path="/agent",
)

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="localhost", port=8000)

이게 전부 입니다. 이제 이 파일을 실행 시킵니다.

python serve.py

localhost:8000 에서 서빙되고 있는 우리의 체인을 볼 수 있습니다.

Playground

모든 LangServe서비스는 중간 단계를 시각화하 스트리밍 아웃풋이 있는 어플리케이션을 조작하고 부기 위해서 간단한 빌트인 UI를 제공합니다. http://localhost:8000/agent/playground/ 이 주소를 통해 확인해 보세요. 이전 질문인 "how can langsmith help with testing?"을 전달해 보세요! 그리고 이전과 같은 답변을 보이는지 확인해보세요.

Client

자, 이제 우리의 서버와 자동으로 상호 작용하는 클라이언트를 만들어 보겠습니다. 우리는 [langserve.RemoteRunnable](/docs/langserve#client) 이것을 가지고 쉽게 만들 수 있습니다. 이것을 사용함으로써 서빙되는 체인을 마치 클라이언트에서 동작하는 것처럼 상호 작용 할 수 있습니다.

from langserve import RemoteRunnable

remote_chain = RemoteRunnable("http://localhost:8000/agent/")
remote_chain.invoke({"input": "how can langsmith help with testing?"})

자세한 내용은 여기를 참고해주세요.

Next steps

우리는 LangChain을 활용한 어플리케이션을 어떻게 만들고 LangSmith로 어떻게 그것을 다루 며, 그리고 LangServe를 가지고 어떻게 서빙하는지 알아보았습니다. 여기서 다룬 것보다 이 세 가지 모두에는 훨씬 더 많은 기능이 있습니다. 계속해서 학습하려면 다음의 내용을 참고하기를 추천 합니다.:

이런 콤포넌트들을 함께 묶는 방법 같은, 모든 이런 기능들은 LangChain Expression Language (LCEL)을에 의해서 지원됩니다. 사용자에게 맞는 체인을 개발하기위해 더 잘 이해하기 위해서 이 문서들을 참고하세요.
Model IO는 prompts, LLMS, 그리고 output parsers에 대해서 더 자세한 것들을 다룹니다.
Retrieval은 회수(retrieval)와 관련된 모든 자세한 것들을 다룹니다.
Agents는 agent과 관련된 모든 자세한 것들을 다룹니다.
공통적인 end-to-end 사용 사례 및 템플릿 애플리케이션을 탐색하세요.
디버깅, 테스트, 모니터링 등을 위한 플랫폼인 LangSmith에 대해 읽어보세요.
LangServe를 사용하여 애플리케이션을 서비스하는 방법에 대해 더 자세히 알아보세요.

langchain_quickstart.ipynb

Colaboratory notebook

colab.research.google.com

LangChain Quickstart(랭체인 기본 예시)

The Yellow Lion King — Fri, 29 Dec 2023 21:54:37 +0900

이번 시간에는 랭체인을 이용해서 간단한 어플리케이션을 만들고 모니터링하고 서빙을(배포를) 해 보겠습니다. 다시 말하면, (이전의 내용들을 잘 따라오셨다면) 랭체인을 이용해서 간단한 언어 모델 어플리케이션을 만들 수 있다는 의미 입니다. 아주 멋지고 유용한 어플리케이션을 만들기 위해 먼저 간단한 어플리케이션을 만들어보는 과정이라고 하겠습니다.

주요 내용은 다음을 참고했고 하나씩 번역하면서 추가로 필요한 설명을 작성하였습니다. https://python.langchain.com/docs/get_started/quickstart (2024년 1월 부터 Quickstart 페이지의 내용이 업그레이드 되었습니다. 따라서 아래의 내용과 일부 다릅니다.)

이번 포스팅(Quickstart)에서는 다음과 같은 것들을 보실 수 있습니다.

LangChain, LangSmith, LangServe 설정방법
랭체인에서 가장 기본적이고 공통적인 요소의 사용법: prompt templates, models, 그리고 output parser 같은 것들
LCEL(LangChain Expression Language)의 사용법: LCEL은 LangChain이 구축된 프로토콜로, 구성 요소들을 체이닝(묶는 것)을 용이하게 합니다.
랭체인을 이용한 간단한 어플리케이션 개발 방법
랭스미스를 이용한 어플리케이션 추적 방법
랭서브를 이용한 어플리케이션 서빙(배포) 방법

살짝 많아보이긴 하지만 매우 기본적이고 중요한 내용입니다. 가보실까요!~~~

전체 내용은 이렇습니다. 먼저 환경 및 필요한 내용을 Setup 하고, LangChain을 만들어보고, LangSmith로 추적해보고, LangServe로 서빙해 보겠습니다.

Setup

Installation

이 내용은 랭체인 설치 방법으로 바로 지난 포스팅에서 다룬 내용입니다. 아래의 명령어를 실행합니다.

pip install langchain

conda 환경에서는 아래를 실행합니다.

conda install langchain -c conda-forge

Environment

랭체인을 사용한다면 보통 하나 이상의 모델 제공자나 데이터 저장소, 또는 APIs와의 통합이 필요합니다. 이번 예제에서는 OpenAI의 모델 API를 이용하려 합니다. 따라서 OpenAI 패키지 사용을 위해서 다음과 같은 OpenAI 패키지 설치 명령어를 실행 시켜 줍니다.

pip install openai

OpenAI API Key에 대해서 낮설으신 분은 이전 포스팅 내용인 다음의 링크를 통해 먼저 이해하고 진행하시면 좋겠네요.(https://bigdatamaster.tistory.com/203)

키를 발급 받으신 다음에는 아래와 같은 명령어를 이용해서 환경번수에 Key 값을 설정해 주세요.

export OPENAI_API_KEY="..."

이처럼 환경변수에 설정하고 싶지 않다면, 아래와 같이 프로그램에서 openai_api_key의 파라메터에 key 값을 전달할 수도 있습니다.

from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(openai_api_key="...")

LangSmith

export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="..."

LangServe

LangServe는 LangChain의 chain들을 REST API로 배포하는 것을 도와 줍니다. LangChain을 사용하기 위해서 LangServe를 사용할 필요는 없습니다. 그렇치만 이번 내용에서는 간단하게 LangServe를 이용해서 앱을 어떻게 배포하는지 보여드리겠습니다. 설치는 아래 명령어를 실행하세요.

pip install "langserve[all]"

Building with LangChain

LangChain은 언어 모델 어플리케이션을 만들기 위해 사용될 수 있는 많은 모듈들을 제공합니다. 이러한 모듈들은 간단한 어플리케이션을 위해서 홀로 사용될 수도 있고. 복잡한 use case에서 사용을 위해 여러 모듈과 함께 구성되어 사용될 수 있습니다. 이런 구성은 LangChain Expression Language(LCEL)에 의해 제공되는데 이것은 많은 모듈에서 일관되게 구현되어 있는 Runnable 인터페이스를 통해 정의 됩니다. 이를 통해서 component들을 끈김 없이 연결 하는 것이 가능합니다.

가장 단순하고 공통적인 체인은 다음의 3가지를 포함합니다.

LLM/Chat Mode: 언어 모델은 추론 엔진의 핵심입니다. 랭체인과 함께 사용하기위해서 여러분은 언어모델의 다른 종류들에 대해 이해하고 어떻게 사용하는지를 이해하는 것이 필요합니다.
Prompt Template: 이것은 언어 모델에 지시를 제공합니다. 이것은 언어 모델 아웃풋을 제어 합니다. 따라서, 프롬프트를 어떻게 생성하고 프롬프트 전략의 차이점을 이해하는 것은 매우 중요합니다.
Output Parser: 이것은 언어모델로부터의 답변내용을 좀더 작업할 수 있는 포맷으로 변환합니다. 이것은 이후 처리에서 아웃풋을 쉽게 사용할 수 있도록 합니다.

이번 내용에서는 이 3가지에 대해서 각각 어떻게 사용하는지 설명하고, 그리고 나서 통합적으로 어떻게 연결하여 사용하는지를 설명할 예정입니다. 이러한 컨셉을 이해하는 것은 여러분이 나중에 LangChain 어플리케이션을 커스터마이즈하거나 사용하는데에 도움이 됩니다. 대부분의 LangChain 애플리케이션에서는 모델 그리고/또는 프롬프트를 구성할 수 있는 기능이 제공되므로, 이를 어떻게 활용하는지 아는 것은 큰 도움이 될 것입니다.

LLM/Chat Model

언어 모델에는 다음과 같이 2종류가 있습니다.

LLM: 기본 모델은 문자열을 입력으로 받고 문자열을 반환합니다.
ChatModel: 기본 모델은 메시지의 리스트를 입력으로 받고 하나의 메시지를 반환합니다.

문자열은 단순합니다. 그러나 메시지는 무엇일까요? 기본 메시지 인터페이스는 BaseMessage에 정의 되어 있는데 다음의 2개 특성이 필요합니다.

content: 메시지의 내용으로 일반적으로 문자열 입니다.
role: BaseMessage가 만들어 내는 엔티티 입니다.

LangChain은 서로 다른 role들을 쉽게 구분하기 위해서 다음과 같이 몇 개의 오브젝트를 제공합니다.

HumanMessage: 사람/사용자로 부터 오는 BaseMessage
AIMessage: AI/assistant로 부터 오는 BaseMessage
SystemMessage: 시스템으로부터오는 BaseMessage
FunctionMessage / Tool Message: 함수나 도구의 호출의 결과를 포함하는 BaseMessage

만약이러한 role들이 맞지 않는 다면, ChatMessage 클래스를 이용해서 역할을 수작업으로 만들 수 있습니다.

LangChain은 LLM과 ChatModel 모두에게 공유되는 공통 인터페이스를 제공합니다. 그럼에도 불구하고 주어진 언어 모델에 맞는 효과적인 프롬프트를 만들기 위해서 이러한 차이점을 이해하는 것은 매우 도움이 됩니다.

LLM 또는 ChatModel을 호출하는 가장 간단한 방법은 .invoke()를 사용하는 것 입니다. 이것은 모든 LCEL 오브젝트를 위한 통일된 동기 호출 방법입니다.

LLM.invoke: 문자열을 입력받고, 문자열을 반환합니다.
ChatModel.invoke: BaseMessage의 리스트를 입력받고, BaseMessage를 반환 합니다.

이러한 메소드의 입력 유형은 사실 이보다 더 일반적입니다. 그러나 여기서는 간단히 LLM은 문자열만을, Chat 모델은 메시지 리스트를 입력으로 받는 것으로 가정할 수 있습니다. 모델 호출에 대한 자세한 내용은 여기를 확인하세요.

이제 이러한 다른 유형의 모델과 다양한 입력 유형을 다루는 방법을 살펴보겠습니다. 먼저 LLM과 ChatModel을 가져와보겠습니다.

from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI

llm = OpenAI()
chat_model = ChatOpenAI()

LLM과 ChatModel 객체는 효과적으로 구성된 객체입니다. 여러분은 temperature나 다른 파라메터들을 함께 전달함으로서 초기화 할 수 있습니다.

from langchain.schema import HumanMessage

text = "What would be a good company name for a company that makes colorful socks?"
messages = [HumanMessage(content=text)]

llm.invoke(text)
# >> Feetful of Fun

chat_model.invoke(messages)
# >> AIMessage(content="Socks O'Color")

Prompt templates

대부분의 LLM 애플리케이션에서는 사용자 입력을 직접 LLM으로 전달하지 않습니다. 일반적으로 사용자 입력을 프롬프트 템플릿이라고 불리는 더 큰 텍스트 조각에 추가하게 되며, 이는 특정 작업에 대한 추가적인 맥락을 제공합니다.

이전 예에서 모델에 전달한 텍스트에는 회사 이름을 생성하기 위한 지침이 포함되어 있었습니다. (text변수에 할당한 What would be....를 말합니다.) 그러니 우리의 애플리케이션이 제품을 제시하면 적절한 회사명을 답변하는 어플리케이션이라고 한다면, 사용자가 모델에 다른 지침을 주지 않고 제품에 대한 설명만 제공하면 될 것입니다.

이를 구현할 때 PromptTemplates이 도움이 됩니다! 이들은 사용자 입력을 서식이 있는 프롬프트로 전환하는 모든 로직을 묶어냅니다. 이는 매우 간단하게 시작할 수 있는데요 예를 들어, 위에서 말한 것처럼 제품을 입력 받아서 전체 문자열을 생성하는 프롬프트는 단순히 다음과 같을 수 있습니다.

from langchain.prompts import PromptTemplate

prompt = PromptTemplate.from_template("What is a good name for a company that makes {product}?")
prompt.format(product="colorful socks")

What is a good name for a company that makes colorful socks?

어떠신가요?! 지침 전체를 바꿀 필요가 없기 때문에 변경이 필요한 부분만 선택적으로 변경해서 문자열을 만들어 낼 수 있습니다.

템플릿을 사용하는 이점은 여러 가지입니다. 변수를 "부분적"으로 처리할 수 있습니다. 즉, 한 번에 일부 변수만 서식을 지정할 수도 있습니다. 이러한 것 들을 쉽게 결합하여 다양한 템플릿을 하나의 프롬프트로 조합할 수도 있습니다. 이러한 기능에 대한 자세한 설명은 프롬프트 섹션을 참조하세요.

PromptTemplates은 또한 메시지 리스트(목록)을 생성하는 데 사용할 수 있습니다. 이 경우 프롬프트에는 컨텐츠 정보뿐만 아니라 각 메시지에 대한 정보(역할, 목록에서의 위치 등)가 포함됩니다. 이러한 가장 일반적인 경우에는 ChatPromptTemplate가 있고, 이것은 ChatMessageTemplate의 목록을 말합니다. 각 ChatMessageTemplate은 해당 ChatMessage를 어떤 서식으로 지정할지에 대한 지침과 함께 역할(role) 및 컨텐츠(content)를 포함합니다. 아래에서 이를 자세히 살펴보겠습니다.

from langchain.prompts.chat import ChatPromptTemplate

template = "You are a helpful assistant that translates {input_language} to {output_language}."
human_template = "{text}"

chat_prompt = ChatPromptTemplate.from_messages([
    ("system", template),
    ("human", human_template),
])

chat_prompt.format_messages(input_language="English", output_language="French", text="I love programming.")

[
    SystemMessage(content="You are a helpful assistant that translates English to French.", additional_kwargs={}),
    HumanMessage(content="I love programming.")
]

ChatPrompttemplates는 또한 다른 방법으로 생성될 수 있습니다. 프롬프트 섹션을 참고하세요.

Output parsers

OutputParsers는 언어 모델의 원시 출력을 이후의 처리에서 사용할 수 있는 형식으로 변환합니다. OutputParsers의 주요 유형 몇 가지가 있으며, 이에는 다음이 포함됩니다:

LLM의 텍스트를 구조화된 정보로 변환 (예: JSON)
ChatMessage를 하나의 단순 문자열로 변환
메시지 이외에 호출에서 반환된 추가 정보 (예: OpenAI 함수 호출)를 문자열로 변환

자세한 내용은 output parsers 섹션을 참조하세요.

이 시작 가이드(포스팅)에서는 우리만의 출력 파서를 작성할 것입니다. 즉, 쉼표로 구분된 목록을 그냥 목록으로 변환하는 출력 파서입니다.

from langchain.schema import BaseOutputParser

class CommaSeparatedListOutputParser(BaseOutputParser):
    """Parse the output of an LLM call to a comma-separated list."""


    def parse(self, text: str):
        """Parse the output of an LLM call."""
        return text.strip().split(", ")

CommaSeparatedListOutputParser().parse("hi, bye")
# >> ['hi', 'bye']

지금까지는 LLM/Chat Model, Prompt templates, Output parsers 별로 알아 보았으며 이번에는 통합해서 구성하는 방법을 알아 보겠습니다.

Composing with LCEL

이제 이들을 하나의 체인으로 결합할 수 있습니다. 이 체인은 입력 변수를 가져와서 프롬프트 템플릿에 전달하여 프롬프트를 생성하고, 이 프롬프트를 언어 모델에 전달한 다음 출력을 (선택적으로) Output parsers에 전달합니다. 이는 모듈화된 논리를 간편하게 묶어내는 방법입니다. 이것이 실제로 동작하는 것을 확인해 보시죠.

from typing import List

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import BaseOutputParser

class CommaSeparatedListOutputParser(BaseOutputParser[List[str]]):
    """Parse the output of an LLM call to a comma-separated list."""


    def parse(self, text: str) -> List[str]:
        """Parse the output of an LLM call."""
        return text.strip().split(", ")

template = """You are a helpful assistant who generates comma separated lists.
A user will pass in a category, and you should generate 5 objects in that category in a comma separated list.
ONLY return a comma separated list, and nothing more."""
human_template = "{text}"

chat_prompt = ChatPromptTemplate.from_messages([
    ("system", template),
    ("human", human_template),
])
chain = chat_prompt | ChatOpenAI() | CommaSeparatedListOutputParser()
chain.invoke({"text": "colors"})
# >> ['red', 'blue', 'green', 'yellow', 'orange']

이러한 구성 요소를 결합하기 위해 | 구문(기호, 문법)을 사용하고 있습니다. 이 | 구문은 LangChain Expression Language (LCEL)에서 파생되며, 이 모든 객체가 구현하는 범용 Runnable 인터페이스에 의존합니다. LCEL에 대해 더 알아보려면 여기서 문서를 읽어보세요.

Tracing with LangSmith

만약 우리가 처음에 보여준 대로 환경 변수를 설정했다면, 우리가 지금까지 한 모든 모델 및 체인 호출은 자동으로 LangSmith에 로그될 것입니다. (즉, LangSmith에 계정도 만들고 Key를 등록했다면 말이지요.) 그런 다음 LangSmith를 사용하여 애플리케이션 추적을 디버그하고 주석을 달고, 이를 향후 애플리케이션 반복 평가를 위한 데이터 세트로 변환할 수 있습니다.

위 체인에 대한 추적이 어떻게 보일지는 다음을 통해 확인하세요: https://smith.langchain.com/public/09370280-4330-4eb4-a7e8-c91817f6aa13/r

LangSmith에 대한 자세한 내용은 여기를 참조하세요.

Serving with LangServe

이제 애플리케이션을 구축했으므로 서비스를 해야 합니다. 이때 LangServe가 등장합니다. LangServe는 개발자가 LCEL 체인을 REST API로 배포하는 데 도움을 주는 도구입니다. 이 라이브러리는 FastAPI와 특히 데이터 유효성 검사를 위해 pydantic과 통합되어 있습니다.

Server

우리의 애플리케이션을 위한 서버를 만들기 위해 serve.py 파일을 만들 것입니다. 이 파일에는 세 가지가 들어갑니다.

체인의 정의 (위와 동일)
FastAPI 앱
체인을 서비스하는 데 사용할 경로의 정의, 이는 langserve.add_routes를 사용하여 설정됩니다.

#!/usr/bin/env python
from typing import List

from fastapi import FastAPI
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.schema import BaseOutputParser
from langserve import add_routes

# 1. Chain definition

class CommaSeparatedListOutputParser(BaseOutputParser[List[str]]):
    """Parse the output of an LLM call to a comma-separated list."""


    def parse(self, text: str) -> List[str]:
        """Parse the output of an LLM call."""
        return text.strip().split(", ")

template = """You are a helpful assistant who generates comma separated lists.
A user will pass in a category, and you should generate 5 objects in that category in a comma separated list.
ONLY return a comma separated list, and nothing more."""
human_template = "{text}"

chat_prompt = ChatPromptTemplate.from_messages([
    ("system", template),
    ("human", human_template),
])
category_chain = chat_prompt | ChatOpenAI() | CommaSeparatedListOutputParser()

# 2. App definition
app = FastAPI(
  title="LangChain Server",
  version="1.0",
  description="A simple API server using LangChain's Runnable interfaces",
)

# 3. Adding chain route
add_routes(
    app,
    category_chain,
    path="/category_chain",
)

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="localhost", port=8000)

위 내용을 serve.py로 저장합니다.

이게 끝입니다. 우리가 이 파일을 다음과 같이 실행 시키면 됩니다.

python serve.py

이렇게 하고나면 우리는 localhost:8000에서 서빙되는 우리의 체인을 볼 수 있습니다.

Playground

모든 LangServe 서비스에는 응용 프로그램을 구성하고 호출하는 간단한 내장 UI가 포함되어 있습니다. 이 UI를 통해 스트리밍 출력 및 중간 단계의 가시성을 제공받을 수 있습니다. http://localhost:8000/category_chain/playground/로 이동하여 사용해 보세요!

Client

이제 서비스와 프로그래밍 방식으로 상호 작용할 클라이언트를 설정해 봅시다. langserve.RemoteRunnable을 사용하면 클라이언트 측에서 실행 중인 것처럼 서비스된 체인과 상호 작용할 수 있습니다.

from langserve import RemoteRunnable

remote_chain = RemoteRunnable("http://localhost:8000/category_chain/")
remote_chain.invoke({"text": "colors"})
# >> ['red', 'blue', 'green', 'yellow', 'orange']

위의 코드를 실행하면 로컬호스트의 8000번 포트를 통해 category_chain을 실행하게되고 그 결과로 제일 하단의 내용을 반환하게 됩니다.

LangServe에 대한 다른 많은 기능에 대한 것을 배우려면 여기를 참고하세요.

Next steps

LangChain을 사용하여 애플리케이션을 만들고 LangSmith로 추적하며 LangServe로 서비스하는 방법에 대해 간략하게 살펴보았습니다. 여기에서 다룰 수 있는 것보다 이 세 가지 모두에는 훨씬 더 많은 기능이 있습니다. 계속해서 학습하려면:

LangChain Expression Language (LCEL)을 읽어서 이러한 구성 요소를 어떻게 연결할지 알아보세요.
LLMs, Prompt 및 Output parser에 대해 더 깊게 파고들고 다른 주요 구성 요소를 알아보세요.
공통적인 end-to-end 사용 사례 및 템플릿 애플리케이션을 탐색하세요.
디버깅, 테스트, 모니터링 등을 위한 플랫폼인 LangSmith에 대해 읽어보세요.
LangServe를 사용하여 애플리케이션을 서비스하는 방법에 대해 더 자세히 알아보세요.

이상은 2023년 버전의 Quickstart 내용이었습니다. 이후 최신 버전의 내용은 아래 링크를 참고하세요.

https://bigdatamaster.tistory.com/211

LangChain Quickstart(2024년 1월 기준)

이 포스팅은 2024년 1월 기준으로 새롭게 변경된 LangChain Quickstart에 대한 내용입니다. 이전 버전의 Quickstart 내용보다 상위 수준에서 설명하면서도 동시에 구체적인 예제 코드를 제시하고 있습니다

bigdatamaster.tistory.com

동영상 설명은 아래 링크를 참고하세요.

https://youtu.be/qM2hzIMFhuo

LangChain 설치 방법(Installation)

The Yellow Lion King — Fri, 29 Dec 2023 12:35:07 +0900

목차 LangChain - Get started

Introduction
Installation (이번 포스팅 내용)
Quickstart
Security

지난 시간에는 LangChain이 무엇인지에 대해서 알아보았습니다.

랭체인은 프레임웍이라고 했으며, 이 프레임웍을 이용하면 어플리케이션이 더 잘 알아듣고 추리/추론을 더 잘 할 수 있도록 개발 할 수 있다고 했습니다. 또한 전반적으로 언어모델을 활용한 어플리케이션을 쉽게 만들 수 있도록 도와 줍니다.

https://bigdatamaster.tistory.com/208

랭체인(LangChain) 이란? : 개요

지난 두번의 포스팅에[서 OpenAI API에 대한 개요와 활용하기 위한 기본적인 방법에 대해서 알아보았습니다. 이번에는 보다 복잡하고 쓸만한 어플리케이션을 만들기 위해서 필요한 랭체인(LangChain)

bigdatamaster.tistory.com

이번 포스팅의 내용은 이러한 랭체인을 사용할 수 있도록 패키지를 설치하는 방법에 대한 설명입니다.

공식 배포 버전 설치 방법

아주 간단합니다. 파이썬이 설치되어 있다면 간단히 아래 명령어로 랭체인을 설치할 수 있습니다.

pip install langchain

콘다를 설치해서 사용중이라면 아래의 명령을 사용하시면 됩니다.

conda install langchain -c conda-forge

이러한 명령은 랭체인을 사용하기 위해 아주 기본적이고 최소한의 내용만 설치 합니다. 랭체인의 가장 큰 가치는 다양한 모델 또는 데이터 저장소 등과 같이 통합될 때 나타납니다. 기본적으로 이런 통합을 의한 의존성이 있는 패키지들은 설치되지 않습니다. 따라서 이러한 통합 사용을 원한다면 별도로 필요한 의존성 패키지들 의 설치가 필요 니다.

소스를 이용한 설치

소스를 이용해서 설치가 필요하다면 소스 레포지토리를 클로닝 해서 할 수 있습니다. 이때는 PATH/TO/REPI/langchain/libs/langchain 와 같이 경로를 명확하게 해주고 아래의 명령어를 실행하면 됩니다.

pip install -e .

LangChain community

langchain-community 패키지는 제3자 통합하는 것을 가지고 있습니다. langchain을 설치하면 자동으로 함께 설치되지만, 아래의 명령어를 통해 개별적으로도 설치할 수 있습니다.

pip install langchain-community

LangChain core

langchain-core 패키지는 LangChain 생태계의 나머지 부분에서 사용하는 기본 추상화와 LangChain 표현 언어(LCEL)가 포함되어 있습니다. 이는 langchain에 의해 자동으로 설치되지만 독립적으로 사용될 수도 있습니다. 다음 명령어로 설치할 수 있습니다:

pip install langchain-core

LangChain experimental

langchain-experimental 패키지는 실험적인 LangChain 코드와 연구와 실험 사용을 위한 코드들을 가지고 있습니다. 이를 설치하기 위해서는 다음과 같은 명령어를 사용합니다.

pip install langchain-experimental

LangServe

LangServe는 개발자들이 LangChain runnables과 chain 들을 REST API로 배포하는 것을 도와 줍니다. LangServe는 LangChain CLI에 의해서 자동으로 설치됩니다. 만약 LangChain CLI를 사용하지 않는 다면 다음을 이용해서 설치하세요.

pip install "langserve[all]"

서버와 클라이언트 모두 설치시 위와 같이하면 되고

클라이언트 코드만 필요시 pip install "langserve[client'" 를

그리고 서버 코드만 필요시 pip install "langserve[server]" 를 이용합니다.

LangChain CLI

LangChain CLI는 LangChain templates나 다른 LangServe 프로젝트의 사용이 필요할 때 유용합니다.

pip install langchain-cli

LangSmith SDK

LangSmith는 LangChain 설치시 자동으로 설치됩니다. LangChain을 사용하지 않는다면 다음을 이용해서 설치할 수 있습니다.

pip install langsmith

이로써 LangChain 에 필요한 다양한 패키지들의 설치 방법에 대해서 알아보았습니다.

모든 설치가 끝난뒤에 pip list 명령어를 통해 정상적으로 설치되었는지를 확인 할 수 있습니다.

기본적으로는 pip install langchain 만 해도 기본적인 사용이 가능하며 module import error가 나면 필요한 패키지를 설치해줘도 됩니다.

다음 시간에는 예제를 통해 이들의 간단한 활용 방법에 대해서 알아보도록 하겠습니다.

아래 링크는 langchain 설치와 관련된 내용을 구글 colab에서 하나씩 실행하는 주피터 노트북 파일 입니다. 참고해서 직접 하나씩 실행시켜보세요.

https://colab.research.google.com/drive/1NTVYI564LLX46ugb9egDH0imLEtMmHfo?usp=sharing

아래는 내용을 좀더 자세히 설명하는 동영상 입니다.

https://youtu.be/hfbt30g4w5k

LangChain이란? : 랭체인 개요

The Yellow Lion King — Sun, 24 Dec 2023 18:34:35 +0900

목차 LangChain - Get started

Introduction (이번 포스팅 내용)
Installation
Quickstart
Security

지난 두번의 포스팅에서 OpenAI API에 대한 개요와 활용하기 위한 기본적인 방법에 대해서 알아보았습니다. 이번에는 보다 복잡하고 쓸만한 어플리케이션을 만들기 위해서 필요한 랭체인(LangChain)이라는 라이브러리에 대해서 알아보겠습니다.

일반적으로 OpenAI API를 그대로 쓰는 것 보다는 더 복잡하고 특정 업무를 처리하기 위한, 그런 어플리케이션을 만들어 사용합니다. 그도 그럴 것이 안그러면 그냥 ChatGPT의 웹을 이용하면 되겠지요. 그러나 특정 업무를 처리하기 위한, 특별한 어플리케이션을 만들려면 많은 추가적인 노력이 필요합니다. 이러한 노력을 줄여주는 라이브러리가 바로 랭체인 입니다. 이전 마지박 포스팅에서 언급한 것처럼, 살짝 특별한 대답을 위하는 경우에 가장 간단한 방법은 프롬프트 엔지니어링(Prompt Engineering)이라고 불리우는 방법으로, 사용자 입력 내용에 더하여 미리 설정된 문구를 함께 제공하는 방법이 있습니다. 이 방법은 쉽지만 한계가 많이 있습니다. 따라서 다양한 방법으로 어플리케이션의 품질을 높이는 방법이 필요한데요, 이러한 개발에 도움을 주는 라이브러리가 바로 랭체인입니다. 그래서 오늘은 먼저 랭체인의 개요에 대해서 알아보고자 합니다.

먼저, 주요 내용은 아래와 같은 페이지를 참조했음을 알립니다.

https://python.langchain.com/docs/get_started/introduction

랭체인(LangChain) 이란

LangChain 은 프레임웍입니다. 언어모델을 이용해서 어플리케이션을 개발할 때 어플리케이션이 맥락을 이해하고 추리 할 수 있도록 랭체인이 도와줍니다. 즉, 랭체인을 이용하면 언어모델을 이용한 어플리케이션이 맥락을 더 잘 이해하고, 추리를 더 잘 하게 만들 수 있습니다. 더 똑똑하게 만들 수 있습니다.

LangChain 프레임웍은 다음과 같이 4가지 파트로 구성됩니다.

LangChain Libraries: 파이썬과 자바스크립트 라이브러리 입니다. 이것은 많은 콤포넌트들 간의 연결과 통합을 제공합니다. 예를들면, 컴포넌트들을 체인, 에이전트와 연결하 여 기본 실행 환경을 제공하고 바로 쓸수 있는 체인과 에이전트를 제공합니다.
LangChain Templates: 다양한 종류의 작업을 위한 쉽게 배포할 수 있는 참조 아키텍처의 집합입니다.
LangServe: LangChain을 REST API로 배포하기 위한 라이브러리 입니다.
LangSmith: LLM 프레임웍하에서 개발되고 랭체인으로 유연하게 연결된 채인들을 디버그하고, 테스트, 평가 그리고 모니터링 할 수 있도록 기능을 제공하는 개발자 플랫폼입니다.

이러한 제품들을 이용하면 어플리케이션 라이프사이클을 단순하게 만듭니다. 개발, 제품화, 배포 등에서 활용됩니다.

Develop: 라이브러리를 이용하여 어플리케이션을 작성하고 참조 템플릿을 이용해서 개발을 시작할 수 있습니다. 즉, 밑바닥부터 시작하는 것이 아니라 라이브러리 import, 호출 만으로 쉽게 어플리케이션을 개발 할 수 있습니다.
Productionize: 랭스미스를 사용해서 여러분이 만든 체인을 조사, 테스트, 모니터링 할 수 있습니다. 그래서 여러분은 자신감을 가지고 지속해서 어플리케이션을 개선/배포 할 수 있습니다. 정확히 어떻게 돌아가는지 확인하고, 검증, 모니터링해서 어플리케이션의 품질을 확인할 수 있습니다.
Deploy: 랭서브를 이용해서 어떤 체인이든지 API로 바꿀 수 있습니다. 라이브러리를 이용하여 필요한 어플리케이션을 만들면 쉽게 API화 할 수 있습니다. 즉, 쉽게 Backend를 만들 수 있습니다.

보시는 것처럼 랭체인의 파트 들이 개발 라이프 사이클에 각각 녹아 들어가서 사용됩니다.

LangChain Libraries

랭체인 패키지들의 가치있는 주요 도구들은 바로 콤포넌트들과 미리 개발된 체인들입니다.

Components: 구성 가능한 툴과 언어모델과의 동작을 통합합니다. 여러분이 랭체인 프레임웍의 일부를 사용하던 안하던 간에, 콤포넌트들은 모듈화되어있고 사용하기 쉽습니다.
Off-the-shelf chains: 상위 수준의 작업을 완수하기 위한 콤포넌트들의 (미리 만들어진) 빌트인 체인 집합을 말합니다.

빌트인 체인들은 랭체인을 사용한 어플리케이션의 개발 시작을 쉽게 해줍니다. 콤포넌트들은 이런 빌트인 체인들을 이용해서 기존 체인을 쉽게 수정하고 새로운 체인을 만들수 있습니다.

랭체인 라이브러리 자체는 아래 3 개의 다른 패키지들로 구성됩니다.

langchain-core: 기본 추상화 모듈과 랭체인 표현언어(LCEL: LangChain Expression Language) 패키지입니다.
langchain-community: 제3자들의 개발을 통합하는 패키지입니다. 패키지에는 Models I/O, Retrieval, AgentTooling 모듈이 있습니다.
langchain: 체인, 에이전트, 그리고 어플리케이션의 인지 아키텍처를 보완하는 회수 전략(retrieval strategies)들의 패키지입니다.

Get started: 시작하기

여기에서는 어떻게 랭체인을 설치하고 여러분의 환경에 맞게 설정하고 만드는 것을 시작하는지 알려줍니다. 관련해서 별도 포스팅 예정입니다.

여러분이 첫번째 랭체인 어플리케이션을 만듬으로써 랭체인에 좀더 익숙해지도록 Quickstart 가이드를 따라해 보시기 바랍니다.

여러분이 보안 모범 사례 를 읽어 봄으로써 랭체인을 개발할 때 더욱 안전하게 만들어 보세요.

LangChain Expression Language (LCEL)

LCEL은 체인을 구성하기위해 선언적인 방법을 사용합니다. LCEL은 하루만에 프롬프트와 LLM의 간단한 체인부터 가장 복잡한 체인까지 코드 변경 없이 프로덕션에 프로토타입을 배포할 수 있도록 설계되었습니다. 이내용도 별도 포스팅 예정입니다. 여기서는 랭체인의 체인을 만들 떼 쉬운 방법이 (LCEL) 있구나 정도만 이해하시면 될 것 같습니다.

Overview: LCEL과 그 장점들
Interface: 객체들을 위한 표준 인터페이스
How-to: LCEL의 주요 기능
Cookbook: 공통 작업을 완료하기 위한 예시 코드

Modules

랭체인은 표준, 확장가능한 인터페이스와 통합을 위해 다음의 모듈들을 제공합니다.

Model I/O : 언어 모델과의 인터페이스 제공

Retrieval : 어플리케이션 특화 데이터와의 인터페이스 제공

Agents : 모델들이 주어진 상위 수준의 지시문을 이용하여 어떤 툴을 선택 할지를 제공하는 모듈

이러한 모듈들을 개발에 이용하여 어플리케이션을 만들게 됩니다. 따라서 어떻게 보면 개발자에게는 제일 중요한 파트라고 할 수 있습니다.

Examples, ecosystem, and resources

Use cases: 사용사례

Integrations: 통합 integrations.

Guides: 랭체인을 활용한 개발 모범 사례

API reference 파이썬 패키지에서 사용하기 위한 랭체인 클래스와 메소드들에 대한 문서 제공

Developer's guide

Community

아래는 내용을 좀더 자세히 설명하는 동영상 입니다.

https://youtu.be/HtmpB9CAdHY

[오류 처리] langchain 설치 (pip install langchain) 중에 아래와 같은 에러 발생

The Yellow Lion King — Sun, 17 Dec 2023 16:31:14 +0900

langchain 설치 (pip install langchain) 중에 아래와 같은 에러 발생

Error Message:

In file included from src/greenlet/greenlet.cpp:9: /Library/Developer/CommandLineTools/SDKs/MacOSX13.3.sdk/usr/include/c++/v1/cstdlib:135:9: error: no member named 'at_quick_exit' in the global namespace using ::at_quick_exit _LIBCPP_USING_IF_EXISTS; ~~^ /Library/Developer/CommandLineTools/SDKs/MacOSX13.3.sdk/usr/include/c++/v1/cstdlib:136:9: error: no member named 'quick_exit' in the global namespace using ::quick_exit _LIBCPP_USING_IF_EXISTS; ~~^ 2 errors generated. error: command '/usr/bin/clang' failed with exit code 1 [end of output] note: This error originates from a subprocess, and is likely not a problem with pip. ERROR: Failed building wheel for greenletFailed to build greenletERROR: Could not build wheels for greenlet, which is required to install pyproject.toml-based projects(venv) $

에러 메시지의 이미지

에러 내용을 자세히 보면 /usr/bin/clang 과 관련해서 문제가 있다고 나와서 인터넷 검색해보니 아래와 같은 페이지가 나왔음.

How to fix Error: command ‘/usr/bin/clang’ failed with exit code 1?

여기서 권장하는 대로 여러가지를 upgrade하고 나니 잘 됬음.

1,2,3 brew install openssl re2

이렇게 업그레이드 하고 다시 install langchain을 하니 grpcio error가 발생했음.

그래서 잘 돌아가는 가상환경에서 grpcio의 버전을 확인해서 설치를 했으나

실패

다시 그냥 langchain을 설치하려하니 이번에는 아래 같은 에러 발생

note: This error originates from a subprocess, and is likely not a problem with pip. ERROR: Failed building wheel for greenletFailed to build greenletERROR: Could not build wheels for greenlet, which is required to install pyproject.toml-based projects

내용을 뜯어 보니 greenlet이 문제 인 것 같아서..

다시 잘 돌아가는 가상 환경에서 greenlet이 있는지 찾아보고 같은 버전으로 설치

이런 젠장, 그래도 안되서 인터넷을 찾아보니 아래 명령을 실행하라고...

pip install --only-binary :all: greenlet

이렇게 하는 이유를 아래와 같이 설명하고 있는데..

Python packages are often distributed as "wheels" (.whl files), which are pre-compiled binary packages. Try installing "greenlet" and "Flask-SQLAlchemy" using wheels instead of source distribution`

이말을 풀어보면, 소스 배포형태에서 wheels 를 사용해서 설치하지말고 pre-compiled된 바이너리 패키지를 이용해서 설치하니까 잘 되더라 라는 의미임.

음.... 그러니까 소스를 가져다가 컴파일해서 쓰러면 컴피일과 관련 라이브러리, 경로 환경 등 여러가지가 맞아야 설치가 되는 데....바이너리 패키지를 설치하면 이런 복잡한 것 필요없이 쉽게 설치가 되더라 라는 의미로 이해됨.

이러고 나서 langchain을 설치하니까 잘 설치됨.

즉, 아래 명령 실행 후 langchain을 설치 했음.

pip install --only-binary :all: greenlet

[오류 처리] 잘되던 OpenAI+langchain 프로그램을, 가상 환경을 옮겨서 설치/실행하려할때 에러 처리(python pip lib 관련)

The Yellow Lion King — Sun, 17 Dec 2023 13:18:55 +0900

Cannot import name OpenAI from openai 그리고 langchain 설치

Error Message:

Cannot import name OpenAI from openai

잘 돌던 OpenAI API 프로그램인데 갑자기 에러를 발생 시킴

Cannot import name OpenAI from openai

원인:

써치 결과 openai 버전차이로 발생한 에러임.

잘 돌아가는 가상환경에서의 openai 버전을 확인해보니 1.3.6

안돌아가는 가상환경의 openai 버전을 확인해보니 0.27.0

인터넷 검색결과 1.2.0 이상이어야 에러가 안난다고함.

해결:

그래서 안돌아가는 가상환경에서 아래와 같이 업그레이드 실행하여 해결

pip install --upgrade openai==1.2.0

OpenAI API를 사용하다보니 많은 에러가 발생한다. 원인은 주로 버전간 차이 모델별 제공 파라메터 차이인 것 같음.

ChatGPT API 사용법 기초2: Chatting Application

The Yellow Lion King — Sun, 3 Dec 2023 12:53:14 +0900

ChatGPT의 API를 사용하면 직접 만든 앱/어플리케이션에서 ChatGPT가 대답하는 것 처럼 개발할 수 있습니다.
이번 내용은 이것을 위한 기본적인 흐름과 코드 내용을 배워 보는 것 입니다. 그래서 사용자가 질문을 입력하면 ChatGPT가 대답하는 대화하는 어플리케이션 프로그램을 만드는 것 입니다.

사전 준비 사항

ChatGPT API 사용을 위해서는 먼저 OpenAI에 가입이 되어 있어야 하고 API사용을 위한 [0.1]API Key를 발급 받아야 합니다. API Key란, API를 호출할 때 허가 받은(Credit이 설정되어있는) 사람이 호출하는 것인지 아닌지를 확인하기 위해서 미리 만들어진 텍스트를 말합니다. 'sk-'로 시작하며 예를 들면 다음과 같습니다.

sk-ABCDEFGHIJ1234567890ABCDEFGHIJ1234567890ABCDEFGH

개발 환경으로는 Google 의 CoLab을 이용할 예정이며 언어는 파이썬을 사용하겠습니다. Colab은 Google에서 제공하는 온라인 무료/유료 주피터 노트북 서비스입니다. 크롬 브라우저 사용을 권장하고요. 크롬에서 구글 로그인 후 여기를 클릭하시면 [0.2]새로운 노트북 파일을 만들 수 있습니다. 또는 여기 https://colab.google/ 를 통해 New notebook 버튼을 클릭합니다. 그러면 아래와 같은 온라인 주피터 노트북이 열립니다.

여기서 잠깐 : 노트북 기본 사용법

사용방법은 연결하고 작성하고 실행하는 것 입니다.

연결

오른쪽 위에 있는 연결 버튼을 클릭해서 화면에 보이는 프로그램과 실제 파이썬을 실행시킬 프로그램을 연결합니다. 일반 주피터 노트북에서는 이 실행 프로그램을 커널이라는 용어를 사용하는데 Colab에서는 실행 프로그램(커널)의 연결 뿐만아니라 실행된느 하드웨어 서버도 선택하여 연결 할 수 있습니다.

작성

가운데 부분에 있는 박스 영역을 쎌이라고 말합니다. 쎌을 한번 클릭하면 작성모드로 변하고 작성모드에서 클릭하면 선택 모드로 바뀝니다. 작성 모드에서 실행하려는 파이썬 코드 내용을 입력하여 프로그램을 작성합니다.

실행

실행 시키고자하는 프로그램이 작성된 쎌을 선택하고 Shift와 Enter를 같이 누르면 쎌의 내용이 실행됩니다. 또는 쎌의 왼쪽에 보이는 삼각형 버튼을 클릭하면 코드나 텍스트를 입력할 수 있습니다.

이렇게 해서 여러분도 온라인 파이썬 개발 환경을 가지게 되셨습니다.

QuickStart 에서도 나오지만 API 사용을 위해서 크게 3단계로 진행합니다. 1. 파이썬을 설정하고, 2. API Key를 사용할 수 있게 설정한 뒤에, 3. 필요한 프로그램에서 API Key와 필요한 함수를 호출하여(프로그램을 작성하여) ChatGPT의 기능을 사용할 수 있습니다.

1. 파이썬 설정

가장 먼저 할일은 파이썬을 설정 하는 것 입니다. 그런데 우리는 CoLab을 사용할 예정이어서 별도로 파이썬을 설치할 필요가 없습니다. 로컬 PC에서 해보고 싶으신 분은 이전 포스팅 또는 OpenAI -> Docs -> Quickstart의 파이썬 설치/설정 부분을 참고해주세요.
CoLab을 사용할 경우 파이썬 설치는 필요 없지만 필요한 라이브러리는 설치해 주어야 합니다. 물론 CoLab이 ML/AI 개발에 필요한 많은 라이브러리를 설치된 상태로 제공되기 때문에 sci-kit learn 같은 라이브러리는 import만 해서 사용할 수 있습니다. 그러나 openai는 기본 설치가 되어있지 않기 때문에 직접 설치해 주어야 합니다. [1.1]아래의 명령어로 설치할 수 있습니다.

!pip install openai

(명령어의 제일 앞에 !가 있는 이유는 Colab 주피터 노트북 의 쎌에서 shell 명령을 실행하기 위해서는 명령어 제일 앞에 !를 붙여 줘야 합니다. 즉, 로컬 PC 터미널이나 명령창에서 실행되기를 원하는 명령어의 경우에는 제일 앞에 !(느낌표)가 필요 합니다.) 이러한 방법으로 라이브러리를 설치할 수 있습니다.

다른 필요한 라이브러리와 함께 사용하기 위해서 설치된 버전을 조정해주어야 할 경우가 있습니다. 이런 경우 이미 설치된 라이브러리의 삭제가 필요한 데 이때는 아래의 명령어를 사용합니다.

!pip uninstall 라이브러리이름

2. API Key 설정

API Kye 설정이란, API Kye를 호출 할 때 같이 전송할 수 있도록 준비하는 것을 말합니다. OpenAI 홈페이지에서 API Key를 만듭니다.
OpenAI -> API Keys 메뉴 페이지에서 Create new secret key 번튼을 눌러서 새로운 API Key를 만들 수 있습니다.

주피터 노트북의 빈 쎌에 아래의 [2.1]내용을 입력하고 Shift와 Enter를 같이 누르거나 쎌 왼쪽에 있는 삼각형을 클릭하여 쎌을 실행시킵니다.

import os
os.environ['OPENAI_API_KEY']='복사한APIKey내용'

위의 내용은 환경변수 'OPENAI_API_KEY'에 복사한APIKey내용을 설정하는 명령 입니다.

3. 어플리케이션 작성

자, 이제부터는 위에서 작성한 환경변수를 설정하는 프로그램과 같이 어플리케이션 로직이 들어있는 파이썬 코드를 작성하면 됩니다.
지난 포스트에서 QuickStart에 있는 코드를 실행해 보았습니다. 이번에는 OpenAI Example 에서 하나를 진행해 보겠습니다. 위의 내용 까지 작성하고 실행한 colab 노트북 쎌 의 아래쪽에 새로운 쎌을 하나 만들고 [3.1]다음의 코드를 입력하고 실행합니다.

# This code is for v1 of the openai package: pypi.org/project/openai
from openai import OpenAI
client = OpenAI()

response = client.completions.create(
  model="gpt-3.5-turbo-instruct",
  prompt="The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly.\n\nHuman: Hello, who are you?\nAI: I am an AI created by OpenAI. How can I help you today?\nHuman: I'd like to cancel my subscription.\nAI:",
  temperature=0.9,
  max_tokens=64,
  top_p=1,
  presence_penalty=0.6,
  stop=[" Human:", " AI:"]
)

이 코드를 실행 시키면 prompt 내용이 chatGPT 모델에 전달되고 회신 받은 내용이 response에 저장됩니다. 전달자 중에 prompt의 내용을 한글로 변환하면 다음과 같습니다. "이어지는 내용은 AI 어시스턴트와의 대화입니다. 어시스턴트는 도움이되고, 창의적이고, 영리하며 매우 친절합니다. 사람: 안녕, 너는 누구니? AI: 나는 OpenAI에서 만든 AI입니다. 어떻게 도와드릴까요? 사람: 나는 가입을 취소하고 싶어 AI: "
그럼이제 반환된 response 내용을 살펴 볼까요! 아래와 같이 [3.2]쎌에 response 를 입력하고 실행합니다.

출력된 내용을 살펴보니 중간에 text의 값으로 AI 어시스턴트의 회신 내용이 보입니다. " Okay, I can definitely help you with that, May I know the reason for cancellation? ......". [3.3]어시스턴트의 회신 내용만 보기위해서 아래와 같이 쎌에 입력하고 실행합니다.

response.dict()['choices'][0]['text']

지금까지 한번의 대화 턴(Turn)이 있는 하나의 질문과 대답을 보았습니다. 계속적인 대화를 위해서 아래와 같은 파이썬 코드를 작성할 수 있습니다. while 문을 통해 반복 실행하도록 했으며, if 구문을 두어서 사용자가 입력한 값이 exit이면 while 문을 빠져나가서 종료하도록 하였습니다. 사용자가 질문을 입력한 것이라면 그내용을 chatGPT에 보내서 회신을 받고 회신 받은 내용을 출력해주는 명령을 작성하였습니다. [3.4]아래 내용을 복사하여 쎌에 입력후 실행해 보세요.

while True:
  prompt = input("질문을 입력하세요: ")
  if prompt == 'exit': break
  response = client.completions.create(
    model="gpt-3.5-turbo-instruct",
    prompt=prompt,
    temperature=0.9,
    max_tokens=64,
    top_p=1,
    presence_penalty=0.6,
    stop=[" Human:", " AI:"]
  )
  print(response.dict()['choices'][0]['text'])

제가 작성하고 실행한 결과는 아래와 같습니다.

추가 실습 방법:

client.completions.create() 함수에 있는 전달자의 값들을 바꾸어가면서 ChatGPT의 회신 내용을 비교해 보세요. temperature는 허풍, 거짓말 등 꾸며낸 이야기의 정도를 어떻게할지 조정할 수 있습니다. 0이면 꾸며내지 말라는 것이며 1을 최대한 꾸며내라는 것입니다. 이렇게 꾸며낸 이야기를 Hallucination이라고 하여 환각의 정도를 조정할 수 있습니다. max_tokens는 입력과 출력을 합친 단어수라고 생각하시면 됩니다. 간단히 말하면 회신 내용의 길이를 조정할 수 있습니다. top_p는 회신 내용의 건수 이며, presence_penalty는 동일한 답변을 조정하는 전달자 입니다.

이것으로 우리가 목표했던 계속적인 대화를 하는 간단한 어플리케이션이 만들어졌습니다. 이 프로그램은 ChatGPT의 대화를 OpenAI가 제공하는 웹서비스에서 사용하는 것이 아니라 별도의 어플리케이션 프로그램에서 사용할 수 있게 했다는 의미가 있습니다. 이후에는 프롬프트 엔지니어링 기법을 이용하여 보다 잘 알아 듣는 챗봇 어플리케이션을 만들어 보겠습니다.

안되는 부분이나 더 궁금한 점, 또는 이상한 점 있으시면 언제든지 댓글 달아주세요.
감사합니다.

검색에 날개를 달자!!! WebChatGPT

The Yellow Lion King — Sat, 25 Nov 2023 18:43:08 +0900

크롬 앱 스토어에서는 ChatGPT를 활용하는 다양한 플러그인 앱들이 올라와 있는데요, 그 중에서 실용적이고 많이 사용되고 있는 앱인 WebChatGPT를 소개 시켜 드리겠습니다.
이글을 읽고나면 WebChatGPT가 무엇인지, 어떤 효과가 있는지, 어떻게 사용하는지 등을 아실 수 있습니다. 이를 통해서 검색이나 ChatGPT를 사용할 때 좀더 쉽고 빠르게 원하는 정보를 얻으실 수 있습니다.
동영상 설명 자료는 여기를 참고해주세요.

무엇인가? : WebChatGPT란?

WebChatGPT는 ChatGPT를 사용하여 검색 결과와 ChatGPT의 결과를 향상 시키는 크롬 브라우저의 플러그인 앱 입니다. 그래서 크롬 앱 스토어로부터 앱을 설치할 수 있습니다. 이 앱의 목적은 인터넷 검색 결과를 활용하여 ChatGPT에 제공 할 질문(프롬프트)을 만들어주는 앱 입니다. 그래서 2가지 방법으로 사용될 수 있는데, 크롬에서 검색시에 사용될 수 있고 ChatGPT에서 채팅 시에 사용될 수 있습니다.

어떤 것을 할 수 있나? : 어떤 기능 이 있는가?

크롬에서 검색시에는 인터넷 검색을 통해 받은 내용을 활용하여 ChatGPT에게 질문 결과를 자동으로 확인 할 수 있습니다. 즉, 예전처럼 검색 결과로 나온 링크들을 일일히 찾아가서 내용을 보지 않아도, WebChatGPT를 사용하면 검색결과와 함께 요약된 주요 내용이 표시 됩니다.
그리고 ChatGPT를 사용할때는 질문 창에 질문은하면 자동으로 인터넷 검색 결과를 활용하여 답변을 생성해 줍니다. 그래서 LLM(Large Language Medel)이 가지는 훈련 데이터의 한계에서 벗어나서 최신 인터넷 정보를 활용하여 질문에 대답할 수 있습니다.
WebCahtGPT 페이지에서 설명하는 주요 특징들은 아래와 같습니다.
---- 주요 특징들:
1️⃣ 웹 접근 - 검색어에 대한 웹 결과 얻기 - 완전한 통찰력을 위해 전체 검색 결과 페이지 스크랩 - 모든 URL에서 웹페이지 텍스트 추출
2️⃣ 원 클릭 프롬프트 - 원 클릭 ChatGPT 프롬프트 라이브러리 - 나만의 프롬프트 관리
3️⃣ AI로 검색 - 검색 결과 바로 옆에 AI 생성 응답 받기 - ChatGPT, Claude, Bard, Bing AI 제공 - 모든 인기 있는 검색 플랫폼과 호환

사용 방법 : 어떻게 설치하는가? 어떻게 사용하는가?

설치 방법은 간단합니다. 구글 크롬 앱 스토어에 가서 WebChatGPT를 검색하거나 그냥 구글 검색에서 WebChatGPT를 검색하여 나온 결과 중 설치 페이지의 링크를 클릭하시면 됩니다. 즉, 구글 크롬 브라우저에서 검색어 입력창에 "webchatgpt 인터넷 액세스가 가능한"을 입력하시고 제일 위에 나오는 링크를 클린하시면 됩니다.

그러면 WebChatGPT 앱 페이지로 이동하고 우측 상단에 있는 Chrome에 추가 버튼을 클릭하시면 자동으로 설치됩니다.
설치 후에 구글 검색창에서 검색하시면 결과가 보여질때 오른쪽에 WebChatGPT의 결과도 같이 보여 줍니다. 그리고 OpenAI의 ChatGPT 채팅을 이용할 때에도 아래와 같이 질문 입력창 위에 One-click prompts 와 Web access 버튼이 보입니다.

기타 자세한 설치 및 사용 방법에 대한 설명은 아래의 영상을 참고하세요.
https://www.youtube.com/watch?v=midoXcI3By0

감사합니다.

OpenAI API 활용 방법 : 기초 1.

The Yellow Lion King — Fri, 24 Nov 2023 13:01:45 +0900

OpenAI에서 제공하는 API를 활용하여 다양한 기능을 사용하기 위한 기초 내용으로, 프로그램에서 OpenAI API를 사용하는 기초 방법에 대해서 설명합니다.
이 내용을 습득하시고 나면 Python 프로그램에서 OpenAI API를 호출하여 사용할 수 있습니다. 이것은 향후 조금만더 공부해 나간다면 개별 프로그램에서도 OpenAI의 ChatGPT와 같은 기능을 사용 할 수 있게 개발할 수 있습니다.
학습의 많은 내용은 OpenAI의 Documentation 에 있는 Quickstart의 내용을 참고하였습니다. https://platform.openai.com/docs/quickstart?context=python
(참고로 아래 내용과 함께, API Key만들기, API 지불방법 설정 등의 내용을 포함한 유투브 영상입니다.)
https://www.youtube.com/watch?v=HTzFYEr4Ai8)

시작해 보겠습니다.

좀더 구체적으로 이 글을 통해서 다음과 같은 내용을 배울 수 있습니다.

개발 환경을 어떻게 설정하는지
최신 SDKs(소프트웨어 개발 킷)을 설치하는지
OpenAI API에 대한 기본적인 개념
API 요청을 어떻게 보내는지

진행에 앞서 필요한 것이 있습니다. 그것은 OpenAI 계정과 API Key 입니다. 링크를 클릭하셔서 만드실 수 있습니다. 그리고 파이참, 비주얼 스튜디오 코드 등 통합개발환경(IDE: integrated development environment) 프로그램을 설치하시면 개발하기에 더 편하십니다.
이제 부터 파이썬 환경에서의 내용을 기준으로 설명하겠습니다.

전체적인 절차 단계는 아래와 같습니다.
1. 파이썬 설정
2. API Key 설정
3. API 요청 테스트
즉, 프로그래밍 언어 소프트웨어인 파이썬을 설치하고, API 호출에 필요한 API Key를 설정하고, 마지막으로 프로그램에서 API를 요청해 봅니다.

1. 파이썬 설정

파이썬 설정을 위해서는 파이썬 다운로드 및 설치, (선택적으로) 가상환경 설치, 그리고 OpenAI 라이브러리 설치가 필요합니다.

프로그램 환경에서 API를 이용하려한 것이니까 당연하게도 프로그래밍 언어의 설치가 필요합니다. 파이썬 설치는 파이썬 다운로드 페이지에 접속하셔서 사용중인 OS(Windows, MacOS, Unix)에 맞는 파이썬 설치 파일을 다운로드 받아서 설치하시면 됩니다.
선택적이긴 하지만 가상환경을 설치할 수 있습니다. 파이썬은 여러 라이브러리를 다운로드 받아 사용하는데 이러한 라이브러리 간의 사용 통일성과 프로젝트간의 간섭 방지를 위해서 관리가 필요합니다. 이러한 환경을 프로젝트 별로 관리할 수 있도록 해주는, 가상환경이라는 것을 만들 수 있습니다.

먼저 프로젝트 폴더를 하나 만들고 터미널이나 CMD명령 창에서 프로젝트 폴더로 이동 한 뒤에, 다음의 명령어로 가상환경을 만들 수 있습니다.(주의: 이후부터는 프로젝트 폴더의 위치에서 아래의 명령어 들을 실행하세요)

python -m venv openai-env

이 내용을 설명해보면 파이썬 프로그램의 venv 모듈을 실행시켜서 openai-env 라는 가상환경을 만들라는 명령입니다.
이렇게 가상환경을 만들고 나서 가상환경으로 들어간 뒤 라이브러리를 설치하게 되면, 설치된 라이브러리 들은 들어간 가상환경에서만 사용할 수 있게 됩니다. Windows에서 가상환경으로 들어가는 명령어는 아래와 같습니다.

openai-env\Scripts\activate

Unix나 MacOS에서의 명령어는 아래와 같습니다. 터미널에서 아래를 실행시키면 됩니다.

source openai-env/bin/activate

가상환경으로 들어가게 되면 터미널/명령창의 프롬프트가 바뀌게 됩니다. 보통 환경명이 나옵니다. 예를 들면 (openai-env) $ 이렇게 됩니다.

OpenAI 라이브러리 설치는 매우 간단합니다. 앞에서 만든 가상환경으로 들어간뒤에 아래의 명령어를 실행시키면 됩니다.

pip install --upgrade openai

2. API Key 설정

API Key는 매우 중요합니다. 왜냐하면 돈과 연결되어 있어서지요. 따라서 다른 사람이 모르도록 보안에 신경써야 합니다. 프로그램에서 사용하면서도 노출되지 않도록 설정하는 방법은 다음과 같이 2가지가 있습니다. 첫번째는 환경변수에 설정해주는 방법이고 두번째는 프로젝트 폴더에 .env 파일로 설정하는 방법입니다.

첫번째 환경변수에 설정하는 방법은 환경변수 OPENAI_API_KEY라는 변수에 발급받은 Key 값을 설정해 놓으면 됩니다. MaC 에서는 아래와 같이 터미널에 입력하면 됩니다.

export OPENAI_API_KEY='your-api-key-here'

Windows에서는 아래와 같이 명령창에 입력하면 됩니다.

setx OPENAI_API_KEY "your-api-key-here"

환경변수는 (.bash_profile 또는 .zshrc 파일에) 별도 로 설정해 주지 않으면 터미널 종료 시 사라지게됩니다. 따라서 계속적인 사용을 위해서는 Profile 파일에 추가로 설정이 필요합니다.

두번째는 '.env' 파일에 설정하는 방법입니다. 하나의 프로젝트에서 사용 할 수 있도록 설정하는 방법입니다. 프로젝트 폴터 안에서 .env 라는 이름의 파일을 새로 만듭니다. 그리고 그 파일의 내용을 아래와 같이 입력하세요.

# Once you add your API key below, make sure to not share it with anyone! The API key should remain private.
OPENAI_API_KEY=abc123

abc123의 위치에 발급받은 OpenAI API Key를 입력하시면 됩니다.
이렇게 입력하고 저장을 하시면 프로그램시 아래와 같은 내용으로 Key를 불러올 수 있습니다.

from openai import OpenAI

client = OpenAI()
# defaults to getting the key using os.environ.get("OPENAI_API_KEY")
# if you saved the key under a different environment variable name, you can do something like:
# client = OpenAI(
#   api_key=os.environ.get("CUSTOM_ENV_NAME"),
# )

이렇게 하면 코딩 내용에서는 API Key 내용이 없기 때문에 보안에 유리합니다.

3. API 요청 테스트

자, 이렇게 파이썬 준비도 끝나고 API Key설정도 끝났으면 실제로 사용해볼 차례 입니다. 위에서 만든 프로젝트 폴더에 openai-test.py라는 이름의 파일을 새로 만들어주세요. 내용을 아래와 같이 입력하세요.

from openai import OpenAI
client = OpenAI()

completion = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "You are a poetic assistant, skilled in explaining complex programming concepts with creative flair."},
    {"role": "user", "content": "Compose a poem that explains the concept of recursion in programming."}
  ]
)

print(completion.choices[0].message)

프로그램의 내용을 간단히 설명 드리면 OpenAI 라이브러리의 API를 이용하여 문장완성을 요청합니다. 모델을 gpt-3.5-turbo를 사용하고, 전달 메시지 로, API 또는 모델이 마치 프로그래밍 컨셉을 설명할 수 있는 능력이 있는 시 작성 도우미라고 설정하고(system), recursion의 컨셉을 설명하는 시를 한편 지어보라(user)는 명령 입니다.
위의 내용을 입력후 저장한뒤에, 터미널/명령창 에서 아래와 같이 실행시키면 프로그램이 실행하게 됩니다.

python openai-test.py

프로그램이 잘 실행된다면 아래와 같이 텍트스 문장이 표시될 껍니다. (아, 저는 파일이름을 openai_api_test.py로 했네요.)

마무리

이렇게 해서 OpenAI API와 관련해서 기초를 배워 봤습니다. 프로그래밍 환경으로 파이썬을 설정했고, API Key를 코딩할때 쓸 수 있도록 설정했습니다. 마지막으로는 간단한 내용의 시를 작성하는 명령을 OpenAI API를 이용하여 프로그램에서 실행해 보았습니다.
OpenAI 라이브러리에는 엄청나게 많은 기능을 제공하고 있습니다. 어플리케이션 프로그램에서 ChatGPT와 같은 서비스를 할 있게 만들 수 있습니다. 프로그램이 가능하기 때문에 ChatGPT의 채팅 창에서 하는 것 보다 더 복잡하고 정교하고 서비스에 필요한 질문과 답변을 할 수 있습니다.
OpenAI AP I를 이해하는데 있어서 여러분에게 도움이 되셨길 바랍니다.
감사합니다.

AWS RDS MySQL DB에 접속하려고 할때 발생한 에러 메세지

The Yellow Lion King — Wed, 22 Nov 2023 23:35:24 +0900

아래는 Google CoLab에서 AWS RDS MySQL DB에 접속하려고 할때 작성한 코드와 발생 에러 메세지입니다.

from sqlalchemy import create_engine

engine = create_engine('mysql+pymysql://id:pwd@dev.cluster-cziqwp.ap-northeast-2.rds.amazonaws.com:3306/dbname', pool_pre_ping=True)

engine = engine.execution_options(autocommit=True)

db_conn = engine.connect()

result = db_conn.execution_options(autocommit=True).execute('select count(*) from dbname.t where batch_date = "20231121";')

print("result: ", result)

result.close()

---------------------------------------------------------------------------
TimeoutError                              Traceback (most recent call last)
/usr/local/lib/python3.10/dist-packages/pymysql/connections.py in connect(self, sock)
    612                         try:
--> 613                             sock = socket.create_connection(
    614                                 (self.host, self.port), self.connect_timeout, **kwargs

44 frames
TimeoutError: timed out

During handling of the above exception, another exception occurred:

OperationalError                          Traceback (most recent call last)
OperationalError: (2003, "Can't connect to MySQL server on 'dev.cluster-czafliq9kcwp.ap-northeast-2.rds.amazonaws.com' (timed out)")

The above exception was the direct cause of the following exception:

OperationalError                          Traceback (most recent call last)
/usr/local/lib/python3.10/dist-packages/pymysql/connections.py in connect(self, sock)
    662                 if DEBUG:
    663                     print(exc.traceback)
--> 664                 raise exc
    665
    666             # If e is neither DatabaseError or IOError, It's a bug.

OperationalError: (pymysql.err.OperationalError) (2003, "Can't connect to MySQL server on 'dev.cluster-czafliq9kcwp.ap-northeast-2.rds.amazonaws.com' (timed out)")
(Background on this error at: https://sqlalche.me/e/14/e3q8)

Error Messages — SQLAlchemy 1.4 Documentation

Previous: Third Party Integration Issues Next: Changes and Migration Up: Home On this page: Error Messages Connections and Transactions DBAPI Errors SQL Expression Language Object Relational Mapping AsyncIO Exceptions Core Exception Classes ORM Exception C

docs.sqlalchemy.org

아무리 찾아봐도 연결이 안될 이유가 없었습니다.

먼저 AWS Sagemaker Jupyter Notebook에서 연결을 확인해보니 잘 되었습니다.

이로 확실한 것은 Sagemaker에서는 접속이되니 DB 문제는 아니라는 것,

그래서 가능한 원인은 두가지 중 하나 입니다.

1. 네트워크 문제 또는 2. 롤(권한)의 문제

1. 네크워크 문제는 Colab에서 IP를 확인하여 AWS VPC에서 Colab의 IP가 연결 오픈 되어있는지 확인하면 됩니다. 안되어있으면 추가해주어야 겠지요.

2. 롤문제는 접속시 AWS CLI를 통해 임시 권한을 받고 이를 통해 접속해 보면 확인 됩니다. 이역시 안되어있을 경우 IAM Role을 만들어서 해결 가능 합니다.

The Yellow Lion King 데이터와 함께 살아가기

DeepSeek 충격의 배경과 현상 및 원인 이해해기

최근 이슈가되는 DeepSeek에 대한 그 현상과 원인 설명을 통해 내용 이해에 도움을 드리고자 합니다.

목차

현상

NVIDIA 주가 폭락

나스닥 지수 폭락

원인분석

1. DeepSeek App Download 1위

2. (DeepSeek App이 1위 한 이유는) 좋은 서비스를 무료로 제공해서

3. (좋은 서비스를 무료로 제공할 수 있었던 이유는) 좋은 모델을 싸게 만들어서

4. (좋은 모델을 싸게 만들 수 있었던 이유는) 엔지니어링을 통해 저사양의 서버를 효과적으로 사용해서

5. (저사양의 서버를 효과적으로 사용할 수 있었던 이유는) 좋은 엔지니어들이 있어서

영향도 분석(별도 포스팅)

Source

mbread

AWS Partner Tech Grue Community

LCEL-왜 LCEL을 사용하는가?

준비

Invoke

Stream

Batch

Async

Chat Model 대신 LLM 사용

모델 제공자가 다른 경우

실행 환경 설정(Runtime configurability)

로깅(Logging)

Fallbacks

전체 코드 비교

요약

Next Steps

LCEL-Get started : 시작해 보기

LCEL 시작하기 : Get started

기본 예제 : 프롬프트 + 모델 + 출력 파서

1. Prompt​

2. Model​

3. Output parser​

4. 전체 Pipeline​

RAG 검색 예시

Next steps​

Langserve ERROR: [Errno 99] error while attempting to bind on address ('::1', 8000, 0, 0): cannot assign requested address

현상:

원인:

조치:

LangServe Endpoint Test Error: {"detail":"Not Found"}%

현상:

원인:

해결 방법:

LangChain Error : ModuleNotFoundError: No module named 'docarray'

에러 메시지:

원인 :

해결 방법 :

LangChain Error: ImportError: cannot import name 'create_retriever_tool' from 'langchain_community.agent_toolkits'

에러 발생 코딩 내용 :

에러 내용 :

원인 :

해결 방법 :

LangChain-Get started- Security

목차 LangChain - Get started

보안(Security)

최적의 방법

취약점 보고하기

기업 솔루션

기타

LangChain Quickstart(2024년 1월 기준)

Setup

Jupyter Notebook

Installation

LangSmith

Building with LangChain

LLM Chain

Diving Deeper

Retrieval Chain

Diving Deeper

Conversation Retrieval Chain

Updating Retrieval

Agent

Diving Deeper

Serving with LangServe

Server

1. Prompt

2. Model

3. Output parser

4. 전체 Pipeline

Next steps

Prompt templates

LangChain Libraries

Get started: 시작하기

LangChain Expression Language (LCEL)

Modules

Model I/O : 언어 모델과의 인터페이스 제공

Retrieval : 어플리케이션 특화 데이터와의 인터페이스 제공

Agents : 모델들이 주어진 상위 수준의 지시문을 이용하여 어떤 툴을 선택 할지를 제공하는 모듈

Examples, ecosystem, and resources

Use cases: 사용사례

Integrations: 통합 integrations.

Guides: 랭체인을 활용한 개발 모범 사례

API reference 파이썬 패키지에서 사용하기 위한 랭체인 클래스와 메소드들에 대한 문서 제공

Developer's guide

Community