Praktisk tutorial i AI-agenter for begyndere

Hvad er en AI-agent (og hvordan adskiller den sig fra en bot)?

Hvad er en AI-agent egentlig? Og hvorfor er den ikke bare en chatbot?

En AI-agent registrerer sine omgivelser, træffer beslutninger og handler på egen hånd for at nå bestemte mål. En simpel bot følger blot et stift script. En agent har derimod autonomi og evne til at tilpasse sig, og det gør den grundlæggende forskellig fra sine mindre komplekse forgængere.

I sin kerne består en agent af blot fire centrale dele: * Model: Agentens "hjerne", som oftest er en LLM, der giver den evnen til at forstå, ræsonnere og planlægge komplekse opgaver. * Perception: Det er de sensorer eller input, agenten bruger til at indsamle information fra sine omgivelser, uanset om det er tekst fra en webside eller rådata fra en API. * Hukommelse: Denne komponent gør det muligt for agenten at bevare konteksten fra tidligere handlinger og observationer.

* Værktøjer: Det er agentens "hænder". Det er de funktioner eller eksterne API'er, som agenten bruger til faktisk at interagere med sin verden og få tingene gjort.

En hypotetisk agent til opdagelse af svindel kunne analysere transaktionsmønstre, markere afvigelser og sende usikre sager videre til en sagsbehandler. Eksemplet illustrerer en agentløkke uden at fremstille en opdigtet bankimplementering som erfaring fra AIGROW.

Forstå de forskellige typer AI-agenter

Ikke alle agenter er ens.

De inddeles i et klart hierarki efter intelligens og bliver mere avancerede, i takt med at de lærer at modellere deres verden og forfølge mål. Det er vigtigt at kende typerne, fordi du så undgår at overkonstruere en simpel opgave eller at underdimensionere en kompleks.

Her er de fem hovedkategorier af AI-agenter: 1. Simple refleksagenter: Den mest grundlæggende type. Disse agenter følger enkle "hvis-så"-regler, der udløses af det, de aktuelt ser, uden hukommelse om fortiden.

Din termostat er et perfekt eksempel: Hvis temperaturen falder under X, tænder den for varmen. 2. Modelbaserede refleksagenter: Disse agenter opbygger og vedligeholder en intern model af verden.

Det interne kort gør, at de kan håndtere omgivelser, de kun delvist kan observere, fordi de husker, hvordan tingene ændrer sig over tid. En robotstøvsuger, der husker din stues indretning, er en modelbaseret agent. 3.

Målbaserede agenter: Et stort skridt fremad. Disse agenter reagerer ikke blot; de har eksplicitte mål og planlægger handlingsforløb for at nå en ønsket fremtidig tilstand.

Tænk på en GPS, der beregner den bedste rute til din destination. Det er en målbaseret agent i aktion. 4.

Nyttebaserede agenter: Når flere veje fører til målet, vælger disse agenter den med den højeste "nytteværdi" eller gevinst. De afvejer fordele og ulemper for at træffe det optimale valg, hvilket er ideelt ved komplekse beslutninger. En aktiehandelsagent, der gennemfører handler for at maksimere profitten, er en klassisk nyttebaseret agent.

5. Lærende agenter: De mest avancerede. Disse agenter forbedrer faktisk deres egen ydeevne over tid ved at analysere feedback fra tidligere handlinger og justere deres interne komponenter, så de senere træffer bedre beslutninger.

Næsten alle moderne generative AI-agenter har en vis evne til at lære.

I denne tutorial fokuserer vi på at bygge agenter, der blander modelbaserede, målbaserede og lærende elementer for at få nyttigt arbejde gjort.

Trin 1: Design din agents mission med PEAS-rammen

Stop. Før du skriver en eneste linje kode, har du brug for en plan.

Agentprojekter kræver en præcis plan, før de implementeres. PEAS-rammen, som dækker præstationsmål, omgivelser, aktuatorer og sensorer, er én måde at definere opgaven og de driftsmæssige begrænsninger på, før du vælger værktøjer.

