AI online: bouw je eigen chat, agents en tools

AI online, praktisch: gebruik een web- of CLI-frontend die je LLM oproept via API, forceer gestructureerde output (JSON schema), sluit tools aan (fetchen, zoeken, acties) en maak het veilig (prompt injection, privilege scheiding). Start met chat-completions, voeg daarna tools en validatie toe, en pas als laatste agents op webverkeer toe.

Snelle start, wat je nodig hebt (1 uur)

Doel: je draait vandaag nog een werkende “AI online” die via HTTP iets doet, bijvoorbeeld: samenvatten, JSON teruggeven, of een simpele tool-call uitvoeren.

1) Kies je minimale architectuur

• Frontend: browser of CLI (geen server nodig bij prototyping, wel bij auth en secrets).
• Backend: 1 endpoint dat verzoeken valideert en naar de LLM API doorstuurt.
• Contract: laat de LLM altijd JSON schema output doen, zodat je code niet hoeft te parse-roulette-en.

2) Forceer gestructureerde output (JSON schema)

OpenAI heeft “structured outputs” via schema gebaseerde response formats uitgelegd. Het idee: je geeft een schema, de API levert valide JSON dat je code direct kan gebruiken. (openai.com)

In de code hieronder ga ik uit van het Chat API concept met messages en structured output. Raadpleeg de actuele API reference voor exacte parameternamen in jouw SDK-versie. (developers.openai.com)

3) Voorbeeld: chat die een JSON-object teruggeeft

Dit voorbeeld laat zien hoe je een technisch bruikbaar resultaat krijgt, niet “tekst met een beetje JSON erin”.

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

schema = {
  "name": "Answer",
  "schema": {
    "type": "object",
    "properties": {
      "title": {"type": "string"},
      "bullets": {"type": "array", "items": {"type": "string"}}
    },
    "required": ["title", "bullets"],
    "additionalProperties": False
  },
  "strict": True
}

resp = client.chat.completions.create(
  model="gpt-4o-mini",
  messages=[
    {"role": "system", "content": "Je bent een assistent voor developers."},
    {"role": "user", "content": "Leg AI online uit in 3 bullets."}
  ],
  response_format={"type": "json_schema", "json_schema": schema}
)

print(resp.choices[0].message.content)

Volgende stap: maak dit een endpoint, zodat je browser of andere clients “AI online” kunnen gebruiken.

Van idee naar werkend systeem: chat, rollen en code

Als je maar één ding vandaag wil doen: bouw een chat-endpoint met rollen, validatie en logging. Daarna pas tools en agents.

Rollen splitsen je prompts in controle en intentie

• system: regels, policy, output contract, veiligheid.
• developer: jouw applicatierichtlijnen (indien beschikbaar via jouw SDK/variant).
• user: input van de client.

Als je dit wil versnellen, zie ook: OpenAI Chat: snel starten met chat-completions, roles en code.

Endpoint patroon (minimal, maar correct)

Je wil minimaal:

1. Validatie van input lengte en type.
2. Rate limiting (op z’n minst per IP of user).
3. Geen secrets in de frontend.
4. Schema validatie op output (liefst via strict JSON schema).

Voorbeeld: Node.js express endpoint (conceptueel)

import express from "express";
import { OpenAI } from "openai";

const app = express();
app.use(express.json());

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

app.post("/api/ai-online", async (req, res) => {
  const { prompt } = req.body;
  if (typeof prompt !== "string" || prompt.length > 2000) {
    return res.status(400).json({ error: "invalid prompt" });
  }

  const schema = {
    name: "Answer",
    schema: {
      type: "object",
      properties: {
        result: { type: "string" }
      },
      required: ["result"],
      additionalProperties: false
    },
    strict: true
  };

  const r = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      { role: "system", content: "Antwoord strikt als JSON via het schema." },
      { role: "user", content: prompt }
    ],
    response_format: { type: "json_schema", json_schema: schema }
  });

  res.json(JSON.parse(r.choices[0].message.content));
});

