Lokale Agentic Workflows Bouwen met n8n en Ollama

In de route van lokaal werken bevind je je na het selecteren, installeren en bedienen van een taalmodel op het cruciale punt van integratie. Waar een losse chat-interface uitsteekt in een-op-een interactie, ontstaat de werkelijke productiviteitswinst pas wanneer het model zelfstandig taken kan uitvoeren, tools kan aanroepen en beslissingen kan nemen in een geautomatiseerde keten. Dit noemen we agentic workflows. Door de workflow-engine n8n te koppelen aan de lokale inference-server Ollama, bouw je geavanceerde autonome agent-loops zonder dat er ook maar één byte aan gegevens naar een externe cloudprovider wordt verzonden.

Waarom Agentic Workflows Lokaal Draaien?

Cloudgebaseerde agentic frameworks zoals LangChain of gehoste n8n-instanties die verbinden met commerciële API's brengen twee grote uitdagingen met zich mee: privacyrisico's en onvoorspelbare gebruikskosten. Een autonome agent werkt per definitie via een lus (de zogenaamde ReAct-loop: Reason, Act, Observe). Het model genereert een gedachte, roept een tool aan, leest het resultaat en herhaalt deze stap totdat het einddoel bereikt is. Een enkele gebruikerstaak kan hierdoor ongemerkt wel tien tot dertig opeenvolgende API-calls genereren.

Wanneer je dit uitvoert op commerciële cloud-API's, lopen de kosten bij grote hoeveelheden documenten of continue achtergrondprocessen snel op. Bovendien verwerkt een agent vaak gevoelige bedrijfsinformatie, zoals e-mails, interne databases en financiële overzichten. Voor een volledige analyse van organisatorische richtlijnen kun je de AVG-privacy checklist voor organisaties raadplegen om te bepalen welke data verwerkt mag worden. Door n8n en Ollama volledig op eigen hardware te draaien, zijn de variabele kosten per uitvoering exact nul euro. Voor een overzicht van hoe je datastromen volledig afschermt binnen je eigen netwerk raadpleeg je het artikel over privacyvriendelijk AI gebruiken.

Systeemvereisten en Hardware-ondergrens

Het draaien van agentic workflows stelt hogere eisen aan hardware dan een eenvoudige chat-sessie. Omdat de agent tijdens een lus constant zijn eerdere stappen, tool-outputs en systeeminstructies in het geheugen moet houden, groeit de context-window snel. Een model met een te klein contextvenster of een te zware kwantisatie zal halverwege de werkstroom zijn instructies vergeten of foutieve JSON-structuren voor tool-calls genereren.

Als je wilt controleren of jouw specifieke grafische kaart voldoende VRAM heeft voor zwaardere agentic workflows, lees dan de gids over hardware voor lokale LLM's. In de onderstaande tabel zie je de minimale en aanbevolen specificaties voor stabiele n8n-agentic setups.

Om te begrijpen hoe gewichten worden gecomprimeerd met minimaal kwaliteitsverlies verwijzen we naar de uitleg over kwantisatie van lokale modellen. Bij agentic workflows geldt: kies liever voor een iets kleiner model met een hogere precisie (bijvoorbeeld Q5_K_M of Q8_0) dan een groter model met zware Q2- of Q3-kwantisatie, omdat logische redeneerfouten bij functie-aanroepen anders exponentieel toenemen.

Architectuur: Hoe n8n Communiceert met Ollama

De koppeling tussen n8n en Ollama berust op een heldere taakverdeling. n8n fungeert als de orchestrator, de 'handen' van het systeem. Het vangt triggers op (zoals een binnenkomende e-mail, een webhook, of een aangepaste cron-job), beheert de data-flows, en voert HTTP-verzoeken of database-operaties uit. Ollama fungeert als het 'brein'. Het ontvangt de gestructureerde prompt van n8n, beoordeelt de beschikbare tools en bepaalt welke actie ondernomen moet worden.

Sinds de introductie van de officiële LangChain en Advanced AI nodes in n8n, beschikt het platform over een ingebouwde Ollama Chat Model-node. Deze node communiceert via de REST API van Ollama (standaard op poort `11434`). Wanneer n8n een AI Agent-node gebruikt, stuurt het niet alleen de vraag van de gebruiker mee, maar ook een JSON-schema van alle gekoppelde n8n-tools. Het lokale model leest dit schema, genereert een functie-aanroep in JSON-formaat, waarna n8n die functie daadwerkelijk uitvoert en het resultaat terugvoert aan het model.

