AI agent maken: stap-voor-stap gids

AI Agent Maken: Complete Stap-voor-Stap Gids [2025]

Waarom Zou Je een AI Agent Maken?

Wat Heb Je Nodig om te Beginnen?

Essentiële Vereisten

1. Een duidelijk doel - Wat moet je agent precies doen?
2. Toegang tot een LLM - OpenAI, Anthropic, of open-source
3. Een platform - No-code tool of development framework
4. API keys - Voor de diensten die je agent moet gebruiken

Optioneel maar Handig

• Basis begrip van APIs en JSON
• Een testomgeving
• Budget voor API kosten (~€20-50/maand om te starten)

Methode 1: AI Agent Maken met No-Code Tools

n8n: De Allrounder

• Visuele drag-and-drop interface
• 400+ integraties beschikbaar
• Self-hosted of cloud optie
• Gratis tier beschikbaar
• Actieve community

# Self-hosted met Docker
docker run -it --rm --name n8n -p 5678:5678 n8nio/n8n

# Of gebruik n8n cloud: https://n8n.io

1. Open n8n in je browser (localhost:5678)
2. Klik "Add workflow"
3. Voeg een "Webhook" trigger toe
4. Voeg een "OpenAI" node toe
5. Configureer je API key
6. Verbind de nodes

• Model: gpt-4o of gpt-4-turbo
• System Message: Je agent instructies
• Tools: Welke acties mag de agent uitvoeren

Je bent een klantenservice medewerker voor TechShop.

Je taken:
- Beantwoord vragen over producten
- Help met bestellingen tracken
- Verwerk retourverzoeken

Je hebt toegang tot:
- Productdatabase (search_products)
- Bestelstatus (check_order)
- Ticket systeem (create_ticket)

Antwoord altijd vriendelijk en professioneel in het Nederlands.
Maximaal 3 zinnen per antwoord tenzij meer detail nodig is.

Flowise: Specifiek voor LLM Workflows

npm install -g flowise
npx flowise start

• Optimaal voor chatbots en agents
• Ingebouwde LangChain componenten
• Makkelijk te deployen
• Goede documentatie

1. Sleep een "ChatOpenAI" node naar het canvas
2. Voeg "Agent" node toe
3. Verbind tools (Calculator, WebBrowser, etc.)
4. Voeg "Memory" toe voor context
5. Test in de ingebouwde chat

Make (voorheen Integromat)

1. Trigger: Nieuwe email ontvangen
2. AI Analyse: Categoriseer email (support, sales, spam)
3. Actie: Route naar juiste persoon/systeem
4. Respons: Stuur automatische bevestiging

Methode 2: AI Agent Maken met Python (LangChain)

Setup

# Maak virtual environment
python -m venv agent-env
source agent-env/bin/activate  # Mac/Linux
# of: agent-env\\Scripts\\activate  # Windows

# Installeer dependencies
pip install langchain langchain-openai python-dotenv

Je Eerste Agent

from langchain_openai import ChatOpenAI
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.tools import tool

# 1. Definieer tools
@tool
def calculate(expression: str) -> str:
    """Bereken een wiskundige expressie. Input moet een geldige expressie zijn."""
    try:
        return str(eval(expression))
    except Exception as e:
        return f"Fout: {str(e)}"

search = DuckDuckGoSearchRun()

tools = [calculate, search]