app.listen(3000);

Tools, RAG en “AI online” die echt kan handelen

Chat is stap 1. “AI online” wordt nuttig als je de LLM koppelt aan data en acties. In praktijk betekent dit: tools + retrieval (indien nodig) + guardrails.

Richtlijn: retrieval is optioneel, tools zijn essentieel

• Als je alleen generieke kennis wil: pure chat is genoeg.
• Als je organisatie-specifieke content wil: RAG, ingest, embeddings, retrieval.
• Als je externe systemen wil gebruiken: tools, function calling, gecontroleerde acties.

Praktische tool-keten

Een betrouwbare keten ziet er zo uit:

1. LLM produceert een tool intent op basis van user prompt.
2. Jij valideert: welke tool, welke inputs, welke constraints.
3. Jij voert de tool call uit buiten de LLM.
4. Jij stuurt resultaat terug naar de LLM met een nieuw prompt, opnieuw onder schema contract.

Voorbeeld: tool “zoek in docs”

Stel je hebt je eigen index. Je LLM mag alleen “search(query)” aanroepen. Alles wat buiten de contractgrens valt, weiger je in je backend.

# Pseudocode
# LLM: wil docs zoeken met query = "rate limit".

tool_name = llm_decision.tool
tool_args = llm_decision.args

if tool_name != "search_docs":
  raise Exception("tool not allowed")

query = tool_args["query"]
if not isinstance(query, str) or len(query) > 200:
  raise Exception("bad args")

docs = search_docs(query)

# Terug naar LLM, met strikte output
# LLM produceert bijv. "answer" + "citations" (IDs uit docs).

Gids om snel naar productie te gaan

Als je een end-to-end route zoekt voor AI implementatie bij developers, gebruik deze als referentie:

• Artificial intelligence voor developers, van concept tot productie
• AI OpenAI voor developers: snelle start, keuzes en tooling
• AI voor developers: van basis tot productie-ready

Security voor AI online: prompt injection, misconfig en tool misbruik

Als je “AI online” publiek maakt, is security geen bijzaak. OWASP beschrijft in de API Security Top 10 risico’s rond injectie en security misconfiguration, en geeft aan dat je dit actief moet mitigeren. (api-security.owasp.org)

Threat model, wat kan er misgaan

• Prompt injection: user input probeert jouw systeemregels te omzeilen.
• Tool injection: de LLM triggert tools met verkeerde parameters.
• Data leakage: LLM lekt interne context (secrets, private data, systeemprompt).
• Misconfig: je API cache’t responses, verkeerde headers, of te permissieve CORS.

Concrete mitigerende maatregelen

• Privilege scheiding: laat de LLM nooit direct toegang krijgen tot secrets. Alleen backend voert tools uit.
• Strict output schema: forceer dat de LLM alleen geldige velden teruggeeft. Structured outputs reduceert “vrij schrijven” waar je parser op stuk gaat. (openai.com)
• Tool allowlist: whitelist tool names en valideer args (type, lengte, bereik).
• Content boundaries: markeer retrieval content als “data”, niet als instructie.
• Logging: log tool requests en model outputs, met redactie voor gevoelige gegevens.
• Rate limiting: voorkom token draining en brute force.

Prompt injection aanpak die echt werkt

Een simpele, praktische regel:

• Beschouw alles wat niet uit je eigen backend komt als input, nooit als instructie.
• Gebruik een systeemprompt die dit expliciet maakt, en evalueer met tests die “injected instructions” bevatten.

OWASP heeft ook een OWASP Top 10 voor LLM toepassingen, waaronder prompt injection als kernrisico wordt behandeld. (owasp.org)

Verder lezen, security en LLM risico’s

Voor updates over modellen, agents en tooling: AI nieuws voor developers: modellen, agents en tooling.

