Hurtig disposition
Dette indlæg vil demonstrere følgende:
Hvad er agenter i Natural Language Processing (NLP)
Kom godt i gang med agenter i LangChain
- Installation af Frameworks
- Konfigurer chatmodel
- Bygningsagent
- Påkaldelse af agenten
- Konfigurer agentværktøjer
- Test af agenten
Hvad er agenter i Natural Language Processing (NLP)?
Agenter er de vitale komponenter i den naturlige sprogapplikation, og de bruger Natural Language Understanding (NLU) til at forstå forespørgsler. Disse agenter er programmer, der fungerer som en samtaleskabelon til at have en interaktion med mennesker ved hjælp af rækkefølgen af opgaver. Agenter bruger flere værktøjer, der kan kaldes af agenten til at udføre flere handlinger eller angive den næste opgave, der skal udføres.
Kom godt i gang med agenter i LangChain
Start processen med at bygge agenterne til at have en samtale med mennesker ved at udtrække output ved hjælp af agenterne i LangChain. For at lære processen med at komme i gang med agenterne i LangChain skal du blot følge nedenstående trin:
Trin 1: Installation af Frameworks
Først skal du komme i gang med processen med at installere LangChain-rammeværket ved hjælp af ' pip kommando for at få de nødvendige afhængigheder til brug af agenter:
pip installer langkæde 
Installer OpenAI-modulet til opbygning af LLM og brug det til at konfigurere agenterne i LangChain:
pip installer openai 
Indstil miljøet for OpenAI-modulet ved at bruge dets API-nøgle fra kontoen ved at køre følgende kode:
importere duimportere getpass
du . rundt regnet [ 'OPENAI_API_KEY' ] = getpass . getpass ( 'OpenAI API-nøgle:' )
Trin 2: Konfigurer chatmodel
Importer ChatOpenAI-modulet fra LangChain for at bygge LLM ved hjælp af dets funktion:
fra langkæde. chat_modeller importere ChatOpenAIllm = ChatOpenAI ( temperatur = 0 )
Importer værktøjer til agenten til at konfigurere de opgaver eller handlinger, der skal udføres af agenten. Følgende kode bruger metoden get_word_length() til at få længden af ordet, som er angivet af brugeren:
fra langkæde. agenter importere værktøj@ værktøj
def get_word_length ( ord: str ) - > int :
'''at få ordets længde'''
Vend tilbage kun ( ord )
værktøjer = [ get_word_length ]
Konfigurer skabelonen eller strukturen for chatmodellen for at skabe en grænseflade til at have en chat:
fra langkæde. prompter importere ChatPromptTemplate , Beskeder Pladsholderhurtig = ChatPromptTemplate. fra_beskeder ( [
( 'system' , 'din assistent er ret fantastisk, men har brug for forbedringer til at beregne længder' ) ,
( 'bruger' , '{input}' ) ,
Beskeder Pladsholder ( variabel_navn = 'agent_scratchpad' ) ,
] )
Trin 3: Bygningsagent
Importer værktøjsbiblioteket til opbygning af LLM med værktøjer ved hjælp af OpenAI-funktionerne fra LangChain-modulet:
fra langkæde. værktøjer . gengive importere format_tool_to_openai_functionllm_med_værktøjer = llm. binde (
funktioner = [ format_tool_to_openai_function ( t ) til t i værktøjer ]
)
Konfigurer agenten ved hjælp af OpenAI-funktionsagenten til at bruge outputparseren til at indstille handlings-/opgavesekvenserne:
fra langkæde. agenter . format_scratchpad importere format_to_openai_functionsfra langkæde. agenter . output_parsere importere OpenAIFunctionsAgentOutputParser
agent = {
'input' : lambda x: x [ 'input' ] ,
'agent_scratchpad' : lambda x: format_to_openai_functions ( x [ 'mellemtrin' ] )
} | prompt | llm_med_værktøjer | OpenAIFunctionsAgentOutputParser ( )
Trin 4: Påkaldelse af agenten
Det næste trin bruger funktionen invoke() til at kalde agenten ved hjælp af input- og intermediate_steps-argumenterne:
agent. påberåbe sig ( {'input' : 'hvor mange bogstaver i ordet god' ,
'mellemtrin' : [ ]
} )
Trin 5: Konfigurer agentværktøjer
Derefter skal du blot importere AgentFinish-biblioteket for at konfigurere intermediate_steps ved at integrere alle trinene i en sekvens for at fuldføre aktiviteten:
fra langkæde. skema . agent importere AgentFinishmellemtrin = [ ]
mens Rigtigt :
produktion = agent. påberåbe sig ( {
'input' : 'bogstaver i god stand' ,
'mellemtrin' : mellemtrin
} )
hvis er forekomst ( produktion , AgentFinish ) :
endelig_resultat = produktion. returværdier [ 'produktion' ]
pause
andet :
Print ( produktion. værktøj , produktion. tool_input )
værktøj = {
'få_ord_længde' : get_word_length
} [ produktion. værktøj ]
observation = værktøj. løb ( produktion. tool_input )
mellemtrin. Tilføj ( ( produktion , observation ) )
Print ( endelig_resultat )
Trin 6: Test af agenten
Kør nu agenten ved at kalde AgentExecutor()-metoden efter import af dets bibliotek fra LangChain:
fra langkæde. agenter importere AgentExecutoragent_executor = AgentExecutor ( agent = agent , værktøjer = værktøjer , ordrig = Rigtigt )
I slutningen skal du kalde agent_executor med input-argumentet for at indtaste forespørgslen for agenten:
agent_executor. påberåbe sig ( { 'input' : 'hvor mange bogstaver i ordet god' } )Agenten har vist svaret på spørgsmålet i input-argumentet efter at have afsluttet kæden:
Det handler om at komme i gang med agenterne i LangChain-rammerne.
Konklusion
For at komme i gang med agenterne i LangChain skal du blot installere de moduler, der kræves for at opsætte miljøet ved hjælp af OpenAI API-nøglen. Konfigurer derefter chatmodellen ved at indstille promptskabelonen til opbygning af agenten med rækkefølgen af mellemtrin. Når agenten er konfigureret, skal du blot bygge værktøjerne ved at specificere opgaverne efter at have givet inputstrengen til brugeren. Denne blog har demonstreret processen med at bruge agenterne i LangChain.