이전 포스팅까지 잘 따라오셨다면 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을 사용할 때 보안 관점에서의 필요성과 보안 모범 사례를 알아보았고,
예상 시나리오에 대한 적절한 완화 전략과 기타 보안 관련 내용에 대해서 이야기해 보았습니다.
이 포스팅은 2024년 1월 기준으로 새롭게 변경된 LangChain Quickstart에 대한 내용입니다. 이전 버전의 Quickstart 내용보다 상위 수준에서 설명하면서도 동시에 구체적인 예제 코드를 제시하고 있습니다. 예를 들어 이전버전에서는 가장 간단한 prompte + LLM 버전의 체인을 만드는 것에 집중했다면 새로운 Quickstart에서는 LLM Chain, Retrieval Chain, Conversation Retrieval Chain, Agent 등의 내용과 예제를 제공합니다. 다루는 폭이 넓어지고 다양해 졌다고 할 수 있겠네요.
이번 시간에는 랭체인을 이용해서 간단한 어플리케이션을 만들고 서빙을(배포를) 해 보겠습니다. 다시 말하면, (이전의 내용들을 잘 따라오셨다면) 랭체인을 이용해서 간단한 언어 모델 어플리케이션을 만들 수 있다는 의미 입니다. 아주 멋지고 유용한 어플리케이션을 만들기 위해서 먼저, 간단한 어플리케이션을 만들어보는 과정이라고 하겠습니다.
전체 내용은 이렇습니다. 먼저 환경 및 필요한 내용을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는 베타버전의 서비스 입니다. 따라서 품질에 대한 보증은 어렵습니다. 그래도 방금 페이지에 접속해보니 사용을 위해서는 대기해야할 정도로 인기가 있네요.
참고로 LangSmith는 베타버전의 서비스 입니다. 따라서 품질에 대한 보증은 어렵습니다. 그래도 방금 페이지에 접속해보니 사용을 위해서는 대기해야할 정도로 인기가 있네요.
Building with LangChain
LangChain은 개발하는 어플리케이션이 데이터의 외부 소스와 LLMs 모델 의 처리를 연결 할 수 있게 합니다. 이 가이드에서 우리는 이와 같은 연결을 하는 몇가지 다른 방법을 진행할 것입니다. 우리는 먼저 간단한 LLM 체인으로 시작할 것인데 이 체인은 프롬프트 템플릿에 있는 정보에 의존해서 반응(회신)합니다. 그 다음에 retrieval chain(회수 체인)을 만들껀데요, 이것은 분리된 데이터 베이스로 부터 데이터를 가져와서 프롬프트 템플릿으로 전달합니다. 우리는 그리고나서 chat history를 추가할 것인데요, 이것은 이전 질문들을 기억하는 것입니다. 마지막으로는 에이전트를 만들 예정입니다. 이 에이전트는 질문에 대답하기 위해서 데이터를 가져와야 하는지 아닌지를 결정하기 위해서 LLM을 이용합니다. 우리는 이와 같은 내용을 상위 수준에서 다룰 예정이지만 사실 많은 상세 내용들이 있습니다. 이런 상세 내용은 링크로 연결/제공하겠습니다.
LLM Chain
공식 문서 가이드에서는 두가지 옵션을 제공 니다. 하나는 OpenAI를 이용하는 것이고 다른 하나는 로컬에 저장된 오픈소스모델을 이용하는 것입니다. 그러나 이 문서에서는 쉬운 사용법 이해를 위해 OpenAI를 이용하도록 하겠습니다. 로컬 모델을 이용하실 분은 공식문서를 참고해주세요.
키를 발급 받으신 다음에는 아래와 같은 명령어를 이용해서 환경번수에 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()
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를 이용해서 동적으로 가장 관련 높은 문서를 선택해서 가져오고 전달 할 수 있습니다.
우리는 이제 이 체인을 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?"})
우리는 LangChain을 활용한 어플리케이션을 어떻게 만들고 LangSmith로 어떻게 그것을 다루 며, 그리고 LangServe를 가지고 어떻게 서빙하는지 알아보았습니다. 여기서 다룬 것보다 이 세 가지 모두에는 훨씬 더 많은 기능이 있습니다. 계속해서 학습하려면 다음의 내용을 참고하기를 추천 합니다.:
이전 포스팅을 통해서 OpenAI API를 사용하는 방법에 대해서 배웠으며, 랭체인이 무엇인지를 알아보았고, 그리고 랭체인을 설치하는 방법에 대해서 알아보았습니다.
이번 시간에는 랭체인을 이용해서 간단한 어플리케이션을 만들고 모니터링하고 서빙을(배포를) 해 보겠습니다. 다시 말하면, (이전의 내용들을 잘 따라오셨다면) 랭체인을 이용해서 간단한 언어 모델 어플리케이션을 만들 수 있다는 의미 입니다. 아주 멋지고 유용한 어플리케이션을 만들기 위해 먼저 간단한 어플리케이션을 만들어보는 과정이라고 하겠습니다.
전체 내용은 이렇습니다. 먼저 환경 및 필요한 내용을Setup하고,LangChain을 만들어보고,LangSmith로 추적해보고,LangServe로 서빙해 보겠습니다.
Setup
Installation
이 내용은랭체인 설치 방법으로바로 지난 포스팅에서 다룬 내용입니다. 아래의 명령어를 실행합니다.
pip install langchain
conda 환경에서는 아래를 실행합니다.
conda install langchain -c conda-forge
Environment
랭체인을 사용한다면 보통 하나 이상의 모델 제공자나 데이터 저장소, 또는 APIs와의 통합이 필요합니다. 이번 예제에서는 OpenAI의 모델 API를 이용하려 합니다. 따라서 OpenAI 패키지 사용을 위해서 다음과 같은 OpenAI 패키지 설치 명령어를 실행 시켜 줍니다.
키를 발급 받으신 다음에는 아래와 같은 명령어를 이용해서 환경번수에 Key 값을 설정해 주세요.
export OPENAI_API_KEY="..."
이처럼 환경변수에 설정하고 싶지 않다면, 아래와 같이 프로그램에서 openai_api_key의 파라메터에 key 값을 전달할 수도 있습니다.
from langchain.chat_models import ChatOpenAI
llm = ChatOpenAI(openai_api_key="...")
LangSmith
여러분이 만드시는 많은 어플리케이션은 LLM(LargeLanguageModel) 호출을 여러번 실행하는 멀티 스텝을 갖게 될 것입니다. 이러한 어플리케이션이 점점더 복잡해 짐에 따라서 여러분의 체인과 에이전트가 정확하게 무엇을 하고 있는지 조사하는 것 또한 점점 더 중요해 집니다. 이를 위해 가장 좋은 방법이 바로 LangSmith를 이용하는 것 입니다.
LangSmith가 반드시 필요한 것은 아닙니다. 그러나 도움이 됩니다. 바로 위의 링크를 통해 LangSmith에 접속해서 LangSmith Key를 받고, 아래와 같이 설정해서 사용할 수 있습니다. 참고로 LangSmith는 베타버전의 서비스 입니다. 따라서 품질에 대한 보증은 어렵습니다. 그래도 방금 페이지에 접속해보니 사용을 위해서는 대기해야할 정도로 인기가 있네요.
참고로 LangSmith는 베타버전의 서비스 입니다. 따라서 품질에 대한 보증은 어렵습니다. 그래도 방금 페이지에 접속해보니 사용을 위해서는 대기해야할 정도로 인기가 있네요.
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은 문자열만을, 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")
대부분의 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의 주요 유형 몇 가지가 있으며, 이에는 다음이 포함됩니다:
이 시작 가이드(포스팅)에서는 우리만의 출력 파서를 작성할 것입니다. 즉, 쉼표로 구분된 목록을 그냥 목록으로 변환하는 출력 파서입니다.
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를 사용하여 애플리케이션 추적을 디버그하고 주석을 달고, 이를 향후 애플리케이션 반복 평가를 위한 데이터 세트로 변환할 수 있습니다.
이제 애플리케이션을 구축했으므로 서비스를 해야 합니다. 이때 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에서 서빙되는 우리의 체인을 볼 수 있습니다.
이번 포스팅의 내용은 이러한 랭체인을 사용할 수 있도록 패키지를 설치하는 방법에 대한 설명입니다.
공식 배포 버전 설치 방법
아주 간단합니다. 파이썬이 설치되어 있다면 간단히 아래 명령어로 랭체인을 설치할 수 있습니다.
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에서 하나씩 실행하는 주피터 노트북 파일 입니다. 참고해서 직접 하나씩 실행시켜보세요.