LangChain / RAG / vektordatabaser · leksjon

LangChain-agenter og verktøykonsepter

Forstå hvordan LangChain Agents kan resonnere og bruke verktøy til å utføre komplekse oppgaver utover enkel spørsmålsbesvarelse.

Leksjon 1 av 412 trinn

LangChain-agenter og verktøykonsepter er en gratis leksjon i LangChain / RAG / vektordatabaser på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i LangChain / RAG / vektordatabaser, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i LangChain / RAG / vektordatabaser inneholder totalt 4 leksjoner.

Hva er LangChain Agents?

Velkommen til Agents! Så langt har du lært å bygge kjeder som utfører en fast sekvens med trinn. Men hva om du trenger mer fleksibilitet?

LangChain Agents er systemer som lar en LLM bestemme dynamisk hvilke handlinger den skal utføre, observere resultatene og deretter velge neste handling. Tenk på dem som å gi LLM-en en «hjerne» til å resonnere og «hender» til å samhandle med verden.

Agentens resonnementssløyfe

Agenter arbeider i en kontinuerlig Observer–Tenk–Handle-sløyfe:

Observer: Agenten mottar et inndata (spørringen din) og resultatene fra den siste handlingen.
Tenk: LLM-en resonerer rundt den nåværende situasjonen og bestemmer hva den skal gjøre videre.
Handle: Agenten utfører en handling, ofte ved å bruke et verktøy.

Denne sløyfen fortsetter til agenten avgjør at den har nok informasjon til å svare på spørsmålet ditt eller fullføre oppgaven.

Introduksjon til verktøy

En LLM alene har bare tilgang til kunnskapen den ble trent på. For å utføre handlinger i den virkelige verden eller få tilgang til oppdatert informasjon trenger den verktøy.

Verktøy er funksjoner eller API-er som en agent kan kalle. De utvider LLM-ens funksjonalitet og gjør det mulig å:

Søke på internett etter aktuelle hendelser.
Utføre beregninger.
Spørre databaser.
Samhandle med andre applikasjoner.

Et verktøys anatomi

Hvert verktøy trenger noen viktige opplysninger for at agenten skal kunne bruke det effektivt:

Navn: En unik identifikator (for eksempel «Google Search»).
Beskrivelse: En tydelig forklaring på hva verktøyet gjør, og når det bør brukes. Dette er avgjørende for LLM-ens resonnement.
Inndataskjema: Hvilken type inndata verktøyet forventer (for eksempel en tekststreng med et søk eller to tall).

LLM-en leser beskrivelsene for å avgjøre hvilket verktøy som passer til et bestemt trinn.

Vanlige innebygde verktøy

LangChain tilbyr mange verktøy som kan brukes direkte. Her er et par populære eksempler:

SerpAPIWrapper: Lar agenten utføre Google-søk. Nyttig for aktuell informasjon eller spesifikke datapunkter.
LLMMathChain: Gjør det mulig for agenten å utføre matematiske beregninger. Dette er mer pålitelig enn å be LLM-en utføre komplisert matematikk direkte.

Disse verktøyene fungerer som programtillegg som gir agenten superkrefter!

Konfigurere en enkel agent

For å opprette en agent trenger du vanligvis:

En LLM (for eksempel ChatOpenAI).
En liste over verktøy agenten kan bruke.
En agenttype eller en ledetekst som definerer hvordan agenten skal resonnere (for eksempel ReAct-rammeverket).

La oss klargjøre disse komponentene for å bygge en agent som kan regne!

Agenten i praksis: Kalkulator

Her er et Python-eksempel på en agent som bruker et tilpasset «Calculator»-verktøy. LLM-en avgjør når verktøyet skal brukes, basert på spørsmålet.

Merk: I en virkelig applikasjon bør eval() erstattes med en sikker matematisk parser.

import os
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent, Tool
from langchain import hub

# Ensure OPENAI_API_KEY is set in your environment variables

def get_calculator_tool():
    """A simple calculator tool."""
    def calculate(expression: str) -> str:
        try:
            # DANGER: In real apps, use safer math parsers!
            return str(eval(expression))
        except Exception as e:
            return f"Error: {e}"

    return Tool(
        name="Calculator",
        func=calculate,
        description="Useful for when you need to answer questions about math. Input should be a mathematical expression."
    )

