Schiță rapidă
Această postare va demonstra următoarele:
Ce sunt agenții în procesarea limbajului natural (NLP)
Noțiuni introductive cu agenții în LangChain
- Instalarea cadrelor
- Configurați modelul de chat
- Agent de constructii
- Invocarea agentului
- Configurați instrumentele agentului
- Testarea agentului
Ce sunt agenții în procesarea limbajului natural (NLP)?
Agenții sunt componentele vitale ale aplicației în limbaj natural și folosesc Natural Language Understanding (NLU) pentru a înțelege interogările. Acești agenți sunt programe care acționează ca un șablon conversațional pentru a avea o interacțiune cu oamenii folosind secvența de sarcini. Agenții folosesc mai multe instrumente care pot fi apelate de agent pentru a efectua mai multe acțiuni sau pentru a specifica următoarea sarcină de efectuat.
Noțiuni introductive cu agenții în LangChain
Începeți procesul de construire a agenților pentru a avea o conversație cu oamenii prin extragerea rezultatelor folosind agenții din LangChain. Pentru a afla procesul de începere cu agenții din LangChain, pur și simplu urmați pașii enumerați mai jos:
Pasul 1: Instalarea cadrelor
În primul rând, începeți cu procesul de instalare a cadrului LangChain folosind „ pip ” comandă pentru a obține dependențele necesare pentru utilizarea agenților:
pip install langchain 
Instalați modulul OpenAI pentru construirea LLM și utilizați-l pentru a configura agenții în LangChain:
pip install openai 
Configurați mediul pentru modulul OpenAI folosind cheia sa API din cont, rulând următorul cod:
import tuimport getpass
tu . aproximativ [ „OPENAI_API_KEY” ] = getpass . getpass ( „Cheia API OpenAI:” )
Pasul 2: Configurați modelul de chat
Importați modulul ChatOpenAI din LangChain pentru a construi LLM folosind funcția sa:
din langchain. chat_models import ChatOpenAIllm = ChatOpenAI ( temperatura = 0 )
Importați instrumente pentru agent pentru a configura sarcinile sau acțiunile necesare pentru a fi efectuate de agent. Următorul cod folosește metoda get_word_length() pentru a obține lungimea cuvântului furnizat de utilizator:
din langchain. agenţi import instrument@ instrument
def obține_lungimea_cuvântului ( cuvânt: str ) - > int :
'''obținerea lungimii cuvântului'''
întoarcere numai ( cuvânt )
unelte = [ obține_lungimea_cuvântului ]
Configurați șablonul sau structura pentru modelul de chat pentru a crea o interfață pentru a avea un chat:
din langchain. solicitări import ChatPromptTemplate , MesajePlaceholderprompt = ChatPromptTemplate. din_mesaje ( [
( 'sistem' , „Asistentul tău este destul de uimitor, dar necesită îmbunătățiri la calcularea lungimii” ) ,
( 'utilizator' , '{intrare}' ) ,
MesajePlaceholder ( nume_variabilă = 'agent_scratchpad' ) ,
] )
Pasul 3: Agent de constructii
Importați biblioteca de instrumente pentru construirea LLM cu instrumente folosind funcțiile OpenAI din modulul LangChain:
din langchain. unelte . face import format_tool_to_openai_functionllm_cu_instrumente = llm. lega (
funcții = [ format_tool_to_openai_function ( t ) pentru t în unelte ]
)
Configurați agentul folosind agentul funcției OpenAI pentru a utiliza analizatorul de ieșire pentru a seta secvențele de acțiuni/sarcini:
din langchain. agenţi . format_scratchpad import format_to_openai_functionsdin langchain. agenţi . analizoare_ieșire import OpenAIFunctionsAgentOutputParser
agent = {
'intrare' : lambda x: x [ 'intrare' ] ,
'agent_scratchpad' : lambda x: format_to_openai_functions ( X [ „pași_intermediari” ] )
} | prompt | llm_cu_instrumente | OpenAIFunctionsAgentOutputParser ( )
Pasul 4: Invocarea agentului
Următorul pas folosește funcția invoke() pentru a apela agentul folosind argumentele input și intermediate_steps:
agent. invoca ( {'intrare' : „câte litere din cuvântul bun” ,
„pași_intermediari” : [ ]
} )
Pasul 5: Configurați instrumentele agentului
După aceea, pur și simplu importați biblioteca AgentFinish pentru a configura intermediate_steps integrând toți pașii într-o secvență pentru a finaliza activitatea:
din langchain. schemă . agent import Agent Finishpași_intermediari = [ ]
in timp ce Adevărat :
ieșire = agent. invoca ( {
'intrare' : 'litere bune' ,
„pași_intermediari” : pași_intermediari
} )
dacă esteinstanță ( ieșire , Agent Finish ) :
rezultat final = ieșire. return_values [ 'ieșire' ]
pauză
altfel :
imprimare ( ieșire. instrument , ieșire. instrument_input )
instrument = {
„get_word_length” : obțineți_lungimea_cuvântului
} [ ieșire. instrument ]
observare = instrument. alerga ( ieșire. instrument_input )
pași_intermediari. adăuga ( ( ieșire , observare ) )
imprimare ( rezultat final )
Pasul 6: Testarea agentului
Acum, executați agentul apelând metoda AgentExecutor() după importarea bibliotecii sale din LangChain:
din langchain. agenţi import Agent Executoragent_executor = Agent Executor ( agent = agent , unelte = unelte , verboroasă = Adevărat )
La sfârșit, invocați agent_executor cu argumentul de intrare pentru a introduce interogarea pentru agent:
agent_executor. invoca ( { 'intrare' : „câte litere din cuvântul bun” } )Agentul a afișat răspunsul la întrebarea furnizată în argumentul de intrare după terminarea lanțului:
Asta înseamnă să începeți cu agenții din cadrul LangChain.
Concluzie
Pentru a începe cu agenții din LangChain, instalați pur și simplu modulele necesare pentru a configura mediul folosind cheia API OpenAI. După aceea, configurați modelul de chat setând șablonul de prompt pentru construirea agentului cu secvența de pași intermediari. Odată ce agentul este configurat, pur și simplu construiți instrumentele prin specificarea sarcinilor după ce ați dat șirul de intrare utilizatorului. Acest blog a demonstrat procesul de utilizare a agenților din LangChain.