Snel overzicht
Dit bericht zal het volgende aantonen:
Wat zijn agenten in natuurlijke taalverwerking (NLP)
Aan de slag met agenten in LangChain
- Kaders installeren
- Chatmodel configureren
- Bouwmakelaar
- Een beroep doen op de agent
- Agenttools configureren
- De agent testen
Wat zijn agenten in natuurlijke taalverwerking (NLP)?
Agents zijn de essentiële componenten van de natuurlijke taaltoepassing en ze gebruiken Natural Language Understanding (NLU) om zoekopdrachten te begrijpen. Deze agenten zijn programma's die fungeren als een gesprekssjabloon voor interactie met mensen met behulp van de reeks taken. Agenten gebruiken meerdere tools die door de agent kunnen worden aangeroepen om meerdere acties uit te voeren of om de volgende taak op te geven die moet worden uitgevoerd.
Aan de slag met agenten in LangChain
Start het proces van het bouwen van agenten die een gesprek met mensen kunnen voeren door uitvoer te extraheren met behulp van de agenten in LangChain. Om te leren hoe u aan de slag gaat met de agenten in LangChain, volgt u eenvoudigweg de onderstaande stappen:
Stap 1: Frameworks installeren
Ga eerst aan de slag met het proces van het installeren van het LangChain-framework met behulp van de “ Pip 'opdracht om de vereiste afhankelijkheden voor het gebruik van agenten op te halen:
pip installeer langchain 
Installeer de OpenAI-module voor het bouwen van de LLM en gebruik deze om de agenten in LangChain te configureren:
pip installeer openai 
Stel de omgeving in voor de OpenAI-module met behulp van de API-sleutel van het account door de volgende code uit te voeren:
importeren Jijimporteren Krijg een pas
Jij . ongeveer [ 'OPENAI_API_KEY' ] = Krijg een pas . Krijg een pas ( 'OpenAI API-sleutel:' )
Stap 2: Chatmodel configureren
Importeer de ChatOpenAI-module uit de LangChain om de LLM te bouwen met behulp van zijn functie:
van langketen. chat_modellen importeren ChatOpenAIllm = ChatOpenAI ( temperatuur = 0 )
Importeer tools waarmee de agent de taken of acties kan configureren die door de agent moeten worden uitgevoerd. De volgende code gebruikt de methode get_word_length() om de lengte van het woord op te halen dat door de gebruiker is opgegeven:
van langketen. agenten importeren hulpmiddel@ hulpmiddel
zeker get_word_length ( woord: str ) - > int :
'''de lengte van het woord bepalen'''
opbrengst alleen ( woord )
hulpmiddelen = [ get_word_length ]
Configureer de sjabloon of structuur voor het chatmodel om een interface te creëren voor het voeren van een chat:
van langketen. aanwijzingen importeren ChatPrompt-sjabloon , BerichtenPlaceholdersnel = ChatPrompt-sjabloon. van_berichten ( [
( 'systeem' , 'uw assistent is behoorlijk verbazingwekkend, maar moet worden verbeterd bij het berekenen van lengtes' ) ,
( 'gebruiker' , '{invoer}' ) ,
BerichtenPlaceholder ( variabele_naam = 'agent_kladblok' ) ,
] )
Stap 3: Bouwagent
Importeer de toolsbibliotheek voor het bouwen van de LLM met tools met behulp van de OpenAI-functies uit de LangChain-module:
van langketen. hulpmiddelen . veroorzaken importeren format_tool_to_openai_functionllm_with_tools = llm. binden (
functies = [ format_tool_to_openai_function ( T ) voor T in hulpmiddelen ]
)
Configureer de agent met behulp van de OpenAI-functieagent om de uitvoerparser te gebruiken om de reeks acties/taken in te stellen:
van langketen. agenten . format_kladblok importeren format_to_openai_functionsvan langketen. agenten . uitvoer_parsers importeren OpenAIFunctionsAgentOutputParser
tussenpersoon = {
'invoer' : lambda x: x [ 'invoer' ] ,
'agent_kladblok' : lambda x: format_to_openai_functions ( X [ 'tussenstappen' ] )
} | prompt | llm_with_tools | OpenAIFunctionsAgentOutputParser ( )
Stap 4: De agent aanroepen
De volgende stap gebruikt de functie invoke() om de agent aan te roepen met behulp van de argumenten input en intermediate_steps:
tussenpersoon. aanroepen ( {'invoer' : 'hoeveel letters in het woord goed' ,
'tussenstappen' : [ ]
} )
Stap 5: Agenttools configureren
Importeer daarna eenvoudigweg de AgentFinish-bibliotheek om de intermediate_steps te configureren door alle stappen in een reeks te integreren om de activiteit te voltooien:
van langketen. schema . tussenpersoon importeren AgentFinishtussenliggende_stappen = [ ]
terwijl WAAR :
uitgang = tussenpersoon. aanroepen ( {
'invoer' : 'brieven in goede staat' ,
'tussenstappen' : tussenliggende_stappen
} )
als isinstantie ( uitgang , AgentFinish ) :
eindresultaat = uitgang. retourwaarden [ 'uitvoer' ]
pauze
anders :
afdrukken ( uitgang. hulpmiddel , uitgang. tool_invoer )
hulpmiddel = {
'get_word_length' : get_word_length
} [ uitgang. hulpmiddel ]
observatie = hulpmiddel. loop ( uitgang. tool_invoer )
tussenliggende_stappen. toevoegen ( ( uitgang , observatie ) )
afdrukken ( eindresultaat )
Stap 6: De agent testen
Voer nu de agent uit door de methode AgentExecutor() aan te roepen nadat de bibliotheek uit de LangChain is geïmporteerd:
van langketen. agenten importeren AgentUitvoerderagent_uitvoerder = AgentUitvoerder ( tussenpersoon = tussenpersoon , hulpmiddelen = hulpmiddelen , uitgebreid = WAAR )
Roep aan het einde de agent_executor aan met het invoerargument om de query voor de agent in te voeren:
agent_uitvoerder. aanroepen ( { 'invoer' : 'hoeveel letters in het woord goed' } )De agent heeft het antwoord op de vraag in het invoerargument weergegeven nadat de keten is voltooid:
Dat gaat allemaal over aan de slag gaan met de agenten in het LangChain-framework.
Conclusie
Om aan de slag te gaan met de agenten in LangChain, installeert u eenvoudig de modules die nodig zijn om de omgeving in te stellen met behulp van de OpenAI API-sleutel. Configureer daarna het chatmodel door de promptsjabloon in te stellen voor het bouwen van de agent met de reeks tussenstappen. Zodra de agent is geconfigureerd, bouwt u eenvoudigweg de tools door de taken op te geven nadat u de invoerreeks aan de gebruiker heeft gegeven. Deze blog heeft het proces van het gebruik van de agenten in LangChain gedemonstreerd.