Hur lägger man till minne till en kedja med flera ingångar i LangChain?

Chatbots och stora språkmodeller används av miljoner över hela världen och dessa modeller kan generera text på kommando. LangChain är ett av de mest effektiva och effektiva ramverken som gör det möjligt för utvecklare att bygga sådana modeller och bots. Användaren ger uppmaningar eller frågor som input och modellen förstår kommandot innan den genererar den text som verkar mest relaterad eller som kommandot.

Denna guide kommer att illustrera processen att lägga till minne till en kedja med flera ingångar i LangChain.

Hur lägger man till minne till en kedja med flera ingångar i LangChain?

Minnet kan läggas till LLM:erna eller chatbotarna för att lagra de senaste meddelandena eller data så att modellen kan förstå kommandots sammanhang. För att lära dig processen att lägga till minne till en kedja med flera ingångar i LangChain, gå helt enkelt igenom följande steg:

Steg 1: Installera moduler

Installera först LangChain-ramverket eftersom det har en mängd olika beroenden för att bygga språkmodeller:

pip installera langkedja

Installera chromadb för att lagra data som används av minnet i Chroma vektorlagret:

pip installera chromadb

Tiktoken är tokenizern som används för att skapa små bitar av stora dokument så att de enkelt kan hanteras:

pip installera tiktoken

OpenAI är modulen som kan användas för att bygga kedjor och LLM med OpenAI()-metoden:

pip installera openai

Steg 2: Konfigurera miljö och ladda upp data

Nästa steg efter installation av alla nödvändiga moduler för denna process är sätta upp miljön med API-nyckeln från OpenAI-kontot:

importera du
importera getpass

du . ungefär [ 'OPENAI_API_KEY' ] = getpass . getpass ( 'OpenAI API Key:' )

Ladda upp dokumenten med hjälp av filbiblioteket för att bygga kedjorna i LangChain-ramverket:

från Google. ET AL importera filer

laddat upp = filer. ladda upp ( )

Steg 3: Importera bibliotek

När dokumentet har laddats upp, importerar du helt enkelt de nödvändiga biblioteken från Langchain-modulen:

från långkedja. inbäddningar . openai importera OpenAIE-inbäddningar

från långkedja. inbäddningar . sammanhänga importera CohereInbäddningar

från långkedja. text_splitter importera CharacterTextSplitter

från långkedja. vektorbutiker . elastic_vector_search importera ElasticVectorSearch

från långkedja. vektorbutiker importera Chroma

från långkedja. läkare . dokumentera importera Dokumentera

Steg 4: Bygg minne med Chroma Database

Börja nu bygga vektorutrymmet för att lagra inbäddningarna och tokens för dokumentet som laddats upp tidigare:

med öppen ( 'state_of_the_union.txt' ) som f:
state_of_the_union = f. läsa ( )
text_splitter = CharacterTextSplitter ( chunk_size = 1000 , chunk_overlap = 0 )
texter = text_splitter. split_text ( state_of_the_union )

inbäddningar = OpenAIE-inbäddningar ( )

Konfigurera Chroma-databasen för att lagra text och inbäddningar från dokumentet:

docsearch = Chroma. from_texts (

texter , inbäddningar , metadata = [ { 'källa' : i } för i i räckvidd ( endast ( texter ) ) ]

)

Testa minnet genom att fråga kommandot i frågevariabeln och kör sedan metoden similarity_search():

fråga = 'När bildades Nato'

docs = docsearch. likhetssökning ( fråga )

Steg 5: Konfigurera promptmall

Det här steget förklarar processen för att konfigurera mallen för uppmaningarna genom att importera följande bibliotek:

från långkedja. kedjor . fråga_svara importera load_qa_chain

från långkedja. llms importera OpenAI

från långkedja. uppmaningar importera PromptMall

från långkedja. minne importera ConversationBufferMemory

Efter det konfigurerar du helt enkelt mallen eller strukturen för frågan och kör kedjan när minnet har lagts till i modellen:

mall = '''Du är en modell som pratar med en människa
Med tanke på de bitar som extraherats från ett långt dokument och en fråga, skapa ett slutligt svar

{sammanhang}

{histo}
Människan: {input}
Chatbot:'''

prompt = PromptMall (
input_variables = [ 'historia' , 'inmatning' , 'sammanhang' ] , mall = mall
)
minne = ConversationBufferMemory ( minnesnyckel = 'historia' , input_key = 'inmatning' )
kedja = load_qa_chain (
OpenAI ( temperatur = 0 ) , chain_type = 'grejer' , minne = minne , prompt = prompt
)

Steg 6: Testa minnet

Här är det dags att testa modellen genom att ställa frågan med hjälp av frågevariabeln och sedan köra metoden chain() med dess parametrar:

fråga = 'När bildades Nato'

kedja ( { 'input_documents' : docs , 'inmatning' : fråga } , return_only_outputs = Sann )

Skriv ut data som lagrats i buffertminnet eftersom svaret som ges av modellen nyligen lagras i minnet:

skriva ut ( kedja. minne . buffert )

Det handlar om att lägga till minne till en kedja med flera ingångar i LangChain.

Slutsats

För att lägga till minne till en kedja med flera ingångar i LangChain, installera helt enkelt modulerna och vektorlagringen för att lagra text och inbäddningar. Därefter laddar du upp data/dokument från det lokala systemet och importerar sedan de nödvändiga biblioteken för att lagra data för att bygga minnet för LLM. Konfigurera promptmallen för att lagra de senaste meddelandena i buffertminnet och skicka sedan ett sms till kedjan. Den här guiden har utvecklat processen att lägga till minne till en kedja med flera ingångar i LangChain.

Hur lägger man till minne till en kedja med flera ingångar i LangChain?