Rask oversikt
Dette innlegget vil vise:
Hvordan bruke en agent til å returnere en strukturert utgang i LangChain
- Installere Frameworks
- OpenAI-miljø
- Opprette en vektorbutikk
- Sette banen
- Laste og dele dataene
- Opprette en Retriever
Metode 1: Kombiner agent med Vector Stores
Metode 2: Bruke Agent som en ruter
Metode 3: Bruke agent med Multi-Hop Vector Store
Hvordan bruke en agent til å returnere en strukturert produksjon i LangChain?
Utvikleren bruker agenter for å rute mellom databasene som inneholder treningsdata for modellene. En agent har blåkopi av hele prosessen ved å lagre alle trinnene. Agenten har verktøyene til å utføre alle disse aktivitetene for å fullføre prosessen. Brukeren kan også bruke agenten til å hente data fra forskjellige datalagre for å gjøre modellen mangfoldig.
For å lære prosessen med å kombinere agenter og vektorbutikker i LangChain, følg ganske enkelt trinnene i listen:
Trinn 1: Installere Frameworks
Installer først LangChain-modulen og dens avhengigheter for å kombinere agenter og vektorlagre:
pip installer langkjede 
I denne veiledningen bruker vi Chroma-databasen som kan lagre data på forskjellige steder eller tabeller:
pip installer chromadb 
For å få en bedre forståelse av data, del de store filene i mindre biter ved å bruke tiktoken tokenizer:
pip installer tiktoken 
OpenAI er modulen som kan brukes til å bygge den store språkmodellen i LangChain-rammeverket:
pip installer openai 
Trinn 2: OpenAI-miljø
Neste steg her er å sette opp miljøet ved å bruke OpenAIs API-nøkkel som kan trekkes ut fra den offisielle OpenAI-kontoen:
import duimport få pass
du . omtrent [ 'OPENAI_API_KEY' ] = få pass . få pass ( 'OpenAI API Key:' )
Last opp dataene fra det lokale systemet til Google-samarbeidet for å bruke dem i fremtiden:
fra Google. ET AL import filerlastet opp = filer. laste opp ( )
Trinn 3: Opprette en vektorbutikk
Dette trinnet konfigurerer den første komponenten i oppgaven vår, som er et vektorlager for lagring av opplastede data. Konfigurering av vektorlagrene krever bibliotekene som kan importeres fra forskjellige avhengigheter av LangChain:
fra langkjede. innstøpinger . openai import ÅpneAIEbeddings#Vector lagrer avhengighet for å få den nødvendige databasen eller vektoren
fra langkjede. vektorbutikker import Chroma
#Tekstsplitter brukes til å konvertere den store teksten til mindre biter
fra langkjede. tekstsplitter import CharacterTextSplitter
fra langkjede. llms import OpenAI
fra langkjede. document_loaders import WebBaseLoader
fra langkjede. kjeder import Henting QA
llm = OpenAI ( temperatur = 0 )
Trinn 4: Angi banen
Etter å ha importert bibliotekene, sett bare banen for tilgang til vektorlagrene før du lagrer dataene i den:
fra stilib import Stirelevante_deler = [ ]
til s i Sti ( '.' ) . absolutt ( ) . deler :
relevante_deler. legge til ( s )
hvis relevante_deler [ - 3 : ] == [ 'langkjede' , 'dokumenter' , 'moduler' ] :
gå i stykker
#Conditional Statement inne i loopen for å angi banen for hver database
doc_path = str ( Sti ( *relevante_deler ) / 'state_of_the_union.txt' )
Trinn 5: Laste og dele dataene
Nå er det bare å laste inn dataene og dele dem opp i mindre biter for å gjøre lesbarheten og forståeligheten bedre. Lag innbygginger av dataene ved å konvertere teksten til tall som lager vektorrom og lagre den i Chorma-databasen:
fra langkjede. document_loaders import TextLoader#Laster datasettet fra banen og lagrer de mindre delene i databasen
laster = TextLoader ( doc_path )
dokumenter = laster. laste ( )
tekstsplitter = CharacterTextSplitter ( chunk_size = 2000 , chunk_overlapp = 0 )
tekster = tekstsplitter. del_dokumenter ( dokumenter )
#Konverter tekst til tall og lagre innebyggingene i databasen
innstøpinger = ÅpneAIEbeddings ( )
docsearch = Chroma. fra_dokumenter ( tekster , innstøpinger , samlingsnavn = 'state-of-union' )
Trinn 6: Opprette en Retriever
For å kombinere agent- og vektorlagre, er det nødvendig å opprette en retriever ved å bruke RetrievalQA()-metoden fra LangChain-rammeverket. Denne gjenfinningsmetoden anbefales for å hente data fra vektorlagre ved å bruke agentene som verktøy for å jobbe med databasene:
state_of_union = Henting QA. from_chain_type (llm = llm , kjedetype = 'ting' , retriever = docsearch. as_retriever ( )
)
Last inn et annet datasett for å integrere agenten med flere datasett eller vektorlagre:
laster = WebBaseLoader ( 'https://beta.ruff.rs/docs/faq/' )Lagre ruff-datasettet i chromadb-en etter å ha opprettet de mindre delene av dataene med innebyggingsvektorene også:
dokumenter = laster. laste ( )ruff_tekster = tekstsplitter. del_dokumenter ( dokumenter )
ruff_db = Chroma. fra_dokumenter ( ruff_tekster , innebygginger , samlingsnavn = 'ruff' )
ruff = Henting QA. from_chain_type (
llm = llm , kjedetype = 'ting' , retriever = ruff_db. as_retriever ( )
)
Metode 1: Kombiner agent med Vector Stores
Den første metoden for å kombinere både agenter og vektorlagre for å trekke ut informasjon er nevnt nedenfor:
Trinn 1: Konfigurer verktøy
Nå som vektorlagrene er konfigurert, går vi videre mot å bygge den andre komponenten i prosessen vår, dvs. agent. For å opprette agenten for prosessen, importer bibliotekene ved hjelp av avhengigheter som agenter, verktøy osv.
fra langkjede. agenter import initialize_agentfra langkjede. agenter import AgentType
#Få verktøy fra LangChain for å bygge agenten
fra langkjede. verktøy import BaseTool
fra langkjede. llms import OpenAI
#Å få LLMMathChain fra kjeder til å bygge språkmodellen
fra langkjede. kjeder import LLMMathChain
fra langkjede. verktøy import SerpAPIWrapper
fra langkjede. agenter import Verktøy
Konfigurer verktøyene som skal brukes med agentene ved å bruke QA-systemet eller gjenfinning konfigurert tidligere med navn og beskrivelse av verktøyene:
verktøy = [Verktøy (
Navn = 'State of Union QA System' ,
func = state_of_union. løpe ,
beskrivelse = 'Gir svar på spørsmålene knyttet til det lastede datasettet med inndata som et fullstendig utformet spørsmål' ,
) ,
Verktøy (
Navn = 'Ruff QA System' ,
func = ruff. løpe ,
beskrivelse = 'Gir svar på spørsmålene om ruff (en python linter) med input som et fullstendig utformet spørsmål' ,
) ,
]
Trinn 2: Initialiser agent
Når verktøyene er konfigurert, setter du bare agenten i argumentet til initializa_agent()-metoden. Agenten vi bruker her er ZERO_SHOT_REACT_DESCRIPTION sammen med verktøyene, llm (språkmodell) og verbose:
middel = initialize_agent (verktøy , llm , middel = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ordrik = ekte
)
Trinn 3: Test agenten
Bare kjør agenten ved å bruke run()-metoden som inneholder spørsmålet i argumentet:
middel. løpe ('Hva sa president Joe Biden om kanji brown i adressen'
)
Følgende skjermbilde viser svaret hentet fra begge datalagrene ved hjelp av observasjonen som er lagret i agentens minne:
Metode 2: Bruke Agent som en ruter
En annen måte å kombinere begge komponentene på er å bruke agenten som en ruter, og følgende forklarer prosessen:
Trinn 1: Konfigurer verktøy
Å bruke agenten som ruteren betyr at RetrievalQA-systemet vil returnere utdataene direkte ettersom verktøyene er konfigurert til å returnere utdataene direkte:
verktøy = [#configuring verktøyene som kreves for å bygge agenten for å hente data fra dataene
Verktøy (
Navn = 'State of Union QA System' ,
func = state_of_union. løpe ,
beskrivelse = 'Gir svar på spørsmålene knyttet til det innlastede datasettet med inndata som et komplett spørsmål' ,
retur_direkte = ekte ,
) ,
Verktøy (
Navn = 'Ruff QA System' ,
func = ruff. løpe ,
beskrivelse = 'Gir svar på spørsmålene om ruff (en python linter) med inndata som et komplett spørsmål' ,
retur_direkte = ekte ,
) ,
]
Trinn 2: Initialiser og test agenten
Etter å ha angitt verktøyene, still inn agenten som kun kan brukes som ruteren ved å bruke initialize_agent()-metoden:
middel = initialize_agent (verktøy , llm , middel = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ordrik = ekte
)
Test agenten ved å gi inndataspørsmålet i agent.run()-metoden ved å utføre følgende kommando:
middel. løpe ('Hva sa president Joe Biden om kanji brown i adressen'
)
Produksjon
Utdataskjermbildet viser at agenten ganske enkelt har returnert svaret på spørsmålet fra datasettet hentet ut av RetrievalQA-systemet:
Metode 3: Bruke agent med Multi-Hop Vector Store
Den tredje metoden der utviklerne kan kombinere både agent- og vektorlagre, er for multi-hop vektorlagerforespørsler. Følgende avsnitt forklarer hele prosessen:
Trinn 1: Konfigurer verktøy
Det første trinnet er, som vanlig, konfigurasjonen av verktøyene som brukes til å bygge agentene for å trekke ut data fra datalagrene:
verktøy = [Verktøy (
Navn = 'State of Union QA System' ,
func = state_of_union. løpe ,
beskrivelse = 'Gir svar på spørsmålene knyttet til det lastede datasettet med inndata som et fullstendig spørsmål, uten å referere til noen pronomen fra forrige samtale' ,
) ,
Verktøy (
Navn = 'Ruff QA System' ,
func = ruff. løpe ,
beskrivelse = 'Gir svar på spørsmålene knyttet til det lastede datasettet med inndata som et fullstendig spørsmål, uten å referere til noen pronomen fra forrige samtale' ,
) ,
]
Trinn 2: Initialiser og test agenten
Deretter bygger du agentvariabelen ved å bruke initialize_agent()-metoden med navnet på agenten:
middel = initialize_agent (verktøy , llm , middel = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ordrik = ekte
)
Kjør agenten ved å bruke multi-hop-spørsmålet som inneholder mer enn ett aspekt eller funksjon, da følgende kodeblokk inneholder et slikt spørsmål:
middel. løpe ('Hvilket verktøy bruker ruff for å kjøre over Python-notatbøker, og nevnte noen av høyttalerne verktøyet i adressen sin'
)
Produksjon
Følgende skjermbilde antyder at agenten må jobbe gjennom spørsmålet for å forstå dets kompleksitet. Den har returnert svaret hentet ut av QA-systemet fra de flere datalagrene vi lastet opp tidligere i prosessen:
Det handler om hvordan man kombinerer agenter og vektorbutikker i LangChain.
Konklusjon
For å kombinere agenter med vektorlagrene i LangChain, start med installasjon av moduler for å sette opp miljøet og laste inn datasett. Konfigurer vektorlagrene til å laste data ved å dele dem i mindre biter først og deretter bygge språkmodellen ved å bruke OpenAI()-metoden. Konfigurer agenten til å integrere den med vektorlageret for å trekke ut data for forskjellige typer spørringer. Denne artikkelen har utdypet prosessen med å kombinere agenter og vektorbutikker i LangChain.