PEAS opdeler missionen i fire tydelige komponenter: * P - Præstationsmål (Performance Measure): Hvordan definerer du en succes? Det skal være et tal. "Forbedre kundetilfredsheden" er en ubrugelig målestok.

"Reducere den gennemsnitlige svartid på tickets med 30 %" er en god, fordi den er specifik, målbar og knyttet til et forretningsmål. * E - Omgivelser (Environment): Hvor lever agenten? Det omfatter den software og hardware, den kører på, de data, den har adgang til, og de regler, den skal følge.

For en supportagent kan det være en helpdesk-platform, en vidensbase og virksomhedens interne API'er. * A - Aktuatorer (Actuators): Hvordan handler agenten? Det er de værktøjer, den bruger til at påvirke omgivelserne.

Handlingerne kan være at sende en e-mail, opdatere en post i en database eller kalde en ekstern API. * S - Sensorer (Sensors): Hvordan ser agenten? Sensorer er agentens input. Det kan være en indkommende e-mail, en brugers chatbesked eller friske data fra et overvågningsværktøj.

Lad os gøre det konkret med en agent, der booker mødelokaler. * Præstation: Book et lokale, der opfylder alle kriterier (tidspunkt, kapacitet, AV-udstyr), på under 60 sekunder, og minimér dobbeltbookinger. * Omgivelser: Virksomhedens Google Calendar, en API til lokalebooking og en Slack-grænseflade til brugerne.

* Aktuatorer: Calendar API'en (til at oprette begivenheder) og Slack API'en (til at sende bekræftelser). * Sensorer: Brugerbeskeder i Slack og Calendar API'en (til at finde ledige tidspunkter).

PEAS-rammen giver dig et klart scope og et målbart mål. Det er ikke valgfrit; det er det afgørende første skridt i ethvert seriøst projekt.

Trin 2: Byg din agents kerne med Python og et framework

Nu hvor vores blueprint er på plads, er det tid til at bygge.

Dette er ikke en teoretisk øvelse; nu skriver vi kode for at bygge din første agent. Vi bruger Python, den ubestridte konge inden for AI-udvikling, og et agentframework, vi foretrækker til de fleste projekter inden for workflow-automatisering: CrewAI.

Hvorfor CrewAI?

Det er et godt valg for begyndere, fordi strukturen er utrolig intuitiv. Hele frameworket er bygget op omkring begrebet et "crew" af agenter, hvor hver har en bestemt rolle, og de samarbejder om at nå et mål, hvilket holder dit projekt organiseret fra start. Vores mission er at bygge en simpel researchagent.

En bruger giver den et emne, og vores crew researcher det og skriver en kort rapport. Og undervurdér ikke denne tilgang: Nyere data viser, at kodeagenter allerede bruges af 85 % af udviklerne og skriver 46 % af koden for deres brugere. Kraften ligger lige til at tage.

Opsætning af dit projekt 1. Installér biblioteker: Du skal bruge crewai, crewai-tools og et bibliotek til den LLM, du vælger. Vi bruger OpenAI.

pip install crewai crewai-tools 'crewai[openai]'

1. Angiv din API-nøgle: Opret en fil med navnet .env i din projektmappe, og tilføj din OpenAI API-nøgle.

OPENAI_API_KEY="your-api-key-here"

Skrivning af koden Opret nu en Python-fil (f.eks. main.py). Hele agenten kan bygges på under 40 linjer kode.

import os
from crewai import Agent, Task, Crew
from crewai_tools import SerperDevTool


# Load environment variables
from dotenv import load_dotenv
load_dotenv()


# Set the model you want to use
os.environ["OPENAI_MODEL_NAME"] = "gpt-6.1-terra"


# 1. Define Tools
# We'll use a search tool for our researcher
search_tool = SerperDevTool()


