Hvordan bruke samtalesammendrag i LangChain?

LangChain er rammeverket som kan brukes til å bygge språkmodeller ved å bruke den enorme mengden treningsdatasett bygget på naturlige språk. LangChain gir bibliotekene og avhengighetene som kan brukes til å bygge og administrere chatboter og språkmodeller som LLM-er. Disse modellene regnes for det meste som maskiner for å ha en samtale med eller trekke ut noe informasjon basert på spørsmål skrevet på menneskelignende språk.

Denne veiledningen vil illustrere prosessen med å bruke et samtalesammendrag i LangChain.

Hvordan bruke samtalesammendrag i LangChain?

LangChain tilbyr biblioteker som ConversationSummaryMemory som kan trekke ut hele sammendraget av chatten eller samtalen. Den kan brukes til å få hovedinformasjonen til samtalen uten å måtte lese alle meldingene og teksten som er tilgjengelig i chatten.

For å lære prosessen med å bruke samtalesammendraget i LangChain, gå ganske enkelt inn i følgende trinn:

Trinn 1: Installer moduler

Installer først LangChain-rammeverket for å få avhengighetene eller bibliotekene ved å bruke følgende kode:

pip installer langkjede

Installer nå OpenAI-modulene etter å ha installert LangChain ved å bruke pip-kommandoen:

pip installer openai

Etter å ha installert modulene, ganske enkelt sette opp miljøet bruke følgende kode etter å ha hentet API-nøkkelen fra OpenAI-kontoen:

import du

import få pass

du . omtrent [ 'OPENAI_API_KEY' ] = få pass . få pass ( 'OpenAI API Key:' )

Trinn 2: Bruke samtalesammendrag

Kom inn i prosessen med å bruke samtalesammendraget ved å importere bibliotekene fra LangChain:

fra langkjede. hukommelse import SamtaleoppsummeringMinne , ChatMessageHistory

fra langkjede. llms import OpenAI

Konfigurer minnet til modellen ved å bruke metodene ConversationSummaryMemory() og OpenAI() og lagre dataene i den:

hukommelse = SamtaleoppsummeringMinne ( llm = OpenAI ( temperatur = 0 ) )

hukommelse. lagre_kontekst ( { 'inngang' : 'Hallo' } , { 'produksjon' : 'hei' } )

Kjør minnet ved å ringe load_memory_variables() metode for å trekke ut data fra minnet:

hukommelse. load_memory_variables ( { } )

Brukeren kan også få dataene i form av samtale som hver enhet med en separat melding:

hukommelse = SamtaleoppsummeringMinne ( llm = OpenAI ( temperatur = 0 ) , return_messages = ekte )

hukommelse. lagre_kontekst ( { 'inngang' : 'Hallo' } , { 'produksjon' : 'Hei, hvordan har du det' } )

For å få meldingen til AI og mennesker hver for seg, utfør load_memory_variables()-metoden:

hukommelse. load_memory_variables ( { } )

Lagre sammendraget av samtalen i minnet og utfør minnet for å vise sammendraget av chatten/samtalen på skjermen:

meldinger = hukommelse. chat_memory . meldinger

forrige_sammendrag = ''

hukommelse. forutsi_ny_sammendrag ( meldinger , forrige_sammendrag )

Trinn 3: Bruke samtalesammendrag med eksisterende meldinger

Brukeren kan også få sammendraget av samtalen som eksisterer utenfor klassen eller chatte ved å bruke ChatMessageHistory()-meldingen. Disse meldingene kan legges til minnet slik at det automatisk kan generere sammendraget av hele samtalen:

historie = ChatMessageHistory ( )

historie. add_user_message ( 'hei' )

historie. add_ai_message ( 'Hei der!' )

Bygg modellen som LLM ved å bruke OpenAI()-metoden for å kjøre de eksisterende meldingene i chat_memory variabel:

hukommelse = SamtaleoppsummeringMinne. fra_meldinger (
llm = OpenAI ( temperatur = 0 ) ,
chat_memory = historie ,
return_messages = ekte
)

Kjør minnet ved å bruke bufferen for å få sammendraget av de eksisterende meldingene:

hukommelse. buffer

Utfør følgende kode for å bygge LLM ved å konfigurere bufferminnet ved å bruke chat-meldingene:

hukommelse = SamtaleoppsummeringMinne (
llm = OpenAI ( temperatur = 0 ) ,
buffer = '''Mennesket spør maskinen spør om seg selv
Systemet svarer at AI er bygd for godt da det kan hjelpe mennesker til å oppnå sitt potensial''' ,
chat_memory = historie ,
return_messages = ekte
)

Trinn 4: Bruke samtalesammendrag i kjede

Det neste trinnet forklarer prosessen med å bruke samtalesammendraget i en kjede ved å bruke LLM:

fra langkjede. llms import OpenAI
fra langkjede. kjeder import Samtalekjede
llm = OpenAI ( temperatur = 0 )
samtale_med_sammendrag = Samtalekjede (
llm = llm ,
hukommelse = SamtaleoppsummeringMinne ( llm = OpenAI ( ) ) ,
ordrik = ekte
)
samtale_med_sammendrag. forutsi ( input = 'Hei, hvordan har du det' )

Her har vi begynt å bygge kjeder ved å starte samtalen med en høflig henvendelse:

Kom nå inn i samtalen ved å spørre litt mer om den siste utgangen for å utvide den:

samtale_med_sammendrag. forutsi ( input = 'Fortell meg mer om det!' )

Modellen har forklart den siste meldingen med en detaljert introduksjon til AI-teknologien eller chatboten:

Trekk ut et interessepunkt fra forrige utgang for å ta samtalen i en bestemt retning:

samtale_med_sammendrag. forutsi ( input = 'Utrolig Hvor bra er dette prosjektet?' )

Her får vi detaljerte svar fra boten ved å bruke minnebiblioteket for samtalesammendrag:

Det handler om å bruke samtalesammendraget i LangChain.

Konklusjon

For å bruke samtaleoppsummeringsmeldingen i LangChain, installer ganske enkelt modulene og rammeverkene som kreves for å sette opp miljøet. Når miljøet er angitt, importerer du SamtaleoppsummeringMinne bibliotek for å bygge LLM-er ved å bruke OpenAI()-metoden. Deretter bruker du bare samtalesammendraget for å trekke ut det detaljerte resultatet fra modellene som er sammendraget av forrige samtale. Denne veiledningen har utdypet prosessen med å bruke minne for samtalesammendrag ved å bruke LangChain-modulen.

Hvordan bruke samtalesammendrag i LangChain?