Agents voor het web: wanneer wel, wanneer niet

Agents zijn vaak waar projecten misgaan: te veel vrijheid, onduidelijke acties, en ontbrekende veiligheidschecks. Gebruik agents pas als je tools en contracten stabiel zijn.

Definition, simpel

• Agent: LLM die herhaaldelijk plannen maakt, tools aanroept, en resultaten iteratief verwerkt.
• Web agent: extra risico, want input en acties komen van het web (onbetrouwbaar).

Praktische “agent guardrails”

1. Max steps: stop na N iteraties of bij tijdslimiet.
2. Tool sandboxing: run web fetch in een geïsoleerde omgeving.
3. Allowlisted domains: of minimaal classificatie van targets.
4. Verbied acties met bijwerkingen: totdat je expliciet autoriseert.
5. Eval set: onderhoud een testset van agent prompts met bekend verwachte uitkomsten.

Voorbeeld: agent die alleen mag lezen

Als je agent webverkeer gebruikt, beperk tot GET en blok schrijf-acties. Valideer elke URL, voorkom SSRF, en werk met egress policies.

Onderhoud en kosten: maak AI online voorspelbaar

Je systeem moet niet alleen “werken”, het moet voorspelbaar worden. Drie dingen bepalen je kosten en betrouwbaarheid: token usage, caching, en falenstrategie.

Token strategie

• Stuur kort: vat samen voordat je opnieuw context toevoegt.
• Beperk context: retrieval snippets i.p.v. volledige chat logs.
• Gebruik schema output: je krijgt minder “extra verhaal” terug.

Caching, waar het kan

• Cache retrieval resultaten (embeddings query + top k).
• Cache deterministische requests (zelfde prompt + zelfde schema en modelparameters).
• Zorg dat je cache nooit secrets of user-specifieke content zonder scheiding opslaat.

Fail fast en degradatie

Maak een degradatiepad, bijvoorbeeld:

• Tool faalt: return “kan geen data ophalen”, maar preserveer contractformat.
• Schema validatie faalt: laat opnieuw genereren met een kort “repair prompt” en dezelfde schema.

Planning, leerroute voor agents en tooling

Als je dit niet alleen wil lezen maar bouwen, zijn deze routes handig:

• AI cursus online: leer agents, tools en productie-ready
• Cursus AI: praktisch leren bouwen met agents en tools
• AI cursus voor developers, van setup tot productie

Workflow checklist, copy-paste voor je volgende AI online project

Gebruik dit als runtime checklist, niet als theorie.

Stap 0, defineer je contract

• Welke output wil je: tekst, JSON, of acties?
• Welke velden moeten altijd aanwezig zijn?
• Wat is het maximale resultaatformaat?

Stap 1, bouw chat met rollen

• System rules, user input, developer constraints.
• Schema output, strict waar mogelijk. (openai.com)

Stap 2, verbind tools met een allowlist

• Valideer tool name en args.
• Laat LLM nooit direct secrets gebruiken.

Stap 3, voeg beveiliging toe vóór je het publiek maakt

• Guard tegen prompt injection en tool misbruik.
• Volg OWASP API security principes en vermijd misconfig. (api-security.owasp.org)

Stap 4, monitor en onderhoud

• Log tool calls, schema failures en re-tries.
• Hanteer rate limits en caching waar zinvol.

Conclusie

AI online is geen magie, het is een keten: frontend, backend, chat met rollen, structured outputs, tools met allowlist, en security die je vooraf implementeert. Als je vandaag wil starten, doe dit in volgorde: (1) chat endpoint met strict JSON schema output, (2) tool-koppeling via gecontroleerde tool calls, (3) pas daarna agents en web interacties met sandboxing en allowlists.

Wil je vooruit blijven kijken naar wat je morgen al kunt bouwen, zie ook: AI alsmaar intelligenter: wat je morgen al kunt bouwen.