# 2. Create Agents
# First, a researcher agent
researcher = Agent(
 role='Senior Research Analyst',
 goal='Uncover groundbreaking technologies and trends',
 backstory='You are a master of sniffing out emerging tech and analyzing its impact.',
 verbose=True,
 tools=[search_tool]
)


# Second, a writer agent
writer = Agent(
 role='Tech Content Strategist',
 goal='Craft compelling content on tech advancements',
 backstory='You turn complex technical concepts into engaging, easy-to-understand narratives.',
 verbose=True
)


# 3. Define Tasks
# A research task for the researcher agent
research_task = Task(
 description='Identify the top 3 most exciting AI trends in 2026.',
 expected_output='A bullet-point list of the top 3 trends with a brief explanation for each.',
 agent=researcher
)


# A writing task for the writer agent
write_task = Task(
 description='Compose an insightful blog post about the top 3 AI trends identified.',
 expected_output='A well-structured blog post of about 4 paragraphs.',
 agent=writer
)


# 4. Assemble the Crew
# Create the crew with the agents and tasks
tech_crew = Crew(
 agents=[researcher, writer],
 tasks=[research_task, write_task],
 verbose=2 # Verbose output shows the agent's thought process
)


# 5. Kick off the work!
result = tech_crew.kickoff()


print("\n\n########################")
print("## Here is the result:")
print("########################\n")
print(result)

Dette enkle script opretter et team på to agenter, der arbejder sammen. researcher finder information, og writer bruger den til at lave en endelig rapport. Når du kører det, får du et klart eksempel på grundprincipperne i at bygge agenter, og du er godt rustet til mere komplekse projekter.

Trin 3: Evaluer, sikr og udrul din AI-agent (AgentOps)

En agent på din bærbare er en prototype. Intet mere.

For at få den i produktion, hvor den leverer reel værdi, har du brug for en disciplineret proces. Vi kalder den AgentOps. Livscyklussen omfatter tre trin, som ikke er til forhandling: evaluering, sikkerhed og udrulning.

Begyndere springer næsten altid disse trin over, og det er grunden til, at deres projekter aldrig gør en reel forskel.

1. Evaluering Hvordan beviser du, at din agent virker? Du skal måle dens ydeevne systematisk.

