Systeemontwerp GenAI: grondslagen en architecturen voor productietoepassingen
U probeert een LLM in uw applicatie te integreren en vraagt zich af of u RAG, verfijning of gewoonweg moet doen aanwijzingen verbeteren? Je bent niet de enige: volgens een analyse van 2024 zal de 73% van de GenAI-implementaties in onderneming mislukt binnen zes maanden, voornamelijk als gevolg van onjuiste architectonische keuzes in de fases ontwerp initialen. Het probleem is niet het model: veel teams kiezen eerst voor technologie begrijp het probleem.
Deze gids biedt u een praktisch beslissingskader voor het ontwerpen van GenAI-systemen in productie de fundamentele architecturen – RAG, fine-tuning, prompt engineering – en de criteria voor het kiezen van de aanpak geschikt voor uw specifieke gebruikssituatie.
Wat je gaat leren
- De drie fundamentele architecturen: RAG, fine-tuning en prompt engineering
- Beslissingskader: wanneer welke aanpak te gebruiken
- Systeemarchitecturen voor GenAI-toepassingen in productie
- Technologiestapel 2026: LangChain, LlamaIndex, vLLM
- Gemeenschappelijke patronen en antipatronen die u moet vermijden
- Kwaliteitsmetrieken voor het evalueren van een RAG-systeem
Het 73%-probleem: waarom GenAI-implementaties mislukken
Voordat je in de architectuur stapt, is het van cruciaal belang om te begrijpen waarom zoveel projecten mislukken. De oorzaken De belangrijkste die zijn geïdentificeerd bij post-mortems bij bedrijfsimplementaties zijn:
- Onbeheerde hallucinatie: het model genereert plausibele maar valse antwoorden, en geen validatiesysteem is geïmplementeerd
- Onaanvaardbare latentie:p99 voorbij de 3-5 seconden bij zoekopdrachten die de gebruiker verwacht snel
- Explosieve kosten: geen berekening van de kosten per zoekopdracht vóór de livegang, waarna de budget wordt binnen enkele weken verbrand
- Onbeheerde kennisafsluiting: Het model kent geen recente of privégegevens van het bedrijf
- Gebrek aan traceerbaarheid: onmogelijk om te weten op welke documenten een document is gebaseerd reactie (kritisch in gereguleerde contexten)
Elke architectuur die we zullen bekijken, pakt sommige van deze problemen beter aan dan andere. Het kennen van de trade-off stelt u in staat vanaf het begin robuuste systemen te ontwerpen.
De drie fundamentele architecturen
1. Snelle engineering
Het startpunt voor elk GenAI-systeem: structureer de prompt waar het model naartoe moet leiden de gewenste opbrengst. Belangrijkste technieken in 2026:
- Weinig schoten: Geef invoer-uitvoervoorbeelden op in de prompt
- Keten van gedachte (CoT): vraag het model eerst stap voor stap na te denken beantwoorden
- Systeemprompt: Definieer het gedrag en de context van het model
- Gestructureerde uitvoer: Forceer uitvoer naar JSON- of XML-indeling voor betrouwbare parsering
# Esempio: prompt engineering con structured output
import json
from openai import OpenAI
client = OpenAI()
def analyze_ticket(ticket_text: str) -> dict:
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "system",
"content": """Sei un sistema di triage per ticket di supporto.
Analizza il ticket e restituisci JSON con:
- priority: "high" | "medium" | "low"
- category: "bug" | "feature" | "question"
- sentiment: "frustrated" | "neutral" | "positive"
- estimated_resolution_hours: numero intero"""
},
{
"role": "user",
"content": f"Ticket: {ticket_text}"
}
],
response_format={"type": "json_object"}
)
return json.loads(response.choices[0].message.content)
# Uso
result = analyze_ticket("Il mio account e bloccato da ieri, non riesco ad accedere!")
# {"priority": "high", "category": "bug", "sentiment": "frustrated", ...}
Wanneer moet u het gebruiken?: eenvoudige en goed gedefinieerde cases, snelle prototyping, als dat niet het geval is privégegevens moeten worden geïntegreerd en het basismodel kent het domein al.
Grenzen: werkt niet met recente of bedrijfseigen gegevens, hallucinatie over feiten specifiek, kosten evenredig aan de lengte van de context.
2. RAG – Retrieval-augmented generatie
RAG lost het probleem van kennisafsluiting en privégegevens op: in plaats van alleen te vertrouwen op de kennis van het model, haalt relevante documenten uit een database en plaatst ze in context vóór de generatie.
De basisarchitectuur van een RAG-systeem kent vier fasen:
- Indexering: Documenten worden in stukken gesplitst en omgezet in inbeddingsvectoren en opgeslagen in een vectordatabase
- Ophalen: de zoekopdracht van de gebruiker wordt omgezet in dezelfde insluitingsruimte de meest vergelijkbare brokken worden teruggevonden
- Augmentatie: De opgehaalde chunks worden als context in de prompt ingevoegd
- Generatie: De LLM genereert het antwoord op basis van de verstrekte context
# RAG minimo funzionante con LangChain e Qdrant
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_qdrant import QdrantVectorStore
from langchain.chains import RetrievalQA
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
# 1. Carica e chunka i documenti
loader = PyPDFLoader("manuale_prodotto.pdf")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(
chunk_size=512,
chunk_overlap=64
)
chunks = splitter.split_documents(docs)
# 2. Crea il vector store
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = QdrantVectorStore.from_documents(
documents=chunks,
embedding=embeddings,
url="http://localhost:6333",
collection_name="manuale_prodotto"
)
# 3. Crea la chain RAG
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
rag_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever,
return_source_documents=True
)
# 4. Query
result = rag_chain.invoke({"query": "Come configuro le notifiche email?"})
print(result["result"])
# La risposta cita i documenti recuperati, non inventa
Wanneer moet u het gebruiken?: bedrijfskennisbank, technische documentatie, FAQ, alle geval waarin het antwoord gebaseerd moet zijn op specifieke en traceerbare documenten.
Grenzen: kwaliteit afhankelijk van ophaalkwaliteit, extra latentie, infrastructuur boven het hoofd.
3. Fijnafstemming
Bij fijnafstemming wordt het gedrag van het model aangepast door middel van aanvullende training op het gebied van gegevens domein specifiek. In 2026 is het dominante paradigma het Parameter-efficiënte fijnafstemming (PEFT) met technieken als LoRA en QLoRA die training op consumentenhardware mogelijk maken.
# Fine-tuning con LoRA usando transformers e PEFT
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model, TaskType
import torch
model_name = "meta-llama/Llama-3.1-8B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
model_name,
torch_dtype=torch.bfloat16,
device_map="auto"
)
# Configurazione LoRA: adatta solo il 0.1% dei parametri
lora_config = LoraConfig(
task_type=TaskType.CAUSAL_LM,
r=16, # rank della matrice di adattamento
lora_alpha=32, # scaling factor
lora_dropout=0.1,
target_modules=["q_proj", "v_proj", "k_proj", "o_proj"]
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 6,815,744 || all params: 8,037,191,680
# trainable%: 0.0848%
Wanneer moet u het gebruiken?: Als je duizenden trainingsvoorbeelden hebt, heb je een formaat nodig van zeer specifieke en consistente uitvoer, of u wilt de lengte van de prompt verkorten door voorbeelden te elimineren paar schoten.
Kritisch antipatroon: Niet afstemmen om feitelijke kennis te injecteren (data, cijfers, specifieke feiten). Het model "onthoudt" zonder begrip en hallucinaties hoe dan ook. Gebruik RAG voor kennis.
Het Besliskader
De belangrijkste vraag is niet ‘welke technologie moet ik gebruiken’, maar ‘wat is mijn echte probleem’. Deze beslissingsboom dekt 90% van de gebruiksscenario's:
Hai dati privati o recenti che il modello non conosce?
SI --> Considera RAG come base
NO --> Prompt engineering puo essere sufficiente
Il tuo knowledge base e aggiornato frequentemente?
SI --> RAG (indicizza i nuovi documenti, non ri-addestra)
NO --> Fine-tuning puo essere considerato
Hai 1000+ esempi di coppie input-output di alta qualita?
SI --> Fine-tuning e un'opzione valida
NO --> Stai nei limiti di RAG + few-shot
Hai bisogno di tracciabilita (citare le fonti)?
SI --> RAG obbligatorio
NO --> Piu flessibilita
Latenza critica (sotto 500ms)?
SI --> Fine-tuning (elimina retrieval overhead) o caching aggressivo
NO --> RAG funziona bene
Conclusione tipica 2026:
Start with RAG + prompt engineering
Add fine-tuning solo se RAG non raggiunge qualita richiesta
Systeemarchitectuur voor productie
Een GenAI-systeem van productiekwaliteit gaat veel verder dan alleen "LLM + vectordatabase". De componenten noodzakelijk voor een serieuze inzet:
# Stack minimo per RAG in produzione (Docker Compose)
services:
api:
image: your-genai-api:latest
environment:
OPENAI_API_KEY: ${OPENAI_API_KEY}
QDRANT_URL: http://qdrant:6333
REDIS_URL: redis://redis:6379
depends_on:
- qdrant
- redis
qdrant:
image: qdrant/qdrant:v1.9.0
volumes:
- qdrant_storage:/qdrant/storage
ports:
- "6333:6333"
redis:
image: redis:7-alpine
# Semantic cache: evita LLM calls per query simili
volumes:
- redis_data:/data
prometheus:
image: prom/prometheus:latest
# Monitora: latency p50/p95/p99, costo per query, quality score
grafana:
image: grafana/grafana:latest
# Dashboard: LLM performance, retrieval quality, cost tracking
De kritische componenten die een prototype scheiden van een productiesysteem:
- Semantische caching (Redis + bibliotheek zoals GPTCache): verlaagt de kosten met 30-60% voor toepassingen met soortgelijke terugkerende vragen
- Waarneembaarheid: volg elke LLM-oproep met latentie, gebruikte tokens, kosten en kwaliteitsscore — zonder deze gegevens kunt u niet optimaliseren
- Terugvalstrategie: wat gebeurt er als OpenAI niet beschikbaar is? Je hebt een lokaal model hoe een back-up maken?
- Tariefbeperking en quotabeheer: Bescherm uw budget tegen vragen afwijkend
- PII-detectie: voordat u gegevens naar de LLM verzendt, persoonlijke gegevens detecteren en verbergen gevoelig
De technologiestapel van 2026
Het GenAI-ecosysteem heeft zich gestabiliseerd rond een paar dominante spelers:
Aanbevolen stapel 2026
- Orkestratie: LangChain v0.3+ of LlamaIndex v0.10+ voor complexe RAG-pijplijnen; LangGraph voor agentworkflows
- Vectordatabase: Qdrant (zelf gehost, uitstekende prestaties), pgvector (al in PostgreSQL, minder dan 1 miljoen vectoren), Pinecone (beheerd, gegarandeerde latentie)
- Gevolgtrekking: vLLM of TensorRT-LLM voor zelf-gehoste open source-modellen; OpenAI/Antropisch voor cloud-API's
- Inbedding: text-embedding-3-small door OpenAI (1536 dim, $0,02/1M token) of all-MiniLM-L6-v2 voor gratis zelfhosting
- Waarneembaarheid: LangSmith, Weights & Biases Weave, of Phoenix voor tracering van kettingen
- Evaluatie: RAGAS voor geautomatiseerde RAG-statistieken (trouw, antwoordrelevantie, contextherinnering)
Kwaliteitsstatistieken voor RAG-systemen
Hoe weet u of uw RAG-systeem goed werkt? Het RAGAS-framework definieert meetbare statistieken:
# Valutazione automatica con RAGAS
from ragas import evaluate
from ragas.metrics import (
faithfulness, # la risposta e supportata dai documenti recuperati?
answer_relevancy, # la risposta risponde alla domanda?
context_recall, # i documenti recuperati contengono le info necessarie?
context_precision # i documenti recuperati sono tutti rilevanti?
)
from datasets import Dataset
# Dataset di test (ground truth necessario)
test_data = {
"question": ["Come configuro l'autenticazione 2FA?"],
"answer": ["Per configurare 2FA, vai in Impostazioni > Sicurezza..."],
"contexts": [["Documentazione 2FA: ...", "Guida sicurezza: ..."]],
"ground_truth": ["La 2FA si configura tramite l'app mobile nelle impostazioni sicurezza"]
}
dataset = Dataset.from_dict(test_data)
result = evaluate(dataset, metrics=[
faithfulness,
answer_relevancy,
context_recall,
context_precision
])
print(result)
# faithfulness: 0.95 (la risposta non inventa)
# answer_relevancy: 0.88 (la risposta e pertinente)
# context_recall: 0.82 (i doc recuperati coprono la risposta)
# context_precision: 0.91 (i doc recuperati sono rilevanti)
Realistische doelstellingen voor een productiesysteem: betrouwbaarheid > 0,85 (kritisch: daaronder drempelhallucinaties komen vaak voor), antwoord_relevantie > 0,80, context_herinnering > 0,75.
Antipatronen die u moet vermijden
- Vaste chunkgrootte voor alle documenten: gestructureerde documenten (FAQ, API-documenten) vereisen dat er andere dan verhalende tekst wordt gefragmenteerd
- Alleen semantisch ophalen: faalt op exacte technische voorwaarden; gebruik hybride zoeken (BM25 + semantisch)
- Geen herschikking: de top-k-vectoren zijn niet noodzakelijkerwijs de meest bruikbare; een cross-encoder verbetert de nauwkeurigheid met 15-20%
- RAG zonder voortdurende evaluatie: De kwaliteit neemt af bij documenten ze veranderen; bewaakt de getrouwheid van de productie
- Finetuning als eerste keuze: en duur en langzaam; RAG is er bijna altijd juiste beweging om te beginnen
Conclusies en volgende stappen
Het systeemontwerp voor GenAI-toepassingen vereist architectonische keuzes die veel verder gaan modelselectie. De vuistregel voor 2026: begint altijd met RAG + prompt techniek, meet de kwaliteit met RAGAS en voeg alleen verfijning toe als er sprake is van een kloof kwaliteit blijft bestaan na retrievaloptimalisatie.
In de volgende artikelen in deze serie gaan we dieper in op elk onderdeel: de selectie van juiste vectordatabase, chunkingstrategieën, hybride zoek- en agentarchitectuur met LangGraf.