Jak zaimplementować logikę ReAct za pomocą agenta w LangChain?

„ Reagować ” to połączenie faz Rozumu i Działania mające na celu poprawę wydajności modelu językowego jako „ Odnośnie ” odnosi się do rozumu i „ Działać ”do działania. Logika ReAct jest często uważana za najbardziej zoptymalizowaną do tworzenia LLM lub chatbotów w celu rozumienia i generowania tekstu. Agent jest decydentem, który decyduje, jakie działania wykonać i w jakiej kolejności zostaną wykonane.

Aby poznać proces implementacji logiki ReAct za pomocą agenta w LangChain wystarczy zapoznać się z poniższym przewodnikiem:

Krok 1: Instalowanie frameworków

Przede wszystkim zainstaluj LangChain, aby rozpocząć proces wdrażania logiki ReAct:

pip zainstaluj langchain

Zainstaluj moduł google-search-results, aby uzyskać zależności do zbudowania agenta, który może pobierać wyniki wyszukiwania z Google:

pip zainstaluj openai google-search-results

Następnie zainstaluj moduły OpenAI, których można użyć do załadowania dużych modeli językowych lub LLM w celu wdrożenia logiki ReAct:

pip zainstaluj openai

Po zdobyciu wszystkich wymaganych modułów po prostu skonfiguruj Środowisko OpenAI do budowy LLM i Środowisko SerpAPI za użycie agenta w modelu:

import Ty

import przejść dalej

Ty . około [ „OPENAI_API_KEY” ] = przejść dalej . przejść dalej ( „Klucz API OpenAI:” )

Ty . około [ „KLUCZ_SERPAPI_API” ] = przejść dalej . przejść dalej ( „Klucz API Serpapi:” )

Krok 2: Ładowanie modelu języka

Następnym krokiem jest załadowanie modeli językowych poprzez import wymaganych bibliotek przy użyciu frameworka LangChain:

z łańcuch językowy. agenci import ład_narzędzia

z łańcuch językowy. agenci import zainicjuj_agent

z łańcuch językowy. agenci import Typ agenta

z łańcuch językowy. llms import OpenAI

Użyj metody OpenAI(), aby zbudować Model Języka (llm), a następnie skonfiguruj narzędzia dla agentów za pomocą SerpAPI:

llm = OpenAI ( temperatura = 0 )

narzędzia = ład_narzędzia ( [ 'serpapi' , „llm-matematyka” ] , llm = llm )

Metoda 1: Używanie języka wyrażeń LandChain

LCEL to proces integrowania lub komponowania łańcuchów podczas budowania modeli językowych w LangChain. Rozpocznij proces od zainstalowania LangChainHub, aby uzyskać jego zależności do budowania i używania logiki ReAct z agentami w LangChain:

pip zainstaluj langchainhub

Importowanie bibliotek z LangChain, takich jak ReActSingleInputOutputParser, aby zbudować model, który może korzystać z modelu ReAct:

z łańcuch językowy. narzędzia . renderowanie import opis_tekstu_renderowania

z łańcuch językowy. agenci . parsery_wyjściowe import ReActSingleInputOutputParser

z łańcuch językowy. agenci . format_scratchpad import format_log_to_str

z łańcuch językowy import centrum

Załaduj model języka, aby zaprojektować logikę ReAct za pomocą metody pull() i zapisz go w zmiennej zachęty. Zdefiniuj narzędzia, których można użyć do zaimplementowania logiki na załadowanym zbiorze danych w celu zaimplementowania jego współpracy z agentem:

podpowiedź = centrum. ciągnąć ( „hwchase17/reaguj” )

podpowiedź = podpowiedź. częściowy (

narzędzia = opis_tekstu_renderowania ( narzędzia ) ,

nazwy_narzędzi = „”, „ . dołączyć ( [ T. nazwa Do T W narzędzia ] ) ,

)

Agent budowlany

Teraz skonfiguruj agenta i jego narzędzia, integrując go z modelem językowym załadowanym w kroku 2 tego przewodnika:

llm_z_stopem = llm. wiązać ( zatrzymywać się = [ ' \N Obserwacja' ] )

Zdefiniuj zmienną agenta, aby zapewnić argumenty i narzędzia do konfiguracji agenta, które wyjaśniają jego działanie. Wcześniej skonfigurowane części, takie jak metoda llm_with_stop i ReActSingleInputOutputParser() są integrowane z agentem:

agent = {

'wejście' : lambda x: x [ 'wejście' ] ,

'agent_zdrapek' : lambda x: format_log_to_str ( X [ „kroki_pośrednie” ] )

} | podpowiedź | llm_with_stop | ReActSingleInputOutputParser ( )

Pobierz bibliotekę AgentExecutor i skonfiguruj jej metodę, używając argumentów takich jak agent, narzędzia i gadatliwość, aby uzyskać bardziej czytelne dane wyjściowe:

z łańcuch językowy. agenci import Wykonawca agenta

agent_wykonawca = Wykonawca agenta ( agent = agent , narzędzia = narzędzia , gadatliwy = PRAWDA )

Wywołaj metodę agent_executor() z zapytaniem łańcuchowym jako danymi wejściowymi, co spowoduje, że agent wyodrębni dane wyjściowe:

agent_wykonawca. odwołać się ( { 'wejście' : „Kim jest dziewczyna Leo DiCaprio” } )

Wyjście

Poniższy zrzut ekranu pokazuje, że agent wyodrębnił informacje za pomocą logiki ReAct i wygenerował tekst w języku naturalnym:

Metoda 2: Używanie ZeroShotReactAgent

Logikę ReAct można również zaimplementować, używając innego agenta, takiego jak ZeroShotReactAgent, podczas konfigurowania zmiennej agent_executor. Następnie po prostu wywołaj zmienną agent_executor z pytaniem jako danymi wejściowymi, aby wywołać agenta:

agent_wykonawca = zainicjuj_agent ( narzędzia , llm , agent = Typ agenta. ZERO_SHOT_REACT_DESCRIPTION , gadatliwy = PRAWDA )

agent_wykonawca. odwołać się ( { 'wejście' : „Jaki jest wiek dziewczyny Leo DiCaprio podniesiony do potęgi 0,21” } )

Wyjście

Agent wyodrębnił informacje na podstawie danych wejściowych zadanych podczas wywoływania agenta_executor:

Metoda 3: Korzystanie z modeli czatu

Kolejny proces, który można wykorzystać do implementacji logiki ReAct poprzez wykorzystanie modeli chat po zaimportowaniu biblioteki ChatOpenAI:

z łańcuch językowy. chat_models import CzatOpenAI

Zbuduj model czatu za pomocą metody ChatOpenAI() z wartością temperatury równą 0, która może kontrolować losowość wyników modelu:

model_czatu = CzatOpenAI ( temperatura = 0 )

Załaduj model, na którym użytkownik może zaimplementować logikę ReAct, aby zapisać go w zmiennej podpowiedzi i skonfigurować narzędzia, które będą używane w procesie:

podpowiedź = centrum. ciągnąć ( „hwchase17/reaguj-json” )

podpowiedź = podpowiedź. częściowy (

narzędzia = opis_tekstu_renderowania ( narzędzia ) ,

nazwy_narzędzi = „”, „ . dołączyć ( [ T. nazwa Do T W narzędzia ] ) ,

)

Budowanie agenta

Użyj modelu czatu do przechowywania obserwacji lub ostatnich wiadomości, gdy model przestanie generować tekst:

chat_model_with_stop = model_czatu. wiązać ( zatrzymywać się = [ ' \N Obserwacja' ] )

Pobierz bibliotekę ReActJsonSingleInputOutputParser, aby zaimplementować logikę ReAct i wygenerować wyniki w formacie JSON:

z łańcuch językowy. agenci . parsery_wyjściowe import ReActJsonSingleInputOutputParser

Zbuduj i skonfiguruj agenta, używając zmiennej chat_model i metody, aby uzyskać wyniki poprzez wywołanie agenta:

agent = {

'wejście' : lambda x: x [ 'wejście' ] ,

'agent_zdrapek' : lambda x: format_log_to_str ( X [ „kroki_pośrednie” ] )

} | podpowiedź | chat_model_with_stop | ReActJsonSingleInputOutputParser ( )

Skonfiguruj agent_executor i uruchom go, aby uzyskać wyniki na podstawie zapytania podanego w zmiennej wejściowej:

agent_wykonawca = Wykonawca agenta ( agent = agent , narzędzia = narzędzia , gadatliwy = PRAWDA )

agent_wykonawca. odwołać się ( { 'wejście' : „Jaki jest wiek dziewczyny Leo DiCaprio podniesiony do potęgi 0,21” } )

Wyjście

Agent wyodrębnił dane wyjściowe, jak pokazano na poniższym zrzucie ekranu:

Metoda 4: Korzystanie z ChatZeroShotReactAgent

Zmianę wartości agenta można również wykorzystać do zaimplementowania logiki ReAct za pomocą frameworka LangChain:

agent = zainicjuj_agent ( narzędzia , model_czatu , agent = Typ agenta. CHAT_ZERO_SHOT_REACT_DESCRIPTION , gadatliwy = PRAWDA )

agent. uruchomić ( „Jaki jest wiek dziewczyny Leo DiCaprio podniesiony do potęgi 0,21” )

Wyjście

Struktura wyjściowa zawiera szczegółowe informacje o działaniu agenta z tokenów i modelu użytego do wyodrębnienia informacji:

To tyle, jeśli chodzi o proces implementacji logiki ReAct za pomocą agenta w LangChain.

Wniosek

Aby zaimplementować logikę ReAct z agentem przy użyciu frameworka LangChain, zainstaluj moduły takie jak google-search-results w celu skonfigurowania agenta. Następnie skonfiguruj środowisko przy użyciu poświadczeń OpenAI i SerpAPI z ich kont, aby rozpocząć korzystanie z modelu. Logikę ReAct można wdrożyć przy użyciu modeli LCEL i chatu z wieloma agentami oferowanych przez moduł LangChain. W tym przewodniku szczegółowo opisano implementację logiki ReAct przy użyciu agenta w LangChain.

Jak zaimplementować logikę ReAct za pomocą agenta w LangChain?

Szybki zarys