Logik-byggeklodser
Logik-byggeklodserne styrer selve forløbet i dit flow: hvilke grene der køres, hvordan lister gennemløbes element for element, og hvordan du kører din egen kode, når de færdige byggeklodser ikke rækker. Brug dem til at gøre et flow betinget, gentaget eller dynamisk — i stedet for en lige linje fra input til output.
De to forgrenings-byggeklodser (Hvis / ellers og Forgrening) vælger vej ud fra en værdi. De fire løkke-byggeklodser (Løkke Start, Løkke Slut, Løkke Afbryd, Løkke Spring Over) gennemløber lister element for element. Og Python Kode giver dig fuld fleksibilitet, når intet af det ovenstående rækker.
Hvis / ellers
Byggeklods-id: if-else
Betinget forgrening med brugervenlige betingelser på naturligt sprog: du bygger "Hvis A operator B"-udtryk ud fra forbundne værdier og styrer, hvad der sendes videre til enten "sand"- eller "falsk"-grenen. Kun den gren, der matcher betingelsen, aktiveres; den anden gren springes over, så efterfølgende byggeklodser dér ikke kører.
Inputs
| Felt | Type | Beskrivelse |
|---|---|---|
| Inputs | Forbindelser (dict) | Træk forbindelser fra andre byggeklodser hertil. Værdierne bruges både i betingelsen og som mulige outputs, og bevarer deres oprindelige type (tekst, tal, boolean, JSON). |
| Betingelse | Betingelses-bygger | Definerer hvis/ellers-logikken: én eller flere betingelser (A, operator, B) kombineret med OG/ELLER, samt hvad der sendes til hhv. "sand" og "falsk". En værdi kan enten pege på et forbundet input eller være en fast, statisk værdi. |
Outputs
To udgange, begge af typen any: "Hvis sand" (output_1) modtager den valgte værdi, når betingelsen er opfyldt; "Hvis falsk" (output_2), når den ikke er. Kun én udgang bliver aktiv pr. kørsel — den anden markeres som "sprunget over", så nedstrøms-byggeklodser på den gren ikke udføres.
Operatorer (type vælges automatisk ud fra den valgte operator):
- Tekst: er lig med, er ikke lig med, indeholder, indeholder ikke, er tom, er ikke tom, starter med, slutter med (samt alfabetisk større/mindre end).
- Tal: er lig med (tal), er ikke lig med (tal), er større end (tal), er mindre end (tal), er større end eller lig (tal), er mindre end eller lig (tal).
- Boolean: er sand, er falsk.
- JSON: indeholder nøgle, indeholder ikke nøgle, er tom objekt, er ikke tom objekt, værdi er lig med (format
nøgle=værdi), værdi indeholder (formatnøgle=delstreng).
Adfærd og faldgruber
- Tom betingelse = altid sand: Uden betingelser (eller tomt
config) er resultatet altid "sand"-grenen. - Flere betingelser: Kombineres i rækkefølge med OG (alle skal være sande) eller ELLER (mindst én sand). Logik-vælgeren gælder fra betingelse nr. 2.
- Ugyldig operator er en konfigurationsfejl: En ukendt operator stopper kørslen med en fejl (i stedet for stille at sende flowet ned ad den forkerte gren). Mangler operatoren helt, bruges "er lig med".
- Type-uegnede data giver falsk: Kan en værdi ikke konverteres (fx ikke-numerisk tekst mod en
(tal)-operator), tælles betingelsen som falsk, og det logges.
Typiske brugsscenarier
- Send tekst videre kun hvis den indeholder et bestemt nøgleord (fx dokumenter, hvor "opsigelse" optræder).
- Forgren på en talgrænse — fx beløb større end 10000 til manuel godkendelse, ellers automatisk.
- Reager på et boolean-flag fra en tidligere byggeklods (fx "godkendt: sand/falsk").
- Tjek et felt i et JSON-svar (findes nøglen? er værdien lig med noget bestemt?).
Brug når / Undlad når
- Brug når du skal træffe en binær ja/nej-beslutning, eller sammenligne med type-bevidste operatorer (tal, boolean, JSON).
- Undlad når du har mere end to grene — brug Forgrening til værdi-matching mod flere tilfælde, eller Python Kode til mange grene, regex og mere kompleks logik.
Relaterede byggeklodser: Logik-byggeklodser (bl.a. Forgrening) · Oversigt over byggeklodser
Forgrening
Byggeklods-id: switch
Sammenligner en indgående værdi med op til fire tilfælde og sender værdien videre ad den første gren, der matcher eksakt; matcher intet tilfælde, sendes værdien til Standard-grenen.
Inputs
| Felt | Type | Beskrivelse |
|---|---|---|
| Værdi | str | Værdien der skal matches |
| Tilfælde 1 | str | Første match-værdi (tomt felt ignoreres) |
| Tilfælde 2 | str | Anden match-værdi (tomt felt ignoreres) |
| Tilfælde 3 | str | Tredje match-værdi (tomt felt ignoreres) |
| Tilfælde 4 | str | Fjerde match-værdi (tomt felt ignoreres) |
Outputs
Fem udgange, alle af typen str: Tilfælde 1–4 (output_1–output_4) og Standard (output_5). Kun én udgang aktiveres pr. kørsel — den modtager den indgående værdi, mens de øvrige udgange springes over (SKIPPED). Tilfældene evalueres i rækkefølge (1 → 2 → 3 → 4), og det første eksakte match vinder; tomme tilfælde springes over. Matcher intet tilfælde, sendes værdien til Standard.
Typiske brugsscenarier
- Rut et dokument eller en sag videre efter en kategori- eller statusværdi (fx "Ansøgning", "Klage", "Afslag") til hver sin efterfølgende gren.
- Send output fra en klassificerings- eller AI-node ned ad forskellige behandlingsveje afhængigt af den valgte label.
- Håndtér op til fire kendte værdier eksplicit og lad alt øvrigt falde til Standard-grenen som fælles fallback.
Brug når / Undlad når
- Brug når du har flere (op til 4) kendte, faste værdier, du vil forgrene på med simpel, eksakt tekstlighed.
- Undlad når du kun har to udfald (sand/falsk) — brug Hvis / ellers i stedet, som også er nødvendig for tal-, boolean- eller JSON-sammenligninger og operatorer som "indeholder" eller "større end".
- Undlad når du har mere end fire grene eller skal bruge mønstre/regex — brug i stedet en kodenode.
Relaterede byggeklodser: Logik-byggeklodser
Løkke Start
Byggeklods-id: for_each_start · parres med Løkke Slut
Starter en løkke, der itererer over elementerne i en liste inde i JSON-data og udfører byggeklodserne mellem Løkke Start og Løkke Slut én gang per element. Den er en markør-byggeklods: selve iterationen håndteres af flow-motoren, og den skal parres med en Løkke Slut.
Inputs
| Felt | Type | Beskrivelse |
|---|---|---|
| JSON Data | tekst / liste / objekt | JSON-objekt, array eller liste fra en anden byggeklods (fx et API-svar eller CSV-parsing). Påkrævet. |
| Sti til elementer | tekst | Sti til listen, der skal løbes igennem, fx items eller data.results (indlejrede stier understøttes). Tom = brug rod-elementet, hvis det selv er en liste. Standard: tom. |
| Fejlhåndtering | valg | Hvad der sker, hvis en iteration fejler: Stop ved fejl (standard) stopper hele kørslen ved første fejl; Fortsæt ved fejl springer det fejlende element over og samler fejlene. |
Outputs
- Nuværende Element (any): elementet i den aktuelle iteration.
- Indeks (heltal): nul-baseret indeks for iterationen.
- Total (heltal): samlet antal elementer i listen.
Typiske brugsscenarier
- Behandl hvert element i et API-svar for sig, fx kald en anden byggeklods per bruger under
data.users. - Kør en LLM- eller struktureret-output-byggeklods per række fra en parset CSV- eller JSON-fil og saml resultaterne med Løkke Slut.
- Iterér over en rod-liste af værdier (tom sti) og transformér hvert element enkeltvis.
Brug når / Undlad når
- Brug når: elementerne ligger inde i et objekt under en nøgle — peg "Sti til elementer" på den (fx
data.results). - Brug når: delvise resultater er bedre end ingen — vælg
Fortsæt ved fejl, så fejlende elementer springes over. - Undlad når: inputtet allerede ER listen — lad "Sti til elementer" stå tom i stedet for at angive en sti.
- Undlad når: du kun har én enkelt værdi, eller kan transformere hele listen på én gang — forbind direkte eller brug Python Kode.
Resultatet af denne byggeklods caches ikke; den fungerer som løkke-markør, og motoren udfører iterationen på ny ved hver kørsel.
Relaterede byggeklodser: Logik-byggeklodser (Løkke Slut, Løkke Afbryd, Løkke Spring Over og Hvis), Data-byggeklodser, Byggeklods-oversigt
Løkke Slut
Byggeklods-id: for_each_end · parres med Løkke Start
Afslutter en løkke og samler værdien fra hver iteration i én liste. Byggeklodsen er en markør, som flow-motoren griber ind i: den indsamler ét resultat pr. gennemløb af den parrede Løkke Start og udsender dem i iterationsrækkefølge.
Inputs
| Felt | Type | Beskrivelse |
|---|---|---|
| Resultat | any | Værdien, der opsamles fra hver iteration. Forbind outputtet fra byggeklodserne, der behandler det aktuelle element inde i løkken. |
Outputs
- Resultater (any): En liste med samtlige opsamlede værdier i den rækkefølge, elementerne blev behandlet. Elementer, der er sprunget over med Løkke Spring Over, optræder som
Nonei listen.
Typiske brugsscenarier
- Kør en AI-byggeklods pr. element i et JSON-array og saml alle svarene i én liste til videre behandling.
- Transformér hvert element (fx normalisér eller berig data) og indsaml de transformerede værdier til et samlet output.
- Kald et eksternt API for hver post i en liste og opsaml alle API-svarene, så de kan sendes videre samlet.
Brug når / Undlad når
- Brug når: du vil have løkkens per-iteration-outputs samlet til én liste, du kan bruge efter løkken.
- Undlad når: løkken kun udfører sideeffekter (fx sender mails) og du ikke behøver de opsamlede værdier — så kan Løkke Slut udelades helt.
- Undlad når: du vil bygge en brugerdefineret datastruktur i stedet for én flad liste — brug Kombiner eller Python Kode.
Byggeklodsen skal parres med en Løkke Start. Ved entydig parring sættes koblingen (loop_id) automatisk; har du flere løkker i samme flow, skal koblingen matche den rigtige Løkke Start.
Relaterede byggeklodser: Logik-byggeklodser (Løkke Start, Løkke Afbryd, Løkke Spring Over), Oversigt over byggeklodser
Løkke Afbryd
Byggeklods-id: loop_break
Stopper hele løkken øjeblikkeligt, når betingelsen er sand — svarende til break i Python/JavaScript. Placeres inde i et Løkke Start/Slut-par; udenfor en løkke giver den en fejl.
Inputs
| Felt | Type | Beskrivelse |
|---|---|---|
| Betingelse | bool | Påkrævet. Når værdien er sand, afbrydes løkken øjeblikkeligt. Forbindes typisk fra en "Hvis"-nodes betingelse-output. |
| Værdi | any | Valgfri (standard: ingen). Den værdi der sendes videre, når betingelsen er falsk. |
Outputs
- Værdi (any): Den gennemgående værdi. Sendes kun videre, når betingelsen er falsk; når betingelsen er sand, stopper løkken i stedet, og der passerer ingen værdi videre.
Typiske brugsscenarier
- Find første match og stop søgningen (f.eks. afbryd så snart et element opfylder et kriterie).
- Begræns behandling til de første N elementer (f.eks. afbryd når indeks er nået en grænse).
- Betinget tidlig afslutning når en bestemt tilstand er opfyldt, for at undgå unødig behandling af resten af listen.
Brug når / Undlad når
- Brug når du vil stoppe hele iterationen så snart en betingelse er opfyldt — allerede behandlede resultater bevares.
- Undlad når du blot vil springe enkelte elementer over uden at stoppe løkken → brug Løkke Spring Over i stedet.
- Undlad når du vil route værdier betinget uden at afbryde løkken → brug Hvis i stedet.
Bemærkninger
- Ved indlejrede løkker afbrydes kun den inderste løkke.
- Byggeklodsen er en kontrol-markør, som løkkemotoren håndterer direkte; resultatet caches ikke.
Relaterede byggeklodser: Logik-byggeklodser (Løkke Start, Løkke Slut, Løkke Spring Over, Hvis) · Oversigt over byggeklodser
Løkke Spring Over
Byggeklods-id: loop_continue
Springer den aktuelle iteration over og fortsætter til næste element, når betingelsen er sand. Placeres inde i et Løkke Start/Slut-par og svarer til continue i Python/JavaScript.
Inputs
| Felt | Type | Beskrivelse |
|---|---|---|
| Betingelse | bool | Når sand, springes den aktuelle iteration over. Forbind typisk en "Hvis"-nodes betingelses-output hertil. |
| Værdi | any | Værdien der sendes videre, når betingelsen er falsk. Valgfri; standard er None. |
Outputs
- Værdi (any): den gennemgående værdi. Sendes kun videre, når betingelsen er falsk; når betingelsen er sand, springes iterationen over, og den overspringede plads bliver
Nonei den samlede resultatliste (fra Løkke Slut).
Typiske brugsscenarier
- Filtrere ugyldige eller irrelevante elementer fra under en iteration (f.eks. spring over når et element er tomt eller markeret som fejl).
- Kun behandle elementer der opfylder et kriterium — spring over resten (f.eks. spring negative tal over).
- Springe problematiske elementer over i stedet for at lade hele løkken fejle.
Brug når / Undlad når
- Brug når: du vil ignorere enkelte elementer men lade resten af løkken køre videre.
- Undlad når: du vil stoppe hele løkken ved første match — brug Løkke Afbryd i stedet.
- Undlad når: filtreringen kan ske før løkken starter — filtrér listen med Python Kode før Løkke Start (mere effektivt).
- Undlad når: du vil route værdier betinget uden at springe over — brug Hvis.
Vigtige bemærkninger
- Skal placeres inde i et Løkke Start/Slut-par; uden for en løkke giver den fejl.
- Ved indlejrede løkker påvirkes kun den inderste løkke.
- Overspringede elementer optræder som
Nonei resultatlisten fra Løkke Slut. - Resultatet caches ikke (byggeklodsen er en løkke-kontrol-markør uden cache).
Relaterede byggeklodser: Logik-byggeklodser (Løkke Start, Løkke Slut, Løkke Afbryd, Hvis) · Oversigt over byggeklodser
Python Kode
Byggeklods-id: python-code
Kør brugerdefineret Python-kode med visuelt definerede inputs og outputs. AgentBase pakker koden ind i en def run(...)-funktion og eksekverer den i et sikkert RestrictedPython-sandbox (maks. 5 sekunders kørsel).
Inputs
| Felt | Type | Beskrivelse |
|---|---|---|
| Inputs & Outputs | str (JSON) | Definér visuelt hvilke input-variabler koden modtager, og hvilke output-variabler den returnerer (navn, type, påkrævet, default). Standard: ét input text (str) og ét output result (str). |
| Kode | str | Selve transformationslogikken. Læs input-variablerne og tildel output-variablerne. Standard: result = text.upper(). |
Ud over de to felter ovenfor tager byggeklodsen dynamiske {felt}-inputs: hvert input, du definerer i signaturen, bliver til et input-handle med samme navn, som kan forbindes fra andre byggeklodser i flowet.
Outputs
Outputtene styres af signaturen: ét defineret output returnerer værdien direkte, flere outputs returneres som et objekt (dict) med ét felt pr. output-navn, og ingen definerede outputs giver None. Byggeklodsens returtype er any (label: Resultat).
Typiske brugsscenarier
- Ad-hoc datatransformation der ikke findes som en dedikeret byggeklods (omform, filtrér, omdøb felter i
list[dict]). - Beregninger og aggregering (summér, procentregn, afstem tal mod en tolerance).
- Tekst- og id-normalisering (rens CVR/kontonumre, parse datoer, sammenlign navne fuzzy).
- Split af ét input i flere navngivne outputs, som efterfølgende byggeklodser kan forbinde til hver for sig.
Brug når / Undlad når
- Brug når: du har brug for skræddersyet logik, som de eksisterende byggeklodser ikke dækker.
- Brug når: du vil transformere strukturerede data (
list[dict]) mellem to trin i flowet. - Undlad når: opgaven kræver netværkskald, filadgang,
import, klasser ellerasync— det er blokeret af sandboxen. - Undlad når: variabel- eller feltnavne skal indeholde æ/ø/å eller foranstillet underscore — sandboxen tillader kun ASCII-navne uden ledende underscore.
Resultatet af denne byggeklods caches ikke — koden køres på ny ved hver eksekvering (byggeklodsen er markeret cacheable=false), så den er egnet til logik med sideeffekter eller ikke-deterministisk output.
Relaterede byggeklodser: Logik-byggeklodser · Data-byggeklodser · Oversigt over byggeklodser
Typiske kæder
Logik-byggeklodserne kombineres oftest sådan:
- Betinget behandling: en Sprogmodel klassificerer et input → Hvis / ellers eller Forgrening sender resultatet ned ad den rigtige gren.
- Behandl en liste: datakilde → Løkke Start → behandling pr. element (fx Sprogmodel) → Løkke Slut samler resultaterne.
- Filtrér eller stop undervejs: inde i en løkke danner Hvis / ellers en betingelse, som Løkke Spring Over (drop elementet) eller Løkke Afbryd (stop løkken) reagerer på.
- Egen logik: Python Kode forbereder eller efterbehandler data — fx normaliserer en liste før Løkke Start eller beregner et flag, som en Forgrening forgrener på.