Stap-voor-stap: n8n en Ollama Opzetten via Docker

De meest betrouwbare manier om n8n en Ollama samen te laten werken op dezelfde fysieke machine is via Docker Compose. Hierdoor draaien beide diensten in een geïsoleerd netwerk, waarbij n8n direct toegang heeft tot de GPU-geaccelereerde Ollama-container. Voor een gedetailleerde handleiding over het optimaal instellen van NVIDIA-drivers en CUDA op een Linux-omgeving kun je terecht bij de handleiding voor lokale LLM's op Linux.

Wie Docker liever vanaf de grond opbouwt met op maat gemaakte volumes kan het uitgebreide stappenplan volgen voor een LLM in Docker draaien. Hieronder staat een kant-en-klare `docker-compose.yml` configuratie waarmee je beide diensten opzet:

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama_storage:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  n8n:
    image: docker.n8n.io/n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=localhost
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
      - NODE_ENV=production
      - WEBHOOK_URL=http://localhost:5678/
      - GENERIC_TIMEZONE=Europe/Amsterdam
    volumes:
      - n8n_storage:/home/node/.n8n
    depends_on:
      - ollama

volumes:
  ollama_storage:
  n8n_storage:

Na het starten van de containers via docker compose up -d, download je het gewenste model in de Ollama-container via de terminal:

docker exec -it ollama ollama run qwen2.5-coder:14b

Inrichten van een Agentic Loop in n8n

Het bouwen van een autonome agentic workflow in het canvas van n8n vereist een specifieke combinatie van nodes. In plaats van een lineaire keten van acties, maak je gebruik van een dynamische intelligentielus:

1. Trigger Node: Bijvoorbeeld een Webhook, Schedule Trigger of Email Read node die het proces start.
2. AI Agent Node: Het centrale knooppunt. Kies als Agent Type voor Tools Agent. Deze node bevat de logica voor de ReAct-lus.
3. Ollama Chat Model Node: Koppel deze aan de Model-ingang van de AI Agent node. Vul bij de Base URL http://ollama:11434 in (indien binnen hetzelfde Docker-netwerk) en kies het geïnstalleerde model (bijv. qwen2.5-coder:14b).
4. Window Buffer Memory Node: Koppel deze aan de Memory-ingang van de agent. Hiermee onthoudt de agent voorgaande tussenstappen binnen dezelfde sessie. Stel de limiet in op 10 tot 15 berichten om te voorkomen dat het contextvenster volloopt.
5. Tools Nodes: Koppel specifieke n8n-acties als tools aan de Tools-ingang van de agent node (bijvoorbeeld een custom HTTP Request, een Calculator, of een SQL-query generator).

Het is essentieel om het gedrag van het model strak af te kaderen in de systeemprompt van de AI Agent node. Lees hoe je de basiseigenschappen en stop-tokens van je model permanent instelt in de gids over het Ollama Modelfile aanpassen.

Tools en Vector Databases Integreren (Lokale RAG)

Een agent wordt pas echt krachtig als hij externe informatiebronnen kan raadplegen. In een puur lokale opstelling combineer je n8n niet alleen met API-tools, maar ook met een lokale vector database. Hierdoor kan de agent tijdens het uitvoeren van een opdracht zelfstandig relevante documentatie opzoeken.

Binnen n8n kun je een Vector Store Tool aanmaken die verbindt met instanties van Qdrant of Chroma. Voor een gedetailleerd stappenplan om vector-indexen lokaal te beheren en op te vragen kun je de gids raadplegen over een lokale vector database opzetten. Als de agent bijvoorbeeld een vraag krijgt over een specifiek klantcontract, roept hij eerst de Vector Store-tool aan, leest de teruggekomen context, en genereert op basis daarvan een onderbouwd antwoord of vervolgactie.

Nederlandstalige Prestaties en Prompt Tuning

Wanneer je agentic workflows inzet voor Nederlandstalige bedrijfsprocessen, stuit je op een bekende uitdaging: veel kleinere open-source modellen (zoals 7B/8B varianten) vallen bij complexe tool-calling opdrachten snel terug op het Engels, of maken fouten in het aanmaken van geldige JSON-parameters.

Uit de praktijktests blijkt dat het Qwen 2.5-model (met name de 14B- en 32B-instruct varianten) superieur presteert in het vasthouden van de Nederlandse taal, gecombineerd met een zeer accurate JSON-output voor n8n tools. Om te zorgen dat het model niet afwijkt, voeg je expliciete instructies toe aan de systeemprompt van de agent node:

Je bent een autonome assistent die taken uitvoert voor een Nederlandse organisatie.
- Analyseer de vraag van de gebruiker zorgvuldig.
- Gebruik de beschikbare tools wanneer je informatie mist.
- Antwoord ALTIJD in het Nederlands, behalve als er expliciet om een andere taal wordt gevraagd.
- Zorg dat alle parameters voor functie-aanroepen strikt voldoen aan het opgegeven JSON-schema.

Bekijk praktische voorbeelden en systeem-instructies in het artikel over je AI beter laten presteren in het Nederlands om de verwerkingskwaliteit van lokale modellen verder te verhogen.

Valkuilen, Debugging en Foutafhandeling

Agentic workflows lokaal draaien is niet zonder risico's. De drie meest voorkomende problemen in de praktijk zijn:

• Oneindige lussen (Infinite Loops): Het model begrijpt de output van een tool niet en blijft dezelfde tool aanroepen met identieke argumenten. Stel in de n8n AI Agent node ALTIJD een Max Iterations limiet in (bijvoorbeeld maximaal 5 of 8 stappen).
• Context Window Overflow: Na meerdere tussenstappen overschrijdt de gecombineerde tekst de tokenlimiet van Ollama. Dit leidt tot willekeurige foutmeldingen of hallucinaties. Beperk de geheugen-buffer en kies een model met minstens 16k context-ondersteuning.
• Timeouts: Indien het lokale model moet nadenken op een minder krachtige GPU, kan de HTTP-verbinding vanuit n8n verlopen. Verhoog de Timeout instelling in n8n HTTP-nodes naar minimaal 120 tot 300 seconden.

Voor een diepere analyse van hardnekkige foutlussen en geavanceerde retry-strategieën verwijzen we naar de community-discussie over agentic loops debuggen op het community-platform. Raadpleeg tevens de maandelijkse analyse op de radarsite over n8n-community signalen van juli 2026 om te zien welke workflow-patronen en foutafhandelingen momenteel populair zijn bij ontwikkelaars. Lees bovendien meer over de bredere marktontwikkelingen en autonome systemen in het overzichtsartikel over agentic AI en autonome systemen.

Stroomverbruik en Operationele Kosten van Continu Draaiende Agents

Een vaak over het hoofd gezien aspect van agentic workflows is het energieverbruik. In tegenstelling tot een gewone chat-interface die pas stroom verbruikt als een gebruiker een vraag typt, kunnen geautomatiseerde n8n-agents (zoals een e-mailverwerker die elke 5 minuten draait) de GPU continu in een hoge actiestand houden.

Een NVIDIA RTX 4090 verbruikt onder piekbelasting tijdens inference ongeveer 350 tot 400 Watt. Als een agentic workflow gemiddeld 4 uur per dag daadwerkelijk actief rekent, komt dat neer op zo'n 1,5 kWh per dag. Bij een gemiddeld elektriciteitstarief van €0,30 per kWh kost het draaien van de agent ongeveer €13,50 per maand aan stroom. Om precies uit te rekenen wat een continu draaiende server kost aan elektriciteit verwijzen we naar de rekenmethode voor het stroomverbruik van lokale AI.

Conclusie en Vervolgstappen

Het combineren van n8n met Ollama vormt een van de krachtigste, meest flexibele en volledig private AI-automatiseringstacks die vandaag de dag beschikbaar zijn. Door de ReAct-lus lokaal uit te voeren behoud je de volledige controle over je data, vermijd je onvoorspelbare cloud-facturen en kun je complexe bedrijfsprocessen doeltreffend automatiseren.

Start klein: bouw eerst een eenvoudige workflow met één enkele tool (zoals het ophalen van een weerbericht of het opslaan van een notitie), controleer hoe je lokale model reageert op de JSON-structuren van n8n, en breid de functionaliteit pas daarna uit met vector-databases en geavanceerde geheugen-buffers.