• Definér succesmål: Start med at fastsætte klare nøgletal (KPI'er), som hænger sammen med dit PEAS-framework. Er målet at nedbringe tiden til at løse en sag, øge salgskonverteringen eller gennemføre en bestemt arbejdsgang? Hvis du ikke kan måle det, kan du ikke forbedre det.
• Opret et testsæt: Byg et "golden set" med forskellige og vanskelige input. Det skal indeholde almindelige tilfælde, mærkelige grænsetilfælde og endda fjendtlige eksempler, der er designet til at få din agent til at fejle.
• Automatisér evalueringen: Kør din agent mod testsættet automatisk efter hver eneste ændring. Når du sammenligner output med en kendt god baseline, opdager du regressioner med det samme og forhindrer, at din agent langsomt bliver dummere over tid.

2. Nødvendige sikkerhedsspærringer En autonom agent med adgang til værktøjer er et ladt våben.

En kompromitteret agent kan slette databaser, tømme bankkonti eller lække følsomme data. Du skal sikre den.

• Princippet om mindst mulige rettigheder: Giv agenten det absolut minimum af tilladelser, den skal bruge for at gøre sit arbejde. Ikke mere. Hvis den kun skal læse fra en database, så giv den aldrig skriveadgang.
• Menneske i løkken: Kræv menneskelig godkendelse til enhver handling med store konsekvenser (som at behandle en refusion over $100 eller slette en bruger). Agenten kan gøre alt forarbejdet og derefter sætte den endelige handling i kø, så en person kan klikke "bekræft".
• Rensning af input og output: Behandl ethvert input som fjendtligt. Du skal rense indkommende data for at forsvare dig mod prompt injection, hvor en angriber narrer din agent til at følge deres ondsindede instruktioner i stedet for dine.

3. Udrulning til produktion At udrulle en agent er ikke bare python main.py på en server.

• Brug et cloudmiljø: Platforme som AWS, Google Cloud eller Azure giver dig den skalerbare infrastruktur, du skal bruge for at vokse.
• Containerisér din applikation: Pak din agent og alle dens afhængigheder i en Docker-container. Så er den portabel, og du er sikker på, at den kører ens overalt.
• Opsæt logning og overvågning: Log hver beslutning, hvert værktøjskald og hvert output. Uden observerbarhedsværktøjer, der overvåger ydeevne, omkostninger og fejlrater i realtid, flyver du i blinde.

En struktureret AgentOps-livscyklus er ikke bare god praksis. Den er det, der adskiller et hobbyprojekt fra et system i produktionskvalitet, du kan stole på.

Derfor mislykkes de fleste agentprojekter hos begyndere (og sådan sikrer du, at dit lykkes)

Her er den hårde sandhed: De fleste agentprojekter hos begyndere mislykkes.

Mange agentprojekter går i stå, fordi arbejdsgangen, tilladelserne, evalueringscases og den driftsansvarlige aldrig blev defineret. Valget af model kan ikke råde bod på et manglende scope eller en manglende accepttest.

Et brugbart projektscope angiver arbejdsgangen, succesmålet, de tilladte handlinger, eskaleringsvejen og fejlbudgettet. Et mål som at løse forespørgsler om ordrestatus inden for et defineret serviceniveau kan testes; et mål som at bygge en kundeserviceagent er for bredt.

Det er en afgørende designbegrænsning, ikke noget, man kan tænke på bagefter.

1. Intet evalueringsframework: Hvordan ved du, om dine ændringer hjælper eller skader? Uden en standardiseret testsuite (et "golden set") gætter du bare. Hver gang du justerer en prompt eller et værktøj, risikerer du at indføre stille fejl, som du først opdager efter flere uger. En grundig, automatiseret evalueringsproces er absolut ikke til forhandling ved nogen seriøs udrulning.
2. For tidlig satsning på fuld autonomi: Mange begyndere har en farlig drøm om en fuldt autonom agent, der ikke kræver menneskeligt tilsyn. Det er en opskrift på katastrofe. En mere sikker udrulning begynder med, at agenten forbereder arbejdet til menneskelig godkendelse. Udvid først autonomien, når repræsentative tests og overvågning i produktion understøtter ændringen. Dette human-in-the-loop-design skaber tillid og giver, endnu vigtigere, et afgørende sikkerhedsnet.

Succes med at bygge agenter handler ikke om at finde den perfekte prompt. Det handler om disciplineret ingeniørarbejde, klare mål og en realistisk tilgang til automatisering.

Hvordan vælger du det rette framework til AI-agenter?

Det framework, du vælger, har stor betydning.

Det afgør, hvor hurtigt du kan udvikle, hvor stærk din agent bliver, og hvor besværligt dit projekt er at vedligeholde. Med så mange muligheder kan valget virke lammende. Lad os derfor skære støjen væk og sammenligne de tre store: LangChain, AutoGen og CrewAI.

Valget af framework afhænger af arbejdsgangen og bør testes med en repræsentativ prototype. Sammenlign håndtering af tilstand, værktøjsintegration, observerbarhed, udrulningsmodel, vedligeholdelse og licensering op mod de samme accepttests, før du beslutter dig.

Hvad bør en begynder vælge? Til alle, der følger denne vejledning, er vores anbefaling klar: start med CrewAI.

Dets rollebaserede abstraktion er let at forstå og lader dig bygge et stærkt multiagentsystem med forbløffende lidt kode. Endnu vigtigere er det, at det tvinger din projektstruktur på plads, så du undgår almindelige designfejl.

Når du er blevet mere erfaren, kan du gå videre til LangChain (især LangGraph) for mere detaljeret kontrol over komplekse eksekveringsforløb eller udforske AutoGen til avanceret forskning. Men hvis du hurtigt og effektivt vil have en rigtig agent til at virke, er CrewAI den oplagte vinder.