Komma igång med agenter i LangChain?

Komma Igang Med Agenter I Langchain

LangChain är ramverket för att lösa Natural Language Processing för att bygga applikationer eller mjukvara som kan interagera och konversera med människor. Chatbotarna eller Large Language Models (LLMs) är designade för att skapa en miljö som kan fungera som ett gränssnitt för chatt/konversation. Dessa chattar genomförs på mänskliga språk som kallas naturliga språk som engelska, etc. mellan människor och en AI-modell.

Snabb översikt

Det här inlägget kommer att visa följande:

Vad är agenter i Natural Language Processing (NLP)

Komma igång med agenter i LangChain

Installera ramar
Konfigurera chattmodell
Byggnadsagent
Åberopar agenten
Konfigurera agentverktyg
Testar agenten

Vad är agenter i Natural Language Processing (NLP)?

Agenter är de vitala komponenterna i det naturliga språkapplikationen och de använder Natural Language Understanding (NLU) för att förstå frågor. Dessa agenter är program som fungerar som en konversationsmall för att ha en interaktion med människor med hjälp av sekvensen av uppgifter. Agenter använder flera verktyg som kan anropas av agenten för att utföra flera åtgärder eller specificera nästa uppgift som ska utföras.

Komma igång med agenter i LangChain

Starta processen med att bygga agenterna för att ha en konversation med människor genom att extrahera utdata med hjälp av agenterna i LangChain. För att lära dig processen för att komma igång med agenterna i LangChain, följ helt enkelt stegen nedan:

Steg 1: Installera ramverk

Kom först igång med processen att installera LangChain-ramverket med hjälp av ' pip ” kommando för att få de nödvändiga beroenden för att använda agenter:

pip installera langkedja

Installera OpenAI-modulen för att bygga LLM och använd den för att konfigurera agenterna i LangChain:

pip installera openai

Ställ in miljön för OpenAI-modulen med dess API-nyckel från kontot genom att köra följande kod:

importera du
importera getpass

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

Steg 2: Konfigurera chattmodellen

Importera ChatOpenAI-modulen från LangChain för att bygga LLM med dess funktion:

från långkedja. chat_modeller importera ChatOpenAI

llm = ChatOpenAI ( temperatur = 0 )

Importera verktyg för agenten för att konfigurera de uppgifter eller åtgärder som ska utföras av agenten. Följande kod använder metoden get_word_length() för att få längden på ordet som tillhandahålls av användaren:

från långkedja. agenter importera verktyg

@ verktyg

def get_word_length ( ord: str ) - > int :

'''får ordets längd'''

lämna tillbaka endast ( ord )

verktyg = [ get_word_length ]

Konfigurera mallen eller strukturen för chattmodellen för att skapa ett gränssnitt för att ha en chatt:

från långkedja. uppmaningar importera ChatPromptMall , Meddelanden Platshållare

prompt = ChatPromptMall. from_messages ( [

( 'systemet' , 'din assistent är helt fantastisk, men behöver förbättras när det gäller att beräkna längder' ) ,

( 'användare' , '{inmatning}' ) ,

Meddelanden Platshållare ( variabelnamn = 'agent_scratchpad' ) ,

] )

Steg 3: Byggnadsagent

Importera verktygsbiblioteket för att bygga LLM med verktyg som använder OpenAI-funktionerna från LangChain-modulen:

från långkedja. verktyg . framställa importera format_tool_to_openai_function

llm_with_tools = llm. binda (

funktioner = [ format_tool_to_openai_function ( t ) för t i verktyg ]

)

Konfigurera agenten med hjälp av OpenAI-funktionsagenten för att använda utdataparsern för att ställa in åtgärds-/uppgiftssekvenserna:

från långkedja. agenter . format_scratchpad importera format_to_openai_functions

från långkedja. agenter . output_parsers importera OpenAIFunctionsAgentOutputParser

ombud = {

'inmatning' : lambda x: x [ 'inmatning' ] ,

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

} | uppmaning | llm_with_tools | OpenAIFunctionsAgentOutputParser ( )

Steg 4: Anropa agenten

Nästa steg använder funktionen invoke() för att anropa agenten med argumenten input och intermediate_steps:

ombud. åberopa ( {

'inmatning' : 'hur många bokstäver i ordet bra' ,

'mellansteg' : [ ]

} )

Steg 5: Konfigurera agentverktyg

Efter det importerar du helt enkelt AgentFinish-biblioteket för att konfigurera intermediate_steps genom att integrera alla steg i en sekvens för att slutföra aktiviteten:

från långkedja. schema . ombud importera AgentFinish
mellansteg = [ ]
medan Sann :
produktion = ombud. åberopa ( {
'inmatning' : 'bokstäver i bra' ,
'mellansteg' : mellansteg
} )
om är instans ( produktion , AgentFinish ) :
final_result = produktion. returvärden [ 'produktion' ]
ha sönder
annan :
skriva ut ( produktion. verktyg , produktion. tool_input )
verktyg = {
'get_word_length' : get_word_length
} [ produktion. verktyg ]
observation = verktyg. springa ( produktion. tool_input )
mellansteg. bifoga ( ( produktion , observation ) )
skriva ut ( final_result )

Steg 6: Testa agenten

Kör nu agenten genom att anropa AgentExecutor()-metoden efter att ha importerat dess bibliotek från LangChain:

från långkedja. agenter importera AgentExecutor

agent_exekutor = AgentExecutor ( ombud = ombud , verktyg = verktyg , mångordig = Sann )

I slutet, anropa agent_executor med input-argumentet för att ange frågan för agenten:

agent_exekutor. åberopa ( { 'inmatning' : 'hur många bokstäver i ordet bra' } )

Agenten har visat svaret på frågan i inmatningsargumentet efter att ha avslutat kedjan:

Det handlar om att komma igång med agenterna i LangChain-ramverket.

Slutsats

För att komma igång med agenterna i LangChain, installera helt enkelt modulerna som krävs för att ställa in miljön med OpenAI API-nyckeln. Efter det konfigurerar du chattmodellen genom att ställa in promptmallen för att bygga agenten med sekvensen av mellansteg. När agenten är konfigurerad bygger du helt enkelt verktygen genom att specificera uppgifterna efter att ha gett inmatningssträngen till användaren. Den här bloggen har visat hur man använder agenterna i LangChain.