Komme i gang med agenter i LangChain?

Komme I Gang Med Agenter I Langchain

LangChain er rammeverket for å løse Natural Language Processing for å bygge applikasjoner eller programvare som kan samhandle og snakke med mennesker. Chatbotene eller Large Language Models (LLMs) er designet for å skape et miljø som kan fungere som et grensesnitt for chat/samtale. Disse chattene utføres på menneskelige språk kalt naturlige språk som engelsk, etc. mellom mennesker og en AI-modell.

Rask oversikt

Dette innlegget vil demonstrere følgende:

Hva er agenter i naturlig språkbehandling (NLP)

Komme i gang med agenter i LangChain

Installere Frameworks
Konfigurer Chat-modellen
Byggeagent
Påkaller agenten
Konfigurer agentverktøy
Tester agenten

Hva er agenter i naturlig språkbehandling (NLP)?

Agenter er de vitale komponentene i applikasjonen for naturlig språk, og de bruker Natural Language Understanding (NLU) for å forstå spørsmål. Disse agentene er programmer som fungerer som en samtalemal for å ha en interaksjon med mennesker ved å bruke sekvensen av oppgaver. Agenter bruker flere verktøy som kan kalles opp av agenten for å utføre flere handlinger eller spesifisere neste oppgave som skal utføres.

Komme i gang med agenter i LangChain

Start prosessen med å bygge agentene for å ha en samtale med mennesker ved å trekke ut output ved å bruke agentene i LangChain. For å lære prosessen med å komme i gang med agentene i LangChain, følg ganske enkelt trinnene nedenfor:

Trinn 1: Installere Frameworks

Først, kom i gang med prosessen med å installere LangChain-rammeverket ved å bruke ' pip kommando for å få de nødvendige avhengighetene for bruk av agenter:

pip installer langkjede

Installer OpenAI-modulen for å bygge LLM og bruk den til å konfigurere agentene i LangChain:

pip installer openai

Sett opp miljøet for OpenAI-modulen ved å bruke API-nøkkelen fra kontoen ved å kjøre følgende kode:

import du
import få pass

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

Trinn 2: Konfigurer Chat-modellen

Importer ChatOpenAI-modulen fra LangChain for å bygge LLM ved å bruke funksjonen:

fra langkjede. chat_modeller import ChatOpenAI

llm = ChatOpenAI ( temperatur = 0 )

Importer verktøy for agenten for å konfigurere oppgavene eller handlingene som skal utføres av agenten. Følgende kode bruker get_word_length()-metoden for å få lengden på ordet gitt av brukeren:

fra langkjede. agenter import verktøy

@ verktøy

def få_ordlengde ( ord: str ) - > int :

'''får ordets lengde'''

komme tilbake bare ( ord )

verktøy = [ få_ordlengde ]

Konfigurer malen eller strukturen for chat-modellen for å lage et grensesnitt for å ha en chat:

fra langkjede. spør import ChatPromptTemplate , MeldingerPlassholder

ledetekst = ChatPromptTemplate. fra_meldinger ( [

( 'system' , 'assistenten din er ganske fantastisk, men trenger forbedring ved å beregne lengder' ) ,

( 'bruker' , «{input}» ) ,

MeldingerPlassholder ( variabelnavn = 'agent_scratchpad' ) ,

] )

Trinn 3: Byggeagent

Importer verktøybiblioteket for å bygge LLM med verktøy ved å bruke OpenAI-funksjonene fra LangChain-modulen:

fra langkjede. verktøy . gjengi import format_tool_to_openai_function

llm_with_tools = llm. binde (

funksjoner = [ format_tool_to_openai_function ( t ) til t i verktøy ]

)

Konfigurer agenten ved å bruke OpenAI-funksjonsagenten til å bruke utdataparseren til å angi handlings-/oppgavesekvensene:

fra langkjede. agenter . format_scratchpad import format_to_openai_functions

fra langkjede. agenter . output_parsere import OpenAIFunctionsAgentOutputParser

middel = {

'inngang' : lambda x: x [ 'inngang' ] ,

'agent_scratchpad' : lambda x: format_to_openai_functions ( x [ 'mellomsteg' ] )

} | ledetekst | llm_with_tools | OpenAIFunctionsAgentOutputParser ( )

Trinn 4: Påkalling av agenten

Det neste trinnet bruker invoke()-funksjonen til å kalle agenten ved å bruke input- og intermediate_steps-argumentene:

middel. påkalle ( {

'inngang' : 'hvor mange bokstaver i ordet bra' ,

'mellomsteg' : [ ]

} )

Trinn 5: Konfigurer agentverktøy

Etter det importerer du bare AgentFinish-biblioteket for å konfigurere intermediate_steps ved å integrere alle trinnene i en sekvens for å fullføre aktiviteten:

fra langkjede. skjema . middel import AgentFinish
mellomtrinn = [ ]
samtidig som ekte :
produksjon = middel. påkalle ( {
'inngang' : 'bokstaver i god stand' ,
'mellomsteg' : mellomtrinn
} )
hvis er forekomst ( produksjon , AgentFinish ) :
endelig resultat = produksjon. returverdier [ 'produksjon' ]
gå i stykker
ellers :
skrive ut ( produksjon. verktøy , produksjon. tool_input )
verktøy = {
'få_ordlengde' : get_word_length
} [ produksjon. verktøy ]
observasjon = verktøy. løpe ( produksjon. tool_input )
mellomtrinn. legge til ( ( produksjon , observasjon ) )
skrive ut ( endelig resultat )

Trinn 6: Testing av agenten

Kjør nå agenten ved å kalle AgentExecutor()-metoden etter å ha importert biblioteket fra LangChain:

fra langkjede. agenter import AgentExecutor

agent_executor = AgentExecutor ( middel = middel , verktøy = verktøy , ordrik = ekte )

På slutten påkaller du agent_executor med input-argumentet for å skrive inn spørringen for agenten:

agent_executor. påkalle ( { 'inngang' : 'hvor mange bokstaver i ordet bra' } )

Agenten har vist svaret på spørsmålet gitt i input-argumentet etter å ha fullført kjeden:

Det handler om å komme i gang med agentene i LangChain-rammeverket.

Konklusjon

For å komme i gang med agentene i LangChain, installer ganske enkelt modulene som kreves for å sette opp miljøet ved hjelp av OpenAI API-nøkkelen. Deretter konfigurerer du chat-modellen ved å angi ledetekstmalen for å bygge agenten med sekvensen av mellomtrinn. Når agenten er konfigurert, bygger du ganske enkelt verktøyene ved å spesifisere oppgavene etter å ha gitt inndatastrengen til brukeren. Denne bloggen har demonstrert prosessen med å bruke agentene i LangChain.