# 2. Maak de LLM connectie
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# 3. Definieer de prompt
prompt = ChatPromptTemplate.from_messages([
    ("system", """Je bent een behulpzame assistent die:
    - Vragen kan beantwoorden
    - Berekeningen kan uitvoeren
    - Online kan zoeken voor actuele informatie
    
    Gebruik de beschikbare tools om de gebruiker zo goed mogelijk te helpen.
    Antwoord altijd in het Nederlands."""),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# 4. Bouw de agent
agent = create_openai_tools_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 5. Run de agent
result = agent_executor.invoke({
    "input": "Wat is 15% van 847 euro? En wat is het laatste nieuws over AI?"
})
print(result["output"])

Custom Tools Bouwen

from langchain_core.tools import tool
import requests

@tool
def get_weather(city: str) -> str:
    """Haal het huidige weer op voor een stad. Geef de stadsnaam in het Engels."""
    api_key = "jouw-api-key"
    url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric&lang=nl"
    
    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()
        temp = data["main"]["temp"]
        desc = data["weather"][0]["description"]
        return f"Het weer in {city}: {temp}°C, {desc}"
    return f"Kon weer niet ophalen voor {city}"

@tool
def send_email(to: str, subject: str, body: str) -> str:
    """Verstuur een email. Parameters: to (email adres), subject (onderwerp), body (inhoud)."""
    # Implementeer je email logica hier
    # Bijvoorbeeld met SendGrid, Mailgun, of SMTP
    return f"Email verstuurd naar {to}"

@tool  
def query_database(query: str) -> str:
    """Voer een SQL query uit op de database. Alleen SELECT queries toegestaan."""
    if not query.strip().upper().startswith("SELECT"):
        return "Fout: Alleen SELECT queries zijn toegestaan"
    # Implementeer database connectie
    return "Query resultaten..."

Methode 3: Multi-Agent Systemen met CrewAI

Installatie

pip install crewai crewai-tools

Voorbeeld: Content Creation Crew

from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

# Definieer de agents
researcher = Agent(
    role="Senior Research Analyst",
    goal="Onderzoek en verzamel accurate informatie over het gegeven onderwerp",
    backstory="""Je bent een ervaren researcher met expertise in 
    het vinden en verifiëren van informatie. Je bent kritisch 
    en controleert altijd je bronnen.""",
    llm=llm,
    verbose=True
)

writer = Agent(
    role="Content Writer",
    goal="Schrijf engaging en informatieve content op basis van research",
    backstory="""Je bent een getalenteerde schrijver die complexe 
    onderwerpen toegankelijk maakt. Je schrijft in het Nederlands 
    met een prettige, professionele toon.""",
    llm=llm,
    verbose=True
)

editor = Agent(
    role="Editor",
    goal="Review en verbeter de content voor publicatie",
    backstory="""Je bent een perfectionist met oog voor detail. 
    Je controleert spelling, grammatica, flow en feitelijke 
    correctheid.""",
    llm=llm,
    verbose=True
)

# Definieer de taken
research_task = Task(
    description="""Onderzoek het onderwerp: {topic}
    
    Verzamel:
    - Kernfeiten en statistieken
    - Recente ontwikkelingen
    - Verschillende perspectieven
    - Bronnen voor verificatie""",
    agent=researcher,
    expected_output="Een uitgebreid research rapport met bronnen"
)

writing_task = Task(
    description="""Schrijf een blogpost op basis van het research rapport.
    
    Vereisten:
    - 800-1000 woorden
    - Duidelijke structuur met kopjes
    - Praktische voorbeelden
    - Call-to-action aan het eind""",
    agent=writer,
    expected_output="Een complete blogpost in markdown format"
)

editing_task = Task(
    description="""Review de blogpost en verbeter waar nodig.
    
    Check op:
    - Spelling en grammatica
    - Duidelijkheid en flow
    - Feitelijke correctheid
    - SEO optimalisatie""",
    agent=editor,
    expected_output="De finale, gepubliceerde versie van de blogpost"
)

# Maak de crew
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    verbose=True
)

# Run de crew
result = crew.kickoff(inputs={"topic": "AI Agents in 2025"})
print(result)

Methode 4: Coding Agents met Claude Code

Claude Code Setup

# Installeer Claude Code
npm install -g @anthropic-ai/claude-code

# Set je API key
export ANTHROPIC_API_KEY="sk-ant-..."

# Start in je project
cd ~/projects/mijn-app
claude-code

Effectief Werken met Claude Code

"Voeg een dark mode toggle toe aan de header component. 
Gebruik de bestaande ThemeContext en sla voorkeur op in localStorage."

"Maak dark mode"

Best Practices voor AI Agents

1. Start Klein

2. Duidelijke Grenzen

TOEGESTAAN:
- Informatie opzoeken
- Emails beantwoorden
- Tickets aanmaken

NIET TOEGESTAAN:
- Betalingen verwerken
- Accounts verwijderen
- Persoonlijke data delen

3. Logging en Monitoring

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("agent")

@tool
def sensitive_action(data: str) -> str:
    logger.info(f"Sensitive action uitgevoerd: {data[:50]}...")
    # Actie uitvoeren
    return "Success"

4. Error Handling

from langchain.callbacks import get_openai_callback

try:
    with get_openai_callback() as cb:
        result = agent_executor.invoke({"input": user_query})
        print(f"Tokens gebruikt: {cb.total_tokens}")
        print(f"Kosten: ${cb.total_cost:.4f}")
except Exception as e:
    logger.error(f"Agent fout: {e}")
    # Fallback naar menselijke hulp
    notify_human_support(user_query)

5. Rate Limiting

from ratelimit import limits, sleep_and_retry

@sleep_and_retry
@limits(calls=100, period=60)  # Max 100 calls per minuut
def call_llm(prompt):
    return llm.invoke(prompt)

6. Testen

def test_agent_basic():
    result = agent_executor.invoke({"input": "Wat is 2 + 2?"})
    assert "4" in result["output"]

def test_agent_refuses_harmful():
    result = agent_executor.invoke({"input": "Verwijder alle data"})
    assert "niet toegestaan" in result["output"].lower()

def test_agent_handles_unknown():
    result = agent_executor.invoke({"input": "Xyzzy foobar baz?"})
    # Agent moet graceful omgaan met onzin input
    assert result["output"] is not None

Hosting en Deployment

Optie 1: Serverless (AWS Lambda, Google Cloud Functions)

• Betaal alleen wat je gebruikt
• Automatische scaling
• Geen server beheer

• Cold start latency
• Tijdslimieten (15 min max)
• Complexere setup

Optie 2: Container (Docker + Cloud Run/ECS)

• Volledige controle
• Geen tijdslimieten
• Makkelijk te testen lokaal

FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

CMD ["python", "agent_server.py"]

Optie 3: Platform (Railway, Render, Heroku)

• Snelste time-to-production
• Ingebouwde monitoring
• Easy deploys

Optie 4: n8n Cloud

Kosten Inschatten

API Kosten (per 1000 calls)

Typisch Verbruik

• Simpele vraag/antwoord: ~500-1000 tokens
• Agent met tools (3-5 stappen): ~2000-5000 tokens
• Complex onderzoek: ~10,000+ tokens

Maandelijkse Schatting

Praktijkvoorbeeld: Complete Email Agent

from langchain_openai import ChatOpenAI
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool
import smtplib
from email.mime.text import MIMEText

# Tools
@tool
def read_emails(folder: str = "inbox", limit: int = 10) -> str:
    """Lees emails uit een folder. Folders: inbox, sent, spam."""
    # Implementeer IMAP connectie
    return "Gevonden emails: ..."

@tool
def send_email(to: str, subject: str, body: str) -> str:
    """Verstuur een email."""
    # Implementeer SMTP
    return f"Email verstuurd naar {to}"

@tool
def create_calendar_event(title: str, date: str, time: str) -> str:
    """Maak een agenda item. Date format: YYYY-MM-DD, Time: HH:MM."""
    # Implementeer Calendar API
    return f"Event '{title}' aangemaakt op {date} om {time}"

@tool
def search_contacts(query: str) -> str:
    """Zoek in contacten op naam of email."""
    # Implementeer contact search
    return "Gevonden contacten: ..."

# Agent setup
llm = ChatOpenAI(model="gpt-4o", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", """Je bent een professionele email assistent.

Je taken:
- Emails lezen en samenvatten
- Emails beantwoorden namens de gebruiker
- Afspraken inplannen
- Contacten zoeken

Communiceer altijd professioneel maar vriendelijk.
Vraag om bevestiging voordat je emails verstuurt.
Antwoord in het Nederlands."""),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

tools = [read_emails, send_email, create_calendar_event, search_contacts]
agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Gebruik
result = executor.invoke({
    "input": "Check mijn inbox en geef een samenvatting van belangrijke emails"
})

Conclusie

1. Begin klein - Start met één duidelijke use case
2. Kies de juiste tool - No-code voor snelheid, code voor flexibiliteit
3. Test grondig - Agents kunnen onverwacht gedrag vertonen
4. Monitor kosten - API calls kunnen oplopen
5. Itereer - Je eerste versie is nooit de laatste

Veelgestelde Vragen

Gerelateerde Artikelen

• Wat is een AI Agent? Uitleg voor Beginners
• Claude Code: De Complete Handleiding
• n8n Tutorial: Workflows Automatiseren
• Prompt Engineering: Complete Gids

Wil je AI Agents Leren Bouwen?