이 글은 화웨이 클라우드 커뮤니티 " 랭체인이란 무엇인가요?" 에서 공유한 글입니다. LangChain의 자세한 소개 및 사용 시나리오 ", 저자: Ma Shanghua_Lancer.
1. 컨셉 소개
1.1 랭체인이란 무엇입니까?
공식 정의는 다음과 같습니다: LangChain은 개발자가 언어 모델을 사용하여 엔드투엔드 애플리케이션을 구축할 수 있도록 설계된 강력한 프레임워크로, LLM(대형 언어 모델) 및 채팅 모델 생성을 단순화하는 도구, 구성 요소 및 인터페이스 세트를 제공합니다. 지원되는 애플리케이션을 제공하는 과정입니다. LangChain은 문서 분석 및 요약, 챗봇, 코드 분석을 포함하여 언어 모델의 사용 사례와 광범위하게 겹치는 언어 모델 통합 프레임워크입니다.
간단히 말해서 LangChain은 개발자가 LLM 애플리케이션을 프로토타입에서 프로덕션 환경으로 전환할 수 있도록 유연한 추상화 및 AI 우선 도구를 제공합니다. 또한 개발자가 상황 인식, 추론 애플리케이션을 구축하는 데 도움이 되는 도구 세트를 제공합니다.LangChain의 도구에는 챗봇, 문서 분석, 요약, 코드 분석, 작업 흐름 자동화, 사용자 정의 검색 등이 포함됩니다.
1.2 LangChain을 사용하는 방법은 무엇입니까?
LangChain을 사용하려면 개발자는 먼저 LLM, 채팅 모델, 에이전트, 체인 및 메모리 기능과 같은 필수 구성 요소와 도구를 가져옵니다. 이러한 구성 요소가 결합되어 사용자 입력을 이해하고, 처리하고, 응답하는 애플리케이션을 만듭니다.
LangChain은 개인 비서, 문서 Q&A, 챗봇, 표 형식 데이터 쿼리, API 상호 작용, 추출, 평가 및 집계와 같은 특정 사용 사례에 대한 여러 구성 요소를 제공합니다.
자세한 현지 구축 과정은 https://bbs.huaweicloud.com/blogs/414657
2. 주요 구성 요소:
- 모델 I/O: 대규모 언어 모델(모델), 해당 입력(프롬프트) 및 형식화된 출력(출력 구문 분석기)을 관리합니다.
- 데이터 연결: 주로 개인 도메인 지식(라이브러리)을 구축하는 데 사용되는 벡터 데이터 저장소(Vector Stores), 콘텐츠 데이터 수집(Document Loaders) 및 변환(Transformers)과 벡터 데이터 쿼리(Retrievers)를 관리합니다.
- 메모리 : 대화 이력을 저장하고 획득하는 기능 모듈
- 체인: 연속적인 대화 및 추측 프로세스를 달성하기 위해 메모리 ←️ 모델 I/O ⇔ 데이터 연결에 사용됩니다.
- 에이전트: 체인을 기반으로 도구(도구)를 추가로 연결하여 대규모 언어 모델의 기능을 로컬 및 클라우드 서비스 기능과 결합합니다.
- 콜백: 로깅, 추적 등 데이터 전환을 용이하게 하기 위해 LLM 지원의 각 단계에 연결할 수 있는 콜백 시스템을 제공합니다.
Langchain 코어 모듈 아키텍처 다이어그램:
3. 핵심 모듈
3.1 모델 I/O
모델은 서로 다른 유형의 모델과의 비즈니스 상호 작용을 완료하는 데 사용되는 LLM의 대화형 구성 요소에 연결됩니다. LangChain은 모델을 LLMS와 Chat Model의 두 가지 모델 모드로 나누고 서로 다른 템플릿을 통해 세 모델의 비즈니스 상호 작용을 완료합니다. 운영.
3.2 LLM
언어 이해 및 생성 기능을 갖춘 상용 대규모 언어 모델을 말하며, 텍스트 문자열을 입력으로 받아 텍스트 문자열을 출력으로 반환합니다. LLM 클래스는 대규모 언어 모델과의 인터페이스 상호 작용을 위해 LangChain에서 설계되었으며 OpenAI, Cohere 및 Hugging Face와 같은 LLM 공급자를 위한 표준 인터페이스를 제공하는 것을 목표로 합니다.
OpenAI LLM 래퍼를 예로 들면 사용법은 다음과 같습니다.
LangChain.llms에서 import OpenAI llm = OpenAI(온도=0, model_name='gpt-3.5-turbo', openai_api_key=OPENAI_API_KEY) llm("자신을 소개해주세요") llm.get_num_tokens(질문)
3.3 채팅
채팅 모델은 언어 모델의 변형입니다. 채팅 모델은 언어 모델을 기반으로 하며 내부적으로 언어 모델을 사용합니다. 더 이상 텍스트 문자열을 입력 및 출력으로 사용하지 않고 채팅 정보를 입력 및 출력으로 나열합니다. 그들은 제공합니다. 보다 구조화된 API. 하나 이상의 메시지가 채팅 모델을 통해 전달될 수 있습니다. LangChain은 현재 AIMessage, HumanMessage, SystemMessage 및 ChatMessage의 네 가지 메시지 유형을 지원합니다.
- SystemMessage: 시스템 메시지는 모델을 설정하는 데 사용되는 도구로, 역할극 등 모델의 특정 환경과 배경을 지정하는 데 사용할 수 있습니다.
- HumanMessage: 휴먼 메시지는 사용자 정보, 질문하기 등 사람이 제공하는 정보로, Chat Model 모델을 사용하려면 시스템 메시지와 휴먼 메시지를 목록에 넣어서 Chat Model의 입력으로 사용해야 합니다. 모델
- AIMessage: AI가 출력하는 메시지로, 질문에 대한 답변이 될 수 있습니다.
- ChatMessage: 채팅 메시지는 모든 역할의 매개변수를 허용할 수 있습니다.
대부분의 경우 HumanMessage, AIMessage 및 SystemMessage 메시지 유형만 처리하면 됩니다. 또한 채팅 모델은 여러 메시지를 입력으로 지원합니다. 아래에는 시스템 메시지와 사용자 메시지의 예가 나와 있습니다.
message = [ SystemMessage(cnotallow="당신은 영어를 프랑스어로 번역하는 유용한 조수입니다."), HumanMessage(cnotallow="저는 프로그래밍을 좋아합니다.") ] chat(messages) AIMessage(cnotallow="J'aime 프로그래머.", 추가_kwargs={})
여러 메시지 세트를 생성하려면 생성을 사용하세요.
배치_messages = [ [ SystemMessage(cnotallow="당신은 영어를 프랑스어로 번역하는 유용한 도우미입니다."), HumanMessage(cnotallow="저는 프로그래밍을 좋아합니다.") ], [ SystemMessage(cnotallow="당신은 영어를 번역하는 유용한 도우미입니다." to French."), HumanMessage(cnotallow="나는 인공지능을 좋아합니다.") ], ] result = chat.generate(batch_messages)
3.4 프롬프트
Prompt는 모델의 입력을 의미하며 이 입력은 하드 코딩되는 경우가 거의 없으나 특정 템플릿 구성 요소를 사용하여 구성됩니다. 이 템플릿 구성 요소는 프롬프트 템플릿을 입력으로 제공할 수 있는 PromptTemplate 프롬프트 템플릿입니다. 템플릿 특정 형식을 의미합니다. 그리고 우리가 얻고자 하는 답의 청사진. LangChain은 다양한 유형의 작업에 대한 프롬프트를 생성하는 데 사용할 수 있는 사전 설계된 프롬프트 템플릿을 제공합니다. 사전 설정된 템플릿이 요구 사항을 충족할 수 없는 경우 사용자 정의된 프롬프트 템플릿을 사용할 수도 있습니다.
LangChain에서는 필요에 따라 프롬프트 템플릿을 설정하고 이를 메인 체인과 연결하여 출력 예측을 수행할 수 있습니다. 또한 LangChain은 결과를 더욱 구체화하기 위한 출력 파서 기능도 제공합니다. 출력 구문 분석기의 역할은 모델 출력의 형식을 지정하고 출력을 필요한 형식으로 구문 분석하는 방법을 안내하는 것입니다.
프롬프트를 쉽게 작성하고 처리할 수 있도록 여러 클래스와 함수가 제공됩니다.
3.4.1 PromptTemplate 프롬프트 템플릿
텍스트 템플릿을 생성하고 변수 매개변수 형태의 완전한 명령문으로 연결할 수 있습니다.
from langchain.llms import OpenAI from langchain import PromptTemplate import os openai_api_key = os.environ["OPENAI_API_KEY"] # openAi 모델 사용 llm = OpenAI(model_name="gpt-3.5-turbo", openai_api_key=openai_api_key) # 템플릿 형식 template = " {value}을(를) 먹고 싶은 기분이 듭니다. 어떻게 만들어야 할까요?" # 빌드 템플릿 프롬프트 = PromptTemplate( input_variables=["value"], template=template, ) # 템플릿 생성 콘텐츠 final_prompt = 프롬프트.format(value='돼지고기 조림 ' ) print("입력 내용::", final_prompt) print("LLM 출력:", llm(final_prompt))
입력 내용 : 돼지고기 조림이 먹고 싶어요. LLM 출력 : 돼지고기 조림 만드는 순서는 다음과 같습니다 1. 재료 준비 : 삼겹살 500g, 마늘 2쪽, 생강 1조각, 설탕 2스푼, 간장 3스푼 , 진간장 1스푼, 맛술 2스푼, 물 500ml. 2. 삼겹살은 사방 2~3cm 크기로 썰어주세요. 3. 손질한 삼겹살을 찬물에 삶아 비린내를 빼기 위해 데친 후 건져둔다. 4. 팬을 달구고 찬 기름을 두른 후 슬라이스 생강과 마늘을 넣고 향이 날 때까지 볶습니다. 5. 냄비에 데친 삼겹살을 넣고 양면이 살짝 갈색이 될 때까지 볶아줍니다. 6. 설탕을 넣고 설탕이 녹고 색이 변할 때까지 약한 불에서 볶는다. 7. 연간장과 진간장을 넣고 골고루 볶아가며 색을 균일하게 해주세요. 8. 맛술을 붓고 고르게 볶아줍니다. 9. 고기를 삶는 데 사용할 물을 삼겹살이 살짝 잠길 만큼 넣고, 풍미를 더하기 위해 작은 티백이나 양념주머니를 넣은 후 냄비 뚜껑을 덮고 센 불에서 끓입니다. 10. 약한 불로 줄여 40~50분간 끓이는데, 이 동안 고기의 색이 고르게 유지되도록 자주 끓여주어야 합니다. 11. 마지막으로 즙을 모아 즙이 걸쭉해지면 불을 꺼주세요. 12. 삶은 돼지고기를 꺼내서 썰어 접시에 담아낸다.
3.4.2 FewShotPromptTemplate 선택기
프롬프트의 샘플 콘텐츠도 문장에 연결되어 모델이 의미론적 의미를 이해하고 결과를 제공할 수 있습니다.
langchain.example_selector import semanticsimilarityexamplyselector에서 langchain.vectorstores leggchain.embeddings import langchain.prompts import import fewshotprompttemplate, langchain.mms openai os openai _ os. 키 "] llm = OpenAI(model_name="gpt-3.5-turbo", openai_api_key=openai_api_key) example_prompt = PromptTemplate( input_variables=["input", "output"], template="입력 예:{input}, 출력 예:{ 출력}", ) # 선택할 수 있는 예제 목록입니다. example = [ {"input": "Pilot", "output": "Aircraft"}, {"input": "Pilot", "output": " car"}, {"input": "Chef", "output": "Kitchen"}, {"input": "Stewardess", "output": "Airplane"}, ] # 의미론을 기반으로 사용자와 유사한 입력을 선택합니다. 예 example_selector = SemanticSimilarityExampleSelector.from_examples( example, # 의미적 유사성을 측정하기 위한 임베딩 클래스를 생성합니다. OpenAIEmbeddings(openai_api_key=openai_api_key), # 단어 벡터 저장 FAISS, # 생성된 예제 수 k=4 ) # 선택기 예제 프롬프트 유사_prompt = FewShotPromptTemplate( example_selector= example_selector, example_prompt=example_prompt, # 프롬프트 상단과 하단에 추가되는 프롬프트 항목 prefix="다음 예에 따라 출력을 작성하세요", suffix="입력: {value}, 출력:", # 입력 변수 input_variables=[ "value"], ) value = "Student" # 템플릿 생성 콘텐츠 final_prompt = 유사한_prompt.format(value=value) print("입력 콘텐츠::", final_prompt) print("LLM 출력:", llm( final_prompt))
입력 내용:: 다음 예를 기반으로 출력 예를 작성합니다. 입력 예: Chef, 출력 예: Kitchen 입력 예: Driver, 출력 예: Car 입력 예: Pilot, 출력 예: 비행기 입력 예: Stewardess, 출력 예: 비행기 입력 : 학생, 출력: LLM 출력: 강의실
3.4.3 ChatPromptTemplate 채팅 프롬프트 템플릿
채팅 메시지를 입력으로 사용하여 완전한 프롬프트 템플릿을 생성합니다.
from langchain.schema import HumanMessage from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate # 우리는 채팅 모델을 사용할 것입니다. 기본값은 gpt-3.5-turbo from langchain.chat_models import ChatOpenAI # 출력을 구문 분석하고 langchain에서 구조화된 데이터를 다시 가져옵니다. .output_parsers import StructuredOutputParser, ResponseSchema import os openai_api_key = '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' chat_model = ChatOpenAI(온도=0, model_name='gpt-3.5-turbo', openai_api_key=openai_api_key) 프롬프트 = 채팅 PromptTemplate( 메시지 =[HumanMessagePromptTemplate.from_template("에 따르면 사용자 콘텐츠에 회사 이름 및 지역 이름 추출, 사용자 콘텐츠 사용: {user_prompt}") ], input_variables=["user_prompt"] ) user_prompt = "Shidi 회사의 본사가 베이징에 있습니까?" Fruit_query = 프롬프트.format_prompt(user_prompt= user_prompt) print( '입력 내용:',fruit_query.messages[0].content)fruit_output = chat_model(fruit_query.to_messages()) print('LLM 출력:',fruit_output)
입력 콘텐츠: 사용자 콘텐츠를 기반으로 회사 이름과 지역 이름을 추출하고 사용자 콘텐츠를 사용합니다. Shuidi 회사의 본사가 베이징에 있습니까? LLM 출력: cnotallow='회사 이름: Shuidi Company\n지역 이름: 베이징' added_kwargs={} example=False
3.4.4 StructuredOutputParser 출력 파서
출력 파서는 모델에서 생성된 결과를 구문 분석하고 처리하는 구성 요소를 나타냅니다. 주요 기능은 모델에서 생성된 텍스트를 구문 분석하고, 유용한 정보를 추출하고, 후속 처리를 수행하는 것입니다. 모델에서 생성된 텍스트를 구문 분석하고, 유용한 정보를 추출하고, 엔터티를 식별하고, 결과를 분류 및 필터링하고, 생성된 텍스트를 후처리하여 생성된 결과를 더 쉽게 이해하고 사용할 수 있도록 하는 등의 작업을 수행합니다. 대규모 언어 모델과 상호작용할 때 결과를 구문 분석하고 처리하는 역할을 하여 모델의 적용성과 유용성을 향상시킵니다.
언어 모델은 텍스트를 출력합니다. 그러나 많은 경우 텍스트보다 더 구조화된 정보를 얻고 싶을 수도 있습니다. 이것이 출력 파서가 하는 일입니다. 즉, 출력 파서는 구조화된 언어 모델의 응답을 돕는 클래스인데, LangChain에서 제공하는 주요 클래스는 PydanticOutputParser이다.
3.5 데이터 연결
문서 로딩, 문서 변환, 텍스트 임베딩 및 벡터 저장을 포함한 외부 데이터 파이프라인을 엽니다. 이 모듈에는 문서 처리, 다양한 유형의 인덱스 및 체인에서 이러한 인덱스의 사용을 위한 유틸리티 기능이 포함되어 있습니다.
외부 데이터와 LLM을 결합하여 자연어를 이해하고 생성할 수 있으며, 외부 데이터는 로컬 문서, 데이터베이스 및 기타 리소스가 될 수 있으며, 이러한 데이터는 슬라이싱 및 벡터화되어 벡터 저장 데이터베이스에 저장된 후 벡터 데이터베이스를 검색합니다. 사용자의 프롬프트를 통해 언어에 포함된 유사한 정보를 대형 언어 모델에 전달하여 액션을 생성하고 실행합니다.
문서 로더
초점은 txt(TextLoader), csv(CSVLoader), html(UnstructuredHTMLLoader), json(JSONLoader), markdown(UnstructuredMarkdownLoader) 및 pdf를 포함합니다(pdf 형식이 더 복잡하기 때문에 PyPDFLoader, MathpixPDFLoader, UnstructuredPDFLoader, PyMuPDF 및 기타 형식은 다음과 같습니다). 로딩 엔진 제공) 일반적으로 사용되는 여러 형식의 콘텐츠 구문 분석.
3.5.2 문서 변환기 문서 변환기
RecursiveCharacterTextSplitter 를 사용하여 문자별로 재귀적으로 분할하는 데 중점을 두고 문서를 쉽게 분할, 결합, 필터링 및 조작할 수 있게 해주는 다양한 내장 문서 변환기가 있습니다.
3.5.3 텍스트 임베딩 모델 텍스트 임베딩
LangChain의 Embeddings 기본 클래스는 문서 삽입을 위한 방법과 쿼리 삽입을 위한 방법의 두 가지 방법을 노출합니다. 전자는 여러 텍스트를 입력으로 사용하는 반면, 후자는 단일 텍스트를 사용합니다. 이를 두 가지 별도의 방법으로 사용하는 이유는 일부 임베딩 공급자가 문서(검색 대상)와 쿼리(검색 쿼리 자체)에 대해 서로 다른 임베딩 방법을 사용하기 때문입니다.
텍스트 임베딩 모델 text-embedding-model은 텍스트를 벡터로 표현하므로 벡터 공간의 텍스트에 대해 의미 검색, 즉 벡터 공간에서 가장 유사한 텍스트 조각을 검색하는 등의 작업을 수행할 수 있습니다. 이는 LangChain의 Embedding 클래스를 통해 구현됩니다.
Embedding 클래스는 텍스트 임베딩과 상호 작용하기 위한 클래스입니다. 이 클래스는 공급자에게 표준 인터페이스를 제공하는 것을 목표로 합니다(OpenAI, Cohere, Hugging Face 등과 같은 임베딩 공급자가 많이 있음).
from langchain.schema import HumanMessage from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate # 우리는 채팅 모델을 사용할 것입니다. 기본값은 gpt-3.5-turbo from langchain.chat_models import ChatOpenAI # 출력을 구문 분석하고 langchain에서 구조화된 데이터를 다시 가져옵니다. .output_parsers import StructuredOutputParser, ResponseSchema import os openai_api_key = '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' chat_model = ChatOpenAI(온도=0, model_name='gpt-3.5-turbo', openai_api_key=openai_api_key) 프롬프트 = 채팅 PromptTemplate( 메시지 =[HumanMessagePromptTemplate.from_template("에 따르면 사용자 콘텐츠에 회사 이름 및 지역 이름 추출, 사용자 콘텐츠 사용: {user_prompt}") ], input_variables=["user_prompt"] ) user_prompt = "Shidi 회사의 본사가 베이징에 있습니까?" Fruit_query = 프롬프트.format_prompt(user_prompt= user_prompt) print( '입력 내용:',fruit_query.messages[0].content)fruit_output = chat_model(fruit_query.to_messages()) print('LLM 출력:',fruit_output)
3.5.4 VectorStores 벡터 저장
구조화되지 않은 데이터를 저장하고 검색하는 가장 일반적인 방법 중 하나는 이를 포함하고 결과 임베딩 벡터를 저장한 다음 쿼리 시 구조화되지 않은 쿼리를 포함하고 포함된 쿼리와 "가장 유사한" 임베딩 벡터를 검색하는 것입니다.
벡터 스토리지는 내장된 데이터를 저장하고 벡터 검색을 수행하는 역할을 담당합니다. . 벡터 저장을 다루는 핵심 부분은 일반적으로 임베딩을 통해 벡터를 저장하는 것입니다. 일반적으로 사용되는 벡터 데이터베이스(Chroma, FAISS, Milvus, Pinecone, PGVector 등)의 Encapsulation 인터페이스에 대한 설명이며 일반적인 프로세스는 데이터베이스 연결 정보 초기화 -> 인덱스 생성 -> 벡터 저장 -> 유사성 쿼리입니다. 다음은 크로마입니다. 예를 들면 다음과 같습니다.
# 파일 로드 loader = TextLoader(filePath) document = loader.load() # 데이터 슬라이스 text_splitter = CharacterTextSplitter( Chunk_size=chunkSize, Chunk_overlap=0, length_functinotallow=len, Separator=separator) Split_docs = text_splitter.split_documents(documents) # 초기 요청 벡터화된 데이터 embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY) # 지속 파일 주소 persist_directory = '/data/' +collectName # 벡터화된 벡터 저장소 실행 = Chroma.from_documents(split_docs, embeddings, persist_directory=persist_directory) # 로컬 벡터 저장소에 지속 .persist()
3.5.5 리트리버 쿼리
검색기는 구조화되지 않은 쿼리를 기반으로 문서를 반환하는 인터페이스입니다. 이는 벡터 저장보다 더 일반적입니다. 검색자는 문서를 저장할 필요가 없으며 문서를 반환(또는 검색)하기만 하면 됩니다. 벡터 저장소는 리트리버의 백본으로 사용될 수 있지만 다른 유형의 리트리버도 있습니다.
검색기 인터페이스는 문서 및 언어 모델을 쉽게 구성할 수 있도록 하는 범용 인터페이스입니다. LangChain에는 쿼리(문자열)를 받아들이고 문서 목록을 반환하는 get_relevant_documents 메서드가 있습니다.
데이터 압축에 초점을 맞춘 목적은 가장 관련성이 높은 텍스트를 얻고 이를 프롬프트 컨텍스트로 가져오는 것입니다. 이를 통해 토큰 소비를 줄일 수 있을 뿐만 아니라 LLM의 출력 품질도 보장할 수 있습니다.
langchain.llms에서 OpenAI 가져오기 langchain.retrievers에서 ContextualCompressionRetriever 가져오기 langchain.retrievers.document_compressors에서 ContextualCompressionRetriever 가져오기 langchain.document_loaders에서 LLMChainExtractor 가져오기 langchain.Vectorstores에서 TextLoader 가져오기 FAISS 문서 가져오기 = TextLoader('../../../state_of_the_union.txt' ).load() text_splitter = CharacterTextSplitter(chunk_size=1000, Chunk_overlap=0) texts = text_splitter.split_documents(documents) 검색자 = FAISS.from_documents(texts, OpenAIEmbeddings()).as_retriever() docs = 검색자.get_relevant_documents("무엇을 했는지 the President say about Ketanji Brown Jackson") # 기본 검색에서는 관련 문서 한두 개와 관련 없는 문서가 반환됩니다. 관련 문서에도 관련 없는 정보가 많이 있습니다. Pretty_print_docs(docs) llm = OpenAI(온도=0 ) 압축기 = LLMChainExtractor. from_llm(llm) # 처음 반환된 문서를 반복하고 각 문서에서 쿼리와 관련된 콘텐츠만 추출 브라운') beautiful_print_docs(compressed_docs)
3.5.6 임베딩 캐싱 임베딩 캐싱
임베딩을 다시 계산할 필요가 없도록 임베딩을 저장하거나 임시로 캐시할 수 있습니다. 캐시 임베딩은 CacheBackedEmbeddings를 사용하여 수행할 수 있습니다.
3.5.7 메모리
메모리는 사용자와 언어 모델의 상호 작용 전반에 걸쳐 상태를 유지하는 개념입니다. 이는 일련의 채팅 메시지에서 지식을 수집, 캡처, 변환 및 추출하는 사용자와 언어 모델 간의 대화형 채팅 메시지 프로세스에 반영됩니다. 메모리는 체인/에이전트 호출 간의 상태를 유지합니다. 기본적으로 체인과 에이전트는 상태가 없으므로 들어오는 각 쿼리를 독립적으로 처리하지만 챗봇과 같은 일부 애플리케이션에서는 단기 및 장기적으로 이전 상호 작용을 기억하는 것이 중요합니다. . 이를 실현하기 위한 것이 '메모리'의 개념이다.
메모리 저장 구성 요소를 사용하는 방법에는 두 가지가 있는데, 하나는 이전 채팅 메시지를 관리하고 운영하기 위한 보조 도구를 제공하여 메시지 시퀀스에서 정보를 추출하는 것이고, 다른 하나는 이를 체인의 상관 관계에 사용하는 것입니다. 메모리는 마지막 N개 메시지 또는 모든 이전 메시지의 요약과 같은 여러 정보를 반환할 수 있습니다. 반환된 정보는 문자열이거나 메시지 목록일 수 있습니다.
LangChain은 채팅 기록, 버퍼 메모리 및 체인에서 메모리 정보를 추출하기 위한 메소드 클래스와 인터페이스를 제공합니다. ChatMessageHistory 클래스는 인간 메시지와 AI 메시지를 저장한 다음 Get에서 추출하는 몇 가지 편리한 방법을 제공하는 초경량 래퍼입니다. 또 다른 예로는 ChatMessageHistory의 래퍼이고 변수 등에서 메시지를 추출하는 데 사용되는 ConversationBufferMemory 클래스가 있습니다.
from langchain.memory import ChatMessageHistory from langchain.chat_models import ChatOpenAI import os openai_api_key=os.environ["OPENAI_API_KEY"] chat = ChatOpenAI(온도=0, openai_api_key=openai_api_key) # 진술 기록 기록 = ChatMessageHistory() History.add_user_message("you 짧은 문장으로 여행할 곳을 알려주는 좋은 AI 로봇입니다.") History.add_user_message("나는 해변을 좋아하는데 어디로 갈까?") # AI 언어 추가 Shenzhen, Guangdong") # 인간 언어 추가 History.add_user_message("거기에 있는 동안 또 무엇을 해야 하나요?") print('history message:', History.messages) # 호출 모델 ai_response = chat(history.messages ) print('result', ai_response) # AI 언어 추가 계속 History.add_ai_message(ai_response.content) print('history message:', History.messages) # 인간 언어 추가 계속 History.add_user_message("음식 및 쇼핑 장소 추천 ") ai_response = chat(history.messages) print('result', ai_response)
3.5.8 체인
일반적으로 별도의 LLM을 사용하여 문제를 해결할 수 있지만, 보다 복잡한 응용 프로그램의 경우 LLM 간을 연결하거나 다른 시스템과 연결하여 작업을 완료해야 하는데, 이를 일반적으로 연결 LLM이라고 합니다.
체인을 사용하면 모델이나 시스템 간의 여러 구성 요소를 결합하여 일관된 단일 애플리케이션을 만들 수 있습니다. 예를 들어, 사용자의 입력을 받아들이고 PromptTemplate 템플릿을 통해 입력 형식을 지정하고 이를 LLM 언어 모델에 전달하는 체인을 만듭니다. 여러 체인을 결합할 수도 있고, 체인을 다른 시스템 구성 요소와 결합하여 더 복잡한 체인을 구축하고 더 강력한 기능을 달성할 수도 있습니다. LangChain은 표준 인터페이스와 체인에 대한 공통 구현을 제공하고, 다른 도구와 광범위하게 통합되며, 공통 애플리케이션을 위한 엔드투엔드 체인을 제공합니다.
기본 시퀀스 체인:
from langchain.llms import OpenAI from langchain.chains import LLMChain from langchain.prompts import PromptTemplate from langchain.chains import SimpleSequentialChain import os openai_api_key = os.environ["OPENAI_API_KEY"] llm = OpenAI(온도=1, openai_api_key=openai_api_key) # 아니요 A 체인 템플릿 content template1 = "사용자가 입력한 설명, 사용자 입력에 따라 적합한 지역 추천: {value}" 프롬프트_template1 = PromptTemplate(input_variables=["value"], template=template1) # 첫 번째 체인 구축 chain1 = LLMChain(llm=llm, 프롬프트=prompt_template1) # 두 번째 체인 템플릿 콘텐츠 template2 = "사용자가 입력한 지역을 기준으로 해당 지역의 음식을 추천합니다. 사용자 입력: {value}" 프롬프트_template2 = PromptTemplate(input_variables=[ "value" ], template=template2) # 두 번째 체인 구축 chain2 = LLMChain(llm=llm, 프롬프트=prompt_template2) # 체인 조립overall_chain = SimpleSequentialChain(chains=[chain1, chain2], verbose=True) # 체인 검토 실행 =overall_chain.run("중국 바다를 보고 싶어요") print('결과:', review)
LangChain.prompts에서 가져오기 LangChain.llms에서 PromptTemplate 가져오기 LangChain.chains에서 OpenAI 가져오기 LLMChain llm = OpenAI(온도=0.9) 프롬프트 = PromptTemplate( input_variables=["product"], template=" 다음에 대한 새 이름을 찾는 데 도움을 주세요. {제품}을 만드는 회사는요?", ) chain = LLMChain(llm=llm, Prompt=prompt) print(chain.run("superphone"))
위의 예에서 템플릿 형식을 통해 사용자 입력을 받아들이고 이를 언어 모델에 전달하는 것은 LangChain의 LLMChain 클래스와 같은 간단한 체인 클래스를 통해 구현할 수 있습니다. 프롬프트 템플릿을 받아들이고, 사용자 입력으로 형식을 지정하고, LLM의 응답을 반환하는 간단한 체인입니다. 물론 LLMChain은 채팅 모델에서도 사용할 수 있습니다.
3.5.9 에이전트
일반적으로 사용자의 문제는 관련 작업을 완료하기 위해 응용 프로그램의 여러 논리적 처리가 필요할 수 있으며, 종종 동적이어서 다양한 사용자 입력에 따라 다양한 작업이 필요하거나 다양한 LLM 출력을 기반으로 다양한 작업이 실행될 수 있습니다. 따라서 애플리케이션은 LLM 및 기타 도구 호출 체인을 미리 결정해야 할 뿐만 아니라 다양한 사용자 입력을 기반으로 다양한 체인을 생성해야 할 수도 있습니다. 프록시를 사용하면 LLM 액세스 도구를 보다 직접적이고 효율적으로 만들 수 있습니다. 도구는 무한한 가능성을 제공합니다. LLM은 네트워크 검색, 수학적 계산 수행, 코드 실행 및 기타 관련 기능을 수행할 수 있습니다.
에이전트는 LLM을 사용하여 수행할 작업과 순서를 결정하고 관찰 내용을 검토하며 작업이 완료될 때까지 반복합니다. LangChain 라이브러리는 사전 구축된 다수의 도구를 제공하며 기존 도구를 수정하거나 새 도구를 생성할 수도 있습니다. 프록시를 올바르게 사용하면 매우 강력해질 수 있습니다. LangChain에서는 "에이전트"라는 개념을 사용하여 이러한 유형의 체인에 있는 일련의 도구에 액세스하여 작업을 완료합니다. 사용자 입력에 따라 에이전트는 이러한 도구를 호출할지 여부를 결정할 수 있습니다. 다음은 간단한 예입니다.
#에이전트 제어에 사용할 언어 모델 로드 llm = OpenAI(온도=0); #serpapi, llm-math 등 사용해야 하는 일부 도구 로드 llm-math 도구에는 LLM tools = load_tools( ["serpapi" , "llm-math"], llm=llm) # 도구, 언어 모델 및 에이전트 유형을 사용하여 에이전트를 초기화합니다. 에이전트 = 초기화_agent(tools, llm, 에이전트=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True) #제어 에이전트 실행 에이전트.run("빈 디젤의 여자친구는 누구입니까? 현재 나이를 0.5승으로 올려보면 몇 살입니까?")
3.5.10 콜백
LangChain은 LLM 지원서의 다양한 단계에 연결할 수 있는 콜백 시스템을 제공합니다. 이는 로깅, 모니터링, 스트리밍 및 기타 작업에 유용합니다.
API 전체에서 사용 가능한 매개변수를 사용하여 이러한 이벤트를 구독할 수 있습니다. 인수는 아래에 자세히 설명된 하나 이상의 메서드를 구현할 것으로 예상되는 핸들러 개체의 목록입니다.
4. LangChain을 사용하여 Huawei Cloud Platform ModelArts에서 엔드투엔드 언어 모델 애플리케이션을 빠르게 구축하는 방법
예비 준비:
1. Huawei Cloud 공식 계정 에 로그인합니다 .
오른쪽 상단에 있는 "Console"을 클릭하고 검색창에 "ModelArts"를 입력하세요.
"개발 환경" - "노트북", "만들기"를 클릭하세요.
노트북을 생성하려면 "notebook-LangChain"이라는 이름을 입력하고 GPU 사양을 선택하고 "GPU: 1*T4 (16GB) | CPU: 8 core 32GB"를 선택한 다음 "지금 만들기"를 클릭하고 디스크 사양 "50G"를 선택한 다음 클릭합니다. "만들다"
클릭하여 "작업 센터"로 돌아가고 노트북을 클릭하여 들어갑니다.
1. 랭체인 설치
먼저 LangChain을 설치하세요. 다음 명령을 실행하면 됩니다.
!pip 설치 랭체인
색인 보기: http://repo.myhuaweicloud.com/repository/pypi/simple
langchain 수집
다운로드 http://repo.myhuaweicloud.com/repository/pypi/packages/1f/fd/f2aa39f8e63a6fbacf2e7be820b846c27b1e5830af9c2e2e208801b6c07f/ 랭체인-0.0.27- py3-none-any.whl (124 kB)
|████████████████████████████████| 124 kB 49.0 MB/s eta 0:00:01
sqlalchemy 수집
다운로드 중 http://repo.myhuaweicloud.com/repository/pypi/packages/ac/d8/51e617a1eb143a48ab2dceb194afe40b3c42b785723a031cc29a8c04103d/SQLAlchemy -2.0.20-cp37-cp37m- manylinux_2_17_x86_64.manylinux2014_x86_64 .whl (2.9MB)
|████████████████████████████████| 2.9MB 30.8MB/s eta 0:00:01
요구 사항이 이미 충족됨: /home/ma-user/anaconda3/envs/PyTorch-1.8/lib/python3.7/site-packages의 numpy(langchain에서)(1.19.5 )
요구 사항이 이미 충족됨: /home/ma-user/anaconda3/envs/PyTorch-1.8/lib/python3.7/site-packages의 pyyaml(langchain에서)(5.1)
요구 사항이 이미 충족됨: /home/ma-user의 요청 /anaconda3/envs/PyTorch-1.8/lib/python3.7/site-packages (langchain에서) (2.27.1)
pydantic 수집
다운로드 http://repo.myhuaweicloud.com/repository/pypi/packages/fd/35/ 86b1e7571e695587df0ddf2937100436dce0caa277d2f016d4e4f7d3791a/pydantic-2.2.1-py3-none-any.whl (373 kB)
|██████████████████████████████ ██| 373 kB 55.0 MB/s 에타 0:00:01
입력 확장 수집 중>=4.6.1
http://repo.myhuaweicloud.com/repository/pypi/packages/38/60/300ad6f93adca578bf05d5f6cd1d854b7d140bebe2f9829561aa9977d 다운로드 중 9f3 /typing_extensions-4.6.2- py3-none-any.whl (31 kB)
pydantic-core 수집 ==2.6.1
http://repo.myhuaweicloud.com/repository/pypi/packages/c0/ca/4cf24afe80f5839a5cad5e35e2a0a11fe41b0f4f6a544109f73337567579/pydantic 다운로드 _core -2.6.1-cp37 -cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.9MB)
|████████████████████████████████| 1.9MB 38.3MB/s 에타 0:00:01
주석 유형 수집>=0.4.0
다운로드 http://repo.myhuaweicloud.com/repository/pypi/packages/d8/f0/a2ee543a96cc624c35a9086f39b1ed2aa403c6d355dfe47a11ee5c64a 164 /annotated_types-0.5.0- py3-none-any.whl (11 kB)
요구 사항이 이미 충족되었습니다: /home/ma-user/anaconda3/envs/PyTorch-1.8/lib/python3.7/site-packages의 urllib3<1.27,>=1.21.1( 요청에서->langchain)(1.26.12)
요구 사항이 이미 충족되었습니다: /home/ma-user/anaconda3/envs/PyTorch-1.8/lib/python3.7/site-packages의 certifi>=2017.4.17(요청에서- >langchain) (2022.9.24)
요구 사항이 이미 충족됨: /home/ma-user/anaconda3/envs/PyTorch-1.8/lib/python3.7/site-packages의 charset-normalizer~=2.0.0(요청에서-> 랭체인) (2.0.12)
요구 사항이 이미 충족됨: /home/ma-user/anaconda3/envs/PyTorch-1.8/lib/python3.7/site-packages의 idna<4,>=2.5(요청->langchain에서)(3.4)
그린렛 수집!=0.4.17
http://repo.myhuaweicloud.com/repository/pypi/packages/1a/ed/72998fb3609f6c4b0817df32e2b98a88bb8510613d12d495bbab8534ebd0/greenlet-2.0.1-cp37-cp37m-manylinux_2_17_x86_64 다운로드. Manylinux2014_x86_64.whl (514 kB)
|███████ █████████████████████████ | 514kB 12.0MB/초 에타 0:00:01
2.환경설정
Jupyter Notebook 또는 Python 스크립트에서 작업하면 다음과 같은 환경 변수를 설정할 수 있습니다.
import os os .environ[ "OPENAI_API_KEY" ] = "..."
언어 모델 애플리케이션 구축: LLM
LangChain을 설치하고 환경을 설정한 후 언어 모델 애플리케이션 구축을 시작할 수 있습니다. LangChain은 언어 모델 애플리케이션을 만드는 데 사용할 수 있는 다양한 모듈을 제공합니다. 더 복잡한 애플리케이션을 위해 이러한 모듈을 결합하거나 더 간단한 애플리케이션을 위해 개별적으로 사용할 수 있습니다.
언어 모델 애플리케이션 구축: 채팅 모델
LLM 외에도 채팅 모델을 사용할 수도 있습니다. 이는 내부적으로 언어 모델을 사용하지만 인터페이스가 다른 언어 모델의 변형입니다. 채팅 모델은 "텍스트 입력, 텍스트 출력" API 대신 채팅 메시지를 입력 및 출력으로 사용합니다. 채팅 모델 API의 사용은 여전히 상대적으로 새로운 것이므로 모든 사람들은 여전히 추상화를 사용하는 가장 좋은 방법을 찾고 있습니다.
채팅을 완료하려면 하나 이상의 메시지를 채팅 모델에 전달해야 합니다. LangChain은 현재 AIMessage, HumanMessage, SystemMessage 및 ChatMessage 유형을 지원합니다. 주로 HumanMessage, AIMessage, SystemMessage를 사용하게 됩니다. 다음은 채팅 모델을 사용하는 예입니다.
langchain.chat_models에서 ChatOpenAI 가져오기
langchain.schema 가져오기(
AIMessage,
HumanMessage,
SystemMessage
)
chat = ChatOpenAI(온도=0)
메시지를 전달하여 이를 수행할 수 있습니다.
chat([HumanMessage(content="이 문장을 영어에서 프랑스어로 번역하세요. 저는 프로그래밍을 좋아합니다.")])
# -> AIMessage(content="J'aime 프로그래머.", extra_kwargs={})
또는 OpenAI의 gpt-3.5-turbo 및 gpt-4 모델에 여러 메시지를 전달합니다.
message = [
SystemMessage(content="당신은 영어를 중국어로 번역하는 유용한 도우미입니다."),
HumanMessage(content="이 문장을 영어에서 중국어로 번역해 주세요. 저는 프로그래밍을 좋아합니다.")
]
chat(messages)
# -> AIMessage (content="我喜欢编程。(Wēxīhuān biānchéng.)", added_kwargs={})
생성을 사용하여 여러 메시지 세트에 대한 완성을 생성할 수도 있습니다. 이는 추가 메시지 매개변수와 함께 LLMResult를 반환합니다.
bat_messages = [
[
SystemMessage(content="당신은 영어를 중국어로 번역하는 유용한 도우미입니다."),
HumanMessage(content="이 문장을 영어에서 중국어로 번역해 주세요. 저는 프로그래밍을 좋아합니다.") ]
,
[
SystemMessage(content=" 당신은 영어를 중국어로 번역해주는 유용한 조수입니다."),
HumanMessage(content="이 문장을 영어에서 중국어로 번역하세요. 인공지능을 좋아합니다.") ]
,
]
result = chat.generate(batch_messages)
result
# -> LLMResult (generations=[[ChatGeneration(text="저는 프로그래밍을 좋아합니다. (Wūxūxhuān biānchéng.)", Generation_info=None, message=AIMessage(content="저는 프로그래밍을 좋아합니다. (Wūxūxhuān biānchéng.)", extra_kwargs={}) )], [ChatGeneration(text="나는 인공지능을 좋아합니다. (Wūxī'ài rén gōng zhì néng.)", Generation_info=None, message=AIMessage(content="나는 인공지능을 좋아합니다. (Wūxī'ài rén gōng) ) zhì néng.)", extra_kwargs={}))]], llm_output={'token_usage': {'prompt_tokens': 71, 'completion_tokens': 18, 'total_tokens': 89}})
LLMResult에서 토큰 사용 및 기타 정보를 추출할 수도 있습니다.
result.llm_output['token_usage']
# -> {'prompt_tokens': 71, 'completion_tokens': 18, 'total_tokens': 89}
채팅 모델의 경우 MessagePromptTemplate을 사용하여 템플릿을 사용할 수도 있습니다. 하나 이상의 MessagePromptTemplate에서 ChatPromptTemplate을 생성할 수 있습니다. ChatPromptTemplate의 format_prompt 메소드는 형식화된 값을 LLM 또는 채팅 모델에 대한 입력으로 사용할지 여부에 따라 문자열 또는 메시지 객체로 변환할 수 있는 PromptValue를 반환합니다.
예는 다음과 같습니다.
from langchain.chat_models import ChatOpenAI
from langchain.prompts.chat import (
ChatPromptTemplate,
SystemMessagePromptTemplate,
HumanMessagePromptTemplate,
)
chat = ChatOpenAI(온도=0)
template="당신은 {input_언어}를 {output_언어}로 번역하는 유용한 도우미입니다."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template="{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])
# 형식화된 메시지에서 채팅 완료 가져오기
chat(chat_prompt.format _프롬프트( input_랭귀지="영어", 출력_언어="중국어", text="저는 프로그래밍을 좋아합니다.").to_messages()) # -> AIMessage(content="我喜欢编程。
(Wēxīhuān biānchéng.)", extra_kwargs={} )
채팅 모델과 함께 LLMChain을 사용할 수도 있습니다.
from langchain.chat_models import ChatOpenAI
from langchain import LLMChain
from langchain.prompts.chat import (
ChatPromptTemplate,
SystemMessagePromptTemplate,
HumanMessagePromptTemplate,
)
chat = ChatOpenAI(온도=0)
template="당신은 {input_언어}를 {output_언어}로 번역하는 유용한 도우미입니다. ."
system_message_prompt = SystemMessagePromptTemplate.from_template(템플릿)
human_template="{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])
chain = LLMChain(llm=chat, 프롬프트=chat_promp t)
체인.런 (input_랭귀지="영어", 출력_언어="중국어", text="저는 프로그래밍을 좋아합니다.")
# -> "我喜欢编程。(Wēxīhuān biānchéng.)"
채팅 모델과 함께 에이전트를 사용할 수도 있습니다. AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION을 에이전트 유형으로 사용하여 에이전트 초기화
from langchain.agents import load_tools
from langchain.agents import 초기화_agent
from langchain.agents import AgentType
from langchain.chat_models import ChatOpenAI
from langchain.llms import OpenAI
# 먼저 에이전트를 제어하는 데 사용할 언어 모델을 로드해 보겠습니다.
chat = ChatOpenAI(온도=0)
# 다음으로 사용할 몇 가지 도구를 로드해 보겠습니다. `llm-math` 도구는 LLM을 사용하므로 이를 전달해야 합니다.
llm = OpenAI(온도=0)
tools = load_tools(["serpapi", "llm-math"], llm=llm)
# 마지막으로 사용하려는 도구, 언어 모델 및 에이전트 유형을 사용하여 에이전트를 초기화해 보겠습니다.
에이전트 = 초기화_agent(tools, chat, Agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
# 이제 테스트해 보겠습니다!
agent.run("올리비아 와일드의 남자친구는 누구입니까? 그의 현재 나이를 0.23승으로 올리면 몇 살입니까?")
이 예에서 에이전트는 최종 답변을 제공하기 위해 대화형으로 검색 및 계산을 수행합니다.
마지막으로 채팅 모델로 초기화된 체인 및 프록시와 함께 메모리를 사용하는 방법을 살펴보겠습니다. 이것과 LLM용 메모리의 주요 차이점은 이전 메시지를 문자열로 압축하는 대신 고유한 메모리 개체로 유지할 수 있다는 것입니다.
다음은 ConversationChain을 사용하는 예입니다.
langchain.prompts에서 가져오기(
ChatPromptTemplate,
MessagesPlaceholder,
SystemMessagePromptTemplate,
HumanMessagePromptTemplate
)
langchain.chains에서 가져오기 ConversationChain
langchain.chat_models에서 ChatOpenAI 가져
오기 langchain.memory에서 ChatOpenAI 가져오기 ConversationBufferMemory
프롬프트 = ChatPromptTemplate.from_messages([
SystemMessagePromptTemplate.from_template("다음은 친근한 대화 인간과 AI 사이에 존재합니다. AI는 수다스럽고 맥락에서 많은 구체적인 세부정보를 제공합니다. AI가 질문에 대한 답을 모른다면 진실로 모른다고 말합니다."), MessagesPlaceholder(variable_name="
history "),
HumanMessagePromptTemplate.from_template("{input}")
])
llm = ChatOpenAI(온도=0)
memory = ConversationBufferMemory(return_messages=True)
대화 = ConversationChain(memory=memory, 프롬프트=프롬프트, llm=llm)
대화.예측 (input="안녕하세요!")
# -> '안녕하세요! 오늘은 어떻게 도와드릴까요?'
대화.predict(input="잘 지내요! AI와 대화하는 것만으로도 충분합니다.")
# -> "재밌을 것 같네요! 대화하게 되어 기쁘네요. 특별히 하고 싶은 말이 있으신가요? 에 대해 이야기하다?"
대화.predict(input="자신에 대해 말해 보세요.")
# -> "물론이죠! 저는 OpenAI에서 만든 AI 언어 모델입니다. 저는 인터넷의 대규모 텍스트 데이터 세트에 대해 교육을 받았는데, 이를 통해 이해하고 생성할 수 있습니다. 인간과 같은 언어를 사용합니다. 질문에 답하고, 정보를 제공하고, 심지어 이런 대화도 나눌 수 있습니다. 저에 대해 더 알고 싶은 것이 있나요?"
이 예에서는 aConversationChain을 사용하여 AI와의 여러 상호 작용에서 대화 컨텍스트를 유지합니다.
그게 다야! 이제 LangChain을 사용하여 엔드투엔드 언어 모델 애플리케이션을 구축하는 방법을 심층적으로 이해했습니다. 이러한 예제를 따르면 LLM, 채팅 모델, 에이전트, 체인 및 메모리 기능을 사용하여 강력한 언어 모델 애플리케이션을 개발할 수 있습니다.
결론적으로
요약하면 LangChain은 모듈식이며 유연한 접근 방식을 제공하여 고급 언어 모델 애플리케이션 구축 프로세스를 단순화하는 강력한 프레임워크입니다. 구성 요소, 체인, 프롬프트 템플릿, 출력 파서, 인덱스, 검색기, 채팅 메시지 기록 및 프록시와 같은 핵심 개념을 이해함으로써 특정 요구 사항에 맞는 사용자 정의 솔루션을 만들 수 있습니다. LangChain의 적응성과 사용 용이성은 개발자에게 귀중한 도구가 되어 언어 모델의 잠재력을 최대한 활용하고 광범위한 사용 사례에 걸쳐 지능적인 상황 인식 애플리케이션을 만들 수 있도록 해줍니다.
참고자료
- https://python.langchain.com/docs/get_started/introduction.html
- https://blog.csdn.net/crystal_csdn8/article/details/131753160?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522169163537516800184147830%2522%252C%2522scm%2 522%253A%252220140713.130102334.pc%255Fall.% 2522%257D&request_id=169163537516800184147830&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v1~rank_v31_ecpm-22-131753160-null-null.142^v92^ins ert_down1&utm_term=langchain&spm=1018.2226.3001.4187
- https://blog.csdn.net/qq_43692950/article/details/131359743?ops_request_misc=&request_id=&biz_id=102&utm_term=langchain&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-131359743. 없음&spm=1018.2226.3001.4187
- https://www.bilibili.com/video/BV1vX4y127v4/?spm_id_from=333.788&vd_source=288508e12cf774ee9ad65190776756be
- https://www.bilibili.com/video/BV1GL411e7K4/?spm_id_from=333.337.search-card.all.click&vd_source=288508e12cf774ee9ad65190776756be
관련 벡터 데이터베이스:
- https://www.bilibili.com/video/BV11a4y1c7SW/?spm_id_from=333.337.search-card.all.click&vd_source=288508e12cf774ee9ad65190776756be
- https://www.bilibili.com/video/BV1BM4y177Dk/?spm_id_from=333.788.recommend_more_video.-1&vd_source=288508e12cf774ee9ad65190776756be
클릭 하시면 화웨이 클라우드의 신기술을 빠르게 팔로우하고 배우실 수 있습니다 ~
Alibaba Cloud가 심각한 장애를 겪고 모든 제품이 영향을 받음(복원) Tumblr는 러시아 운영 체제 Aurora OS 5.0을 냉각시켰습니다 . 새로운 UI는 Delphi 12 & C++ Builder 12, RAD Studio 12를 공개했습니다 . 많은 인터넷 회사들이 Hongmeng 프로그래머를 긴급 채용합니다. UNIX 시간 17억 시대를 앞두고 있다.(이미 돌입했다.) 메이투안은 병력을 모집해 홍몽 시스템 앱을 개발할 계획이다. 아마존은 리눅스 기반의 운영체제인 .NET 8에 대한 안드로이드의 의존성을 없애기 위해 리눅스 기반 운영체제를 개발한다 . 독립 규모는 50% 감소 FFmpeg 6.1 "Heaviside" 출시