Vandaag heb ik de eerste dag afgerond van de cursus LLM Engineering: Master AI and Large Language Models. De focus lag niet zozeer op de theorie achter AI, maar vooral op het opzetten van een professionele ontwikkelomgeving en het bouwen van de eerste werkende AI-toepassingen.
Wat ik prettig vond aan deze aanpak is dat je direct aan de slag gaat. Geen urenlange introducties over wat AI is, maar meteen zelf een lokale LLM draaien, een OpenAI API-key configureren en je eerste prompts versturen.
Wat kwam er aan bod?
Dag 1 bestond uit een aantal praktische onderdelen:
- Open-source LLM's lokaal draaien met Ollama
- Een demo van een AI-taaldocent op basis van open-source modellen
- Het opzetten van een development omgeving met Cursor en UV
- Git configureren en de cursusrepository clonen
- OpenAI API-keys en environment variables configureren
- Jupyter Notebooks gebruiken voor experimenten
- Het verschil leren tussen system prompts en user prompts
- Een eerste OpenAI API-call uitvoeren
- Een eenvoudige website summarizer bouwen
- Zelfstandig een API-integratie vanaf nul opzetten
Na één dag had ik al een volledig werkende AI-ontwikkelomgeving draaien.
Lokale modellen met Ollama
Een van de interessantste onderdelen vond ik het lokaal draaien van modellen via Ollama.
Met één commando kon ik een model downloaden en direct gebruiken:
ollama run llama3
Dit gaf direct inzicht in hoe Large Language Models werken zonder afhankelijk te zijn van externe API's. Daarnaast biedt lokaal draaien interessante voordelen op het gebied van privacy, kosten en experimenteerruimte.
Moderne Python Development met UV
In plaats van de traditionele Python-tooling werd gebruikgemaakt van UV.
Dat voelde direct een stuk moderner:
- snelle package installs
- eenvoudig beheer van virtuele omgevingen
- automatische dependency locking
- minder configuratie
De setup was verrassend eenvoudig:
uv venv
uv add openai python-dotenv jupyter
Voor iemand die gewend is aan moderne JavaScript workflows voelt UV direct vertrouwd.
Mijn Eerste OpenAI API Call
Het hoogtepunt van de dag was het maken van de eerste echte OpenAI API-integratie.
In essentie bestaat zo'n integratie uit drie stappen:
- Authenticeren met een API-key
- Een prompt versturen
- De response verwerken
Een vereenvoudigd voorbeeld:
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Explain what an LLM is."
}
]
)
Wat hierbij direct duidelijk werd, is dat de kwaliteit van de output sterk afhankelijk is van de kwaliteit van de prompt.
System Prompts vs User Prompts
Een belangrijk concept dat tijdens dag 1 werd geïntroduceerd is het verschil tussen system prompts en user prompts.
De system prompt bepaalt het gedrag van het model:
You are a helpful assistant.
De user prompt bevat de daadwerkelijke opdracht:
Explain what an LLM is.
Dit lijkt een klein verschil, maar heeft een grote impact op hoe een model reageert.
Een Website Summarizer Bouwen
Later op de dag werd een eenvoudige website summarizer gebouwd met behulp van de OpenAI API.
De workflow was verrassend simpel:
Website content
↓
Prompt opbouwen
↓
OpenAI API
↓
Samenvatting genereren
Dit liet direct zien hoe krachtig LLM's kunnen zijn voor het verwerken en samenvatten van grote hoeveelheden tekst.
Experimenteren in Jupyter
Voor veel van de oefeningen werd gebruikgemaakt van Jupyter Notebooks.
Dat bleek ideaal voor:
- snel testen van prompts
- experimenteren met API-calls
- iteratief ontwikkelen
- direct inspecteren van responses
Voor AI-development begrijp ik nu goed waarom notebooks zo populair zijn.
Eerste Indruk
Na dag 1 is mijn belangrijkste conclusie dat werken met LLM's technisch minder complex is dan ik vooraf dacht.
De uitdaging zit niet in het versturen van een API-request.
De echte uitdaging zit in:
- goede prompts schrijven
- context beheren
- consistente output genereren
- workflows ontwerpen
- kosten en tokengebruik beheersen
Oftewel: het model gebruiken is eenvoudig, maar het bouwen van goede AI-applicaties blijft gewoon software engineering.
Op naar Dag 2
Met een werkende lokale LLM, een OpenAI-integratie en een moderne ontwikkelomgeving staat de basis nu klaar.
Ik ben benieuwd hoe de cursus verder ingaat op onderwerpen zoals embeddings, retrieval, agents en productieklare AI-systemen.
Maar voor een eerste dag was dit een uitstekende introductie in de wereld van LLM Engineering.
Wat betekent dit voor Drupal?
Hoewel de oefeningen op dag 1 relatief eenvoudig waren, zag ik direct een aantal interessante toepassingen voor Drupal.
De website summarizer die we tijdens het lab bouwden, is namelijk niet veel anders dan wat een Drupal-module zou kunnen doen met node-content.
Een aantal van deze functies is zelfs al (deels) gebouwd in Drupal AI Initiative
Automatische Samenvattingen
Een eerste toepassing zou kunnen zijn om automatisch samenvattingen te genereren voor artikelen.
Workflow:
Node content
↓
Build Prompt
↓
OpenAI API
↓
Summary
↓
Opslaan in Summary field
Dit kan redacteuren tijd besparen en zorgt voor consistente teasers en introductieteksten.
SEO Metadata Genereren
Dezelfde techniek kan worden gebruikt voor:
- SEO titels
- meta descriptions
- social media samenvattingen
In plaats van dat een redacteur alles handmatig invult, kan Drupal suggesties genereren op basis van de inhoud van een node.
Content Assistent voor Redacteuren
Met een eenvoudige OpenAI-integratie zou Drupal redacteuren kunnen helpen bij het:
- herschrijven van teksten
- inkorten van content
- verbeteren van leesbaarheid
- vertalen van teksten
- aanpassen van tone-of-voice
De technische basis hiervoor is exact hetzelfde als de API-calls die tijdens dag 1 werden gebouwd.
Slimme Taxonomie Suggesties
Op basis van de inhoud van een node kan AI automatisch relevante tags of categorieën voorstellen.
Workflow:
Node content
↓
OpenAI API
↓
Analyse
↓
Taxonomy suggesties
Dit kan helpen om content consistenter te classificeren.
Lokale AI met Ollama
Een van de interessantste onderdelen van dag 1 vond ik het werken met Ollama.
Daardoor hoeft een Drupal-integratie niet per se afhankelijk te zijn van externe AI-diensten zoals OpenAI.
In plaats van:
Drupal
↓
OpenAI API
zou een architectuur er ook zo uit kunnen zien:
Drupal
↓
Ollama
↓
Llama 3
Dat biedt voordelen op het gebied van:
- privacy
- kosten
- controle over data
- self-hosting
Voor organisaties die geen content naar externe AI-platformen willen sturen, is dat een interessante optie.
Eerste Conclusie
Na dag 1 werd al snel duidelijk dat de technische drempel om AI-functionaliteit toe te voegen verrassend laag is.
De echte uitdaging zit niet in het versturen van een API-request, maar in het ontwerpen van goede prompts, workflows en gebruikerservaringen.
Voor Drupal zie ik vooral kansen in het ondersteunen van redacteuren, het automatiseren van contenttaken en het slimmer benutten van bestaande content.
En dat alles begint eigenlijk met dezelfde eenvoudige bouwsteen die tijdens dag 1 centraal stond:
response = client.chat.completions.create(...)
Een simpele API-call, maar met een enorme hoeveelheid mogelijkheden daarachter.