def main():
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    tools = [get_calculator_tool()]
    prompt = hub.pull("hwchase17/react") # ReAct agent prompt

    agent = create_react_agent(llm, tools, prompt)
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

    print("--- Agent Running ---")
    result = agent_executor.invoke({"input": "What is 123 + 456?"})
    print("\n--- Agent Result ---")
    print(result["output"])

if __name__ == "__main__":
    main()

Sporing av agentens tankeprosess

Når du kjører en agent med verbose=True, viser LangChain agentens interne monolog:

Thought: LLM-ens resonnement rundt den nåværende situasjonen.
Action: Verktøyet agenten velger å bruke, og inndataene til det.
Observation: Resultatet som verktøyet returnerer.

Dette sporet hjelper deg med å forstå hvordan agenten kom frem til svaret, og med å feilsøke atferden.

Ulike agenttyper

LangChain støtter flere agenttyper, hver med sin egen strategi for resonnement:

zero-shot-react-description: En generell agent som bruker ReAct-rammeverket. Den er i stor grad avhengig av verktøybeskrivelser.
OpenAIFunctionsAgent: Utnytter OpenAIs innebygde funksjonskall, noe som ofte gir mer robust og kortfattet bruk av verktøy.
Det finnes også andre typer for bestemte bruksområder eller modeller.

Valget av riktig agenttype avhenger av LLM-en og oppgavens kompleksitet.

Agenters begrensninger og hensyn

Selv om agenter er kraftige, har de begrensninger:

Kostnad og ventetid: Flere kall til LLM-en og verktøy kan øke kostnadene og svartiden.
Pålitelighet: Agenter kan fortsatt «hallusinere» eller bruke verktøy feil hvis beskrivelsene ikke er presise, eller LLM-en har problemer med komplekst resonnement.
Sikkerhet: Verktøy som samhandler med eksterne systemer (for eksempel eval() eller API-er) må håndteres nøye for å forhindre sårbarheter.

Utform verktøyene og ledetekstene nøye!

Test av agentbegreper

Hvilke av følgende påstander om LangChain Agents og Tools er SANNE?

Besvar den i den interaktive leksjonen

Oppsummering: Agentenes kraft

Du har lært at LangChain Agents gjør det mulig for LLM-er å gå lenger enn enkel spørsmålsbesvarelse ved å la dem:

Resonnere dynamisk gjennom en «Observer–Tenk–Handle»-sløyfe.
Bruke verktøy til å samhandle med eksterne data og tjenester.
Utføre komplekse oppgaver som krever flere trinn og ekstern samhandling.

Denne kombinasjonen gjør agenter svært allsidige når du skal bygge intelligente applikasjoner!

Gratis å komme i gang

Lær deg LangChain / RAG / vektordatabaser med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «LangChain-agenter og verktøykonsepter» gratis?

Ja – hele teksten i «LangChain-agenter og verktøykonsepter» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av LangChain / RAG / vektordatabaser-kurset, kan du oppgradere til CoddyKit PRO. Kurset i LangChain / RAG / vektordatabaser inneholder totalt 4 leksjoner.

Hva lærer jeg i «LangChain-agenter og verktøykonsepter»?

Forstå hvordan LangChain Agents kan resonnere og bruke verktøy til å utføre komplekse oppgaver utover enkel spørsmålsbesvarelse. Du øver på LangChain / RAG / vektordatabaser med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med LangChain / RAG / vektordatabaser?

Ingen tidligere erfaring er nødvendig. LangChain / RAG / vektordatabaser på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «LangChain-agenter og verktøykonsepter»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne LangChain / RAG / vektordatabaser-leksjonen?

Ja. Alle LangChain / RAG / vektordatabaser-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

LangChain-agenter og verktøykonsepter
Bygging av arbeidsflyter for multi-agent-RAG
Integrering av eksterne API-er som verktøy
Minne og tilstand i agentisk RAG

← Tilbake til LangChain / RAG / vektordatabaser