Hurtig disposition
Dette indlæg vil vise:
Sådan bruges en agent til at returnere et struktureret output i LangChain
- Installation af Frameworks
- OpenAI miljø
- Oprettelse af en vektorbutik
- Indstilling af stien
- Indlæsning og opdeling af data
- Oprettelse af en retriever
Metode 1: Kombination af agent med Vector Stores
Metode 2: Brug af agent som en router
Metode 3: Brug af agent med Multi-Hop Vector Store
Hvordan bruger man en agent til at returnere et struktureret output i LangChain?
Udvikleren bruger agenter til at rute mellem databaserne, der indeholder træningsdata for modellerne. En agent har blueprintet af hele processen ved at gemme alle trinene. Agenten har værktøjerne til at udføre alle disse aktiviteter for at fuldføre processen. Brugeren kan også bruge agenten til at hente data fra forskellige datalagre for at gøre modellen forskelligartet.
For at lære processen med at kombinere agenter og vektorbutikker i LangChain skal du blot følge de anførte trin:
Trin 1: Installation af Frameworks
Installer først LangChain-modulet og dets afhængigheder til at kombinere agenter og vektorlagre:
pip installer langkæde 
I denne vejledning bruger vi Chroma-databasen, som kan gemme data på forskellige steder eller tabeller:
pip installer chromadb 
For at få en bedre forståelse af data, opdel de store filer i mindre bidder ved hjælp af tiktoken tokenizer:
pip installer tiktoken 
OpenAI er modulet, der kan bruges til at bygge den store sprogmodel i LangChain-rammerne:
pip installer openai 
Trin 2: OpenAI-miljø
Det næste skridt her er at sætte miljøet op ved hjælp af OpenAI's API-nøgle, som kan udtrækkes fra den officielle OpenAI-konto:
importere duimportere getpass
du . rundt regnet [ 'OPENAI_API_KEY' ] = getpass . getpass ( 'OpenAI API-nøgle:' )
Upload nu dataene fra det lokale system til Google-samarbejdet for at bruge dem i fremtiden:
fra google. ET AL importere fileruploadet = filer. upload ( )
Trin 3: Oprettelse af en vektorbutik
Dette trin konfigurerer den første komponent i vores opgave, som er et vektorlager til lagring af de uploadede data. Konfiguration af vektorlagrene kræver de biblioteker, der kan importeres fra forskellige afhængigheder af LangChain:
fra langkæde. indlejringer . openai importere OpenAIE-indlejringer#Vector lagrer afhængighed for at få den nødvendige database eller vektor
fra langkæde. vektorbutikker importere Chroma
#Tekst splitter bruges til at konvertere den store tekst til mindre bidder
fra langkæde. tekstsplitter importere CharacterTextSplitter
fra langkæde. llms importere OpenAI
fra langkæde. dokumentindlæsere importere WebBaseLoader
fra langkæde. kæder importere Hentning QA
llm = OpenAI ( temperatur = 0 )
Trin 4: Indstilling af stien
Efter import af bibliotekerne skal du blot indstille stien til adgang til vektorlagrene, før du gemmer dataene i dem:
fra stilib importere Stirelevante_dele = [ ]
til s i Sti ( '.' ) . absolut ( ) . dele :
relevante_dele. Tilføj ( s )
hvis relevante_dele [ - 3 : ] == [ 'langkæde' , 'dokumenter' , 'moduler' ] :
pause
#Conditional Statement inde i løkken for at angive stien for hver database
doc_path = str ( Sti ( *relevante_dele ) / 'state_of_the_union.txt' )
Trin 5: Indlæsning og opdeling af data
Nu skal du blot indlæse dataene og dele dem i mindre bidder for at gøre dets læsbarhed og forståelighed bedre. Opret indlejringer af dataene ved at konvertere teksten til tal, der laver deres vektorrum og gemmer den i Chorma-databasen:
fra langkæde. dokumentindlæsere importere TextLoader#Indlæser datasættet fra dets sti og gemmer dets mindre bidder i databasen
læsser = TextLoader ( doc_path )
Dokumenter = læsser. belastning ( )
tekstsplitter = CharacterTextSplitter ( chunk_size = 2000 , chunk_overlap = 0 )
tekster = tekstsplitter. split_dokumenter ( Dokumenter )
#Konverter tekst til tal og gem indlejringerne i databasen
indlejringer = OpenAIE-indlejringer ( )
docsearch = Chroma. fra_dokumenter ( tekster , indlejringer , samlingsnavn = 'state-of-union' )
Trin 6: Oprettelse af en retriever
For at kombinere agent- og vektorlagre er det nødvendigt at oprette en retriever ved hjælp af RetrievalQA()-metoden fra LangChain-frameworket. Denne genfindingsmetode anbefales til at hente data fra vektorlagre ved hjælp af agenterne som værktøj til at arbejde med databaserne:
state_of_union = Hentning QA. from_chain_type (llm = llm , kæde_type = 'ting og sager' , retriever = docsearch. as_retriever ( )
)
Indlæs et andet datasæt for at integrere agenten med flere datasæt eller vektorlagre:
læsser = WebBaseLoader ( 'https://beta.ruff.rs/docs/faq/' )Gem ruff-datasættet i chromadb'en efter oprettelse af de mindre bidder af dataene med indlejringsvektorerne:
dokumenter = læsser. belastning ( )ruff_tekster = tekstsplitter. split_dokumenter ( dokumenter )
ruff_db = Chroma. fra_dokumenter ( ruff_tekster , indlejringer , samlingsnavn = 'ruff' )
ruff = Hentning QA. from_chain_type (
llm = llm , kædetype = 'ting og sager' , retriever = ruff_db. as_retriever ( )
)
Metode 1: Kombination af agent med Vector Stores
Den første metode til at kombinere både agenter og vektorlagre for at udtrække information er nævnt nedenfor:
Trin 1: Konfigurer værktøjer
Nu hvor vektorlagrene er konfigureret, går vi videre mod at bygge den anden komponent i vores proces, dvs. agent. For at oprette agenten til processen skal du importere bibliotekerne ved hjælp af afhængigheder som agenter, værktøjer osv.
fra langkæde. agenter importere initialize_agentfra langkæde. agenter importere AgentType
#Få værktøjer fra LangChain til at bygge agenten
fra langkæde. værktøjer importere BaseTool
fra langkæde. llms importere OpenAI
#Få LLMMathChain fra kæder til at bygge sprogmodellen
fra langkæde. kæder importere LLMMathChain
fra langkæde. forsyningsselskaber importere SerpAPIWrapper
fra langkæde. agenter importere Værktøj
Konfigurer de værktøjer, der skal bruges sammen med agenterne ved hjælp af QA-systemet eller hentning, der er konfigureret tidligere, med navn og beskrivelse af værktøjerne:
værktøjer = [Værktøj (
navn = 'State of Union QA System' ,
func = state_of_union. løb ,
beskrivelse = 'Giver svar på spørgsmålene relateret til det indlæste datasæt med input som et fuldt udformet spørgsmål' ,
) ,
Værktøj (
navn = 'Ruff QA System' ,
func = ruff. løb ,
beskrivelse = 'Giver svar på spørgsmålene om ruff (en python linter) med input som et fuldt udformet spørgsmål' ,
) ,
]
Trin 2: Initialiser agent
Når værktøjerne er konfigureret, skal du blot sætte agenten i argumentet for initializa_agent()-metoden. Agenten vi bruger her er ZERO_SHOT_REACT_DESCRIPTION sammen med værktøjerne, llm (sprogmodel) og verbose:
agent = initialize_agent (værktøjer , llm , agent = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ordrig = Rigtigt
)
Trin 3: Test agenten
Udfør blot agenten ved hjælp af run()-metoden, der indeholder spørgsmålet i sit argument:
agent. løb ('Hvad sagde præsident Joe Biden om kanji brown i talen'
)
Følgende skærmbillede viser svaret udtrukket fra begge datalagre ved hjælp af observationen gemt i agentens hukommelse:
Metode 2: Brug af agent som en router
En anden måde at kombinere begge komponenter på er ved at bruge agenten som en router, og følgende forklarer processen:
Trin 1: Konfigurer værktøjer
Brug af agenten som routeren betyder, at RetrievalQA-systemet returnerer output direkte, efterhånden som værktøjerne er konfigureret til at returnere output direkte:
værktøjer = [#konfigurering af de nødvendige værktøjer til at bygge agenten til at hente data fra dataene
Værktøj (
navn = 'State of Union QA System' ,
func = state_of_union. løb ,
beskrivelse = 'Giver svar på spørgsmålene relateret til det indlæste datasæt med input som et komplet spørgsmål' ,
return_direct = Rigtigt ,
) ,
Værktøj (
navn = 'Ruff QA System' ,
func = ruff. løb ,
beskrivelse = 'Giver svar på spørgsmålene om ruff (en python linter) med input som et komplet spørgsmål' ,
return_direct = Rigtigt ,
) ,
]
Trin 2: Initialiser og test agenten
Efter indstilling af værktøjerne skal du blot indstille agenten, som udelukkende kan bruges som routeren ved hjælp af initialize_agent() metoden:
agent = initialize_agent (værktøjer , llm , agent = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ordrig = Rigtigt
)
Test agenten ved at give inputspørgsmålet i metoden agent.run() ved at udføre følgende kommando:
agent. løb ('Hvad sagde præsident Joe Biden om kanji brown i talen'
)
Produktion
Outputskærmbilledet viser, at agenten simpelthen har returneret svaret på spørgsmålet fra datasættet, der er udtrukket af RetrievalQA-systemet:
Metode 3: Brug af agent med Multi-Hop Vector Store
Den tredje metode, hvor udviklerne kan kombinere både agent- og vektorlagre, er for multi-hop vektorlagerforespørgsler. Det følgende afsnit forklarer hele processen:
Trin 1: Konfigurer værktøjer
Det første trin er, som sædvanligt, konfigurationen af værktøjer, der bruges til at bygge agenterne til at udtrække data fra datalagrene:
værktøjer = [Værktøj (
navn = 'State of Union QA System' ,
func = state_of_union. løb ,
beskrivelse = 'Giver svar på spørgsmålene relateret til det indlæste datasæt med input som et fuldt udformet spørgsmål, uden at henvise til nogen pronominer fra den forrige samtale' ,
) ,
Værktøj (
navn = 'Ruff QA System' ,
func = ruff. løb ,
beskrivelse = 'Giver svar på spørgsmålene relateret til det indlæste datasæt med input som et fuldt udformet spørgsmål, uden at henvise til nogen pronominer fra den forrige samtale' ,
) ,
]
Trin 2: Initialiser og test agenten
Byg derefter agentvariablen ved hjælp af initialize_agent() metoden med navnet på agenten:
agent = initialize_agent (værktøjer , llm , agent = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ordrig = Rigtigt
)
Kør agenten ved hjælp af multi-hop-spørgsmålet, der indeholder mere end ét aspekt eller funktion, da følgende kodeblok indeholder et sådant spørgsmål:
agent. løb ('Hvilket værktøj bruger ruff til at køre over Python-notebooks, og har nogen af talerne nævnt værktøjet i deres adresse'
)
Produktion
Følgende skærmbillede antyder, at agenten skal arbejde sig igennem spørgsmålet for at forstå dets kompleksitet. Det har returneret svaret, der er udtrukket af QA-systemet fra de flere datalagre, vi uploadede tidligere i processen:
Det handler om, hvordan man kombinerer agenter og vektorbutikker i LangChain.
Konklusion
For at kombinere agenter med vektorlagrene i LangChain, start med installationen af moduler til at opsætte miljøet og indlæse datasæt. Konfigurer vektorlagrene til at indlæse data ved først at opdele dem i mindre bidder og derefter bygge sprogmodellen ved hjælp af OpenAI()-metoden. Konfigurer agenten til at integrere den med vektorlageret for at udtrække data til forskellige slags forespørgsler. Denne artikel har uddybet processen med at kombinere midler og vektorbutikker i LangChain.