Claude Architect · Lektion

Det centrale loop

request til stop_reason til værktøjskørsel til tilføjelse af historik

Lektion 1 af 413 trin

Det centrale loop er en gratis Claude Architect-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Claude Architect, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Claude Architect-kurset indeholder 4 lektioner i alt.

Hvorfor overhovedet en løkke?

Et enkelt kald til Claude returnerer ét svar. Men virkelige agenter skal handle: slå noget op, køre et værktøj og derefter fortsætte. Den agentiske løkke er den motor, der får dette til at ske.

Selve modellen er tilstandsløs — den gemmer ingen hukommelse mellem kald. Din kode holder styr på samtalen og beslutter, hvornår den skal fortsætte, og hvornår den skal stoppe. Når du mestrer denne løkke, har du mestret grundlaget, som alle Claude-agenter bygges på.

I denne lektion følger du én hel omgang: anmodning → stop_reason → kørsel af værktøj → tilføjelse til historikken, gentaget efter behov.

Anmodningen: Hele historikken ved hver omgang

Fordi modellen ikke gemmer nogen tilstand, skal du sende hele samtalehistorikken med ved hver anmodning. De vigtigste felter i en anmodning til Messages API:

model — hvilken Claude-model
max_tokens — grænsen for output
system — de vedvarende instruktioner
messages — hele historikken (bruger, assistent, værktøjsresultater)
tools — definitioner af de værktøjer, modellen må kalde
tool_choice — auto, any eller et gennemtvunget værktøj

Hvis du glemmer at føje en omgang til messages, kan modellen ganske enkelt ikke se den. Historikken er agentens hukommelse.

from anthropic import Anthropic

client = Anthropic()
messages = [{"role": "user", "content": "What is the weather in Paris?"}]

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    system="You are a helpful travel assistant.",
    tools=tools,
    messages=messages,
)

Undersøg stop_reason

Efter hvert svar er det første, du skal kontrollere, stop_reason. Det fortæller dig præcis, hvorfor modellen stoppede, og hvad du skal gøre som det næste:

end_turn — modellen er færdig. Stop løkken.
tool_use — modellen vil have kørt et værktøj. Kør det, tilføj resultatet, og kald igen.
max_tokens — outputtet blev afkortet. Hæv grænsen, eller stream outputtet.
stop_sequence — en tilpasset stopstreng blev fundet.

stop_reason er løkkens styresignal. Alt, agenten gør derefter, styres af dette ene felt — aldrig af at læse teksten.

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    tools=tools,
    messages=messages,
)

print(response.stop_reason)  # "tool_use" | "end_turn" | "max_tokens" | ...

tool_use: Modellen anmoder om en handling

Når stop_reason er tool_use, indeholder svarindholdet en eller flere tool_use-blokke. Hver blok indeholder:

id — en unik id, som du skal sende tilbage
name — hvilket værktøj der skal køres
input — argumenterne (allerede fortolket for dig af SDK'et)

Modellen har besluttet, hvad der skal kaldes, og med hvilke argumenter. Den har ikke kørt noget — Claude kører aldrig dine værktøjer. Det er din kode, der skal køre dem. Modellen anmoder kun; din runtime udfører.

for block in response.content:
    if block.type == "tool_use":
        print(block.name)   # "get_weather"
        print(block.input)  # {"city": "Paris"}
        print(block.id)     # "toolu_01A..." -> echo this back

Kør værktøjet i din kode

Du knytter værktøjets name til en rigtig funktion og kører den med modellens input. Dette foregår udelukkende hos dig — i din database, dine API'er og din forretningslogik.

Det er også her, garantierne hører hjemme. Modellen beslutter, hvilket værktøj der skal kaldes, men deterministisk kode beslutter, om det må køres — identitetskontrol, forbrugsgrænser og tilladelsesgateways. Beslutningerne er modelstyrede; hårde garantier skal ligge i koden.

def execute_tool(name, tool_input):
    if name == "get_weather":
        return get_weather(**tool_input)
    if name == "lookup_order":
        return lookup_order(**tool_input)
    raise ValueError(f"Unknown tool: {name}")

Tilføj assistentens omgang OG værktøjsresultatet

Nu udvider du historikken. Der sker to tilføjelser i denne rækkefølge:

Først tilføjer du assistentens fulde response.content — det bevarer tool_use-blokkene.
Derefter tilføjer du en brugermeddelelse med en tool_result-blok for hvert kald, hver med det matchende tool_use_id.

Tilføj hele content, ikke kun teksten — hvis du fjerner tool_use-blokkene, brydes sammenknytningen, og det næste kald mislykkes.

messages.append({"role": "assistant", "content": response.content})

tool_results = []
for block in response.content:
    if block.type == "tool_use":
        result = execute_tool(block.name, block.input)
        tool_results.append({
            "type": "tool_result",
            "tool_use_id": block.id,
            "content": str(result),
        })

messages.append({"role": "user", "content": tool_results})

Gentag indtil end_turn

Nu hvor værktøjsresultatet ligger i historikken, kalder du API'et igen. Modellen ser resultatet og fortsætter — måske svarer den, måske kalder den et andet værktøj. Du undersøger stop_reason igen og gør det samme.

Det er hele løkken: anmodning → undersøg stop_reason → hvis tool_use, kør værktøjer og tilføj resultater → gentag indtil end_turn. Cyklussen fortsætter med så mange værktøjskald, som opgaven kræver, og slutter derefter naturligt, når modellen returnerer end_turn.

while True:
    response = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    if response.stop_reason == "end_turn":
        break
    if response.stop_reason == "tool_use":
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": run_tools(response)})

Afslut med stop_reason, aldrig med tekst

Her er løkkens vigtigste regel: afslut med stop_reason, aldrig ved at lede efter ord som "færdig" eller "afsluttet" i teksten.

At læse den synlige tekst for at beslutte, hvornår du skal stoppe, er et klassisk anti-mønster. Modellen kan sige "Jeg er færdig!" midt i en tanke, eller aldrig sige det, eller sige det i en sætning, der faktisk ikke markerer slutningen. stop_reason er et struktureret og pålideligt signal; fri tekst er ikke.

Hvis du opdager, at du skriver if "done" in response_text, så stop — du bygger på et usikkert grundlag.

# ANTI-PATTERN -- do NOT do this
if "done" in text.lower():
    break

# CORRECT -- structured signal
if response.stop_reason == "end_turn":
    break

Gentagelsesgrænser er et sikkerhedsnet, ikke bremsen

En robust løkke har normalt et maksimalt antal gentagelser — men forstå dens rolle. Grænsen er et sikkerhedsnet, der skal forhindre en løbsk løkke, ikke den primære stopmekanisme.

Den primære og forventede måde, løkken slutter på, er end_turn. Grænsen udløses kun i unormale situationer. At behandle en vilkårlig gentagelsesgrænse som den primære måde at stoppe på er et anti-mønster: Det afbryder legitimt arbejde og skjuler, at modellen aldrig afsluttede naturligt.

MAX_ITERS = 10  # safety net only

for i in range(MAX_ITERS):
    response = client.messages.create(...)
    if response.stop_reason == "end_turn":
        break          # the PRIMARY exit
    # ... run tools, append ...
else:
    log.warning("Hit iteration cap -- investigate, do not treat as normal")

Modelstyrede beslutninger, kodehåndhævede garantier

Grundløkken fordeler ansvaret klart:

Modellen beslutter, hvad der skal gøres — hvilket værktøj, hvilke argumenter, og hvornår opgaven er færdig (end_turn).
Din kode håndhæver garantier — hvad der må køres, forbrugsgrænser, identitetsbekræftelse og sikkerhedsnettets grænse.

Brug hårdkodet styring til det, der skal garanteres (en tilbagebetaling over en grænse, en destruktiv handling). Lad modellen styre de fleksible dele, der kræver mange beslutninger. For stramme begrænsninger med rigid kode gør agenten skrøbelig; for få begrænsninger på kritiske handlinger gør den usikker.

En komplet minimal løkke

Her er hele grundløkken samlet ét sted. Læs den fra top til bund — alle begreber fra denne lektion er med: fuld historik ved hver omgang, undersøgelse af stop_reason, kørsel af værktøjer, tilføjelse af både assistentens omgang og værktøjsresultater samt afslutning ved end_turn med en gentagelsesgrænse som sikkerhedsforanstaltning.

Det samme skelet kan skaleres fra en hjælper med ét værktøj til en kompleks agent med flere trin. Løkken ændrer sig aldrig; kun værktøjerne og opgaven gør.

messages = [{"role": "user", "content": user_query}]

for _ in range(MAX_ITERS):
    response = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    if response.stop_reason == "end_turn":
        break

    messages.append({"role": "assistant", "content": response.content})
    results = []
    for block in response.content:
        if block.type == "tool_use":
            out = execute_tool(block.name, block.input)
            results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": str(out),
            })
    messages.append({"role": "user", "content": results})

final_text = next(b.text for b in response.content if b.type == "text")

Hurtigt tjek: Hvornår stopper løkken?

En arkitekt gennemgår en kollegas agent. Løkken læser teksten i hvert svar og afbryder, når den indeholder formuleringen "opgaven er færdig". Den har også en hård grænse på 3 gentagelser som den primære måde, den afslutter på. Hvilken ændring løser bedst problemet i designet?

Besvar den i den interaktive lektion

Opsummering: Grundløkken

Du har nu styr på grundlaget for alle Claude-agenter:

Tilstandsløs model — send hele messages-historikken ved hver omgang; historikken er hukommelsen.
Undersøg stop_reason først — end_turn stopper, tool_use betyder, at et værktøj skal køres, og max_tokens betyder, at outputtet blev afkortet.
Claude anmoder, din kode udfører — knyt name + input til en funktion, og kør den.
Tilføj begge omgange — assistentens fulde content, derefter et tool_result pr. kald med det matchende tool_use_id.
Afslut med stop_reason, aldrig med tekst; gentagelsesgrænsen er et sikkerhedsnet, ikke bremsen.
Modellen beslutter, koden garanterer.

Gør denne cyklus til en del af din intuition — alle avancerede mønstre i certificeringen bygger direkte på den.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 26
Lektioner: 104

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Det centrale loop” gratis?

Ja — alle 3 lektioner i læringssporet Claude Architect, inklusive “Det centrale loop”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Claude Architect-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Det centrale loop”?

request til stop_reason til værktøjskørsel til tilføjelse af historik Du øver dig i Claude Architect med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Claude Architect?

Der kræves ingen tidligere erfaring. Claude Architect på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Det centrale loop”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Claude Architect-lektion?

Ja. Alle Claude Architect-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Claude Architect