LangChain Quickstart(2024년 1월 기준)

2024. 1. 1. 14:38

이 포스팅은 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' 카테고리의 다른 글

LCEL-Get started : 시작해 보기 (0)	2024.01.13
LangChain-Get started- Security (0)	2024.01.07
LangChain Quickstart(랭체인 기본 예시) (0)	2023.12.29
LangChain 설치 방법(Installation) (0)	2023.12.29
LangChain이란? : 랭체인 개요 (0)	2023.12.24

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