Mijn eerste experiment met lokale AI begon toen ik merkte dat elke API-call naar ChatGPT of Claude geld kostte en ik geen controle had over privacy van gevoelige projectdata. Ollama bleek de perfecte oplossing om krachtige taalmodellen lokaal te draaien zonder een dure grafische kaart te moeten aanschaffen. Na maanden testen kan ik zeggen dat dit een game-changer is voor developers die AI willen integreren zonder externe afhankelijkheden.
Installatie en eerste configuratie op verschillende systemen
Het installeren van Ollama verschilt per besturingssysteem, maar gelukkig biedt het platform uitstekende ondersteuning voor Windows, macOS en Linux. Op Ubuntu installeer ik Ollama altijd via de officiële script omdat dit automatisch de juiste configuraties instelt:
curl -fsSL https://ollama.ai/install.sh | sh
Windows-installatie verloopt via een MSI-bestand dat je downloadt van de officiële website. Wat ik handig vind is dat Ollama automatisch als service wordt geïnstalleerd, waardoor het in de achtergrond draait zonder dat je er constant aan hoeft te denken. Na de installatie start je gewoon een command prompt en typ je ollama run llama2 om je eerste model te downloaden en te starten.
De eerste keer dat je een model downloadt duurt dit even omdat de bestanden meerdere gigabytes groot zijn. Llama2 7B neemt ongeveer 4GB ruimte in beslag, terwijl Code Llama 7B ongeveer 3.8GB groot is. Ik bewaar alle modellen op een aparte SSD omdat de toegangssnelheid merkbaar invloed heeft op de responstijd van het model.
Memory management en CPU optimalisatie instellingen
Ollama draait standaard met automatische memory management, maar voor betere prestaties pas ik altijd handmatig de instellingen aan. In het configuratiebestand /etc/systemd/system/ollama.service op Linux voeg ik omgevingsvariabelen toe om het geheugen beter te beheren:
[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_MAX_LOADED_MODELS=2"
Environment="OLLAMA_FLASH_ATTENTION=1"
De OLLAMA_NUM_PARALLEL instelling bepaalt hoeveel threads Ollama mag spawnen voor parallelle verwerking. Op mijn 16-core machine zet ik dit op 4 omdat hogere waarden paradoxaal genoeg tot langzamere responstijden leiden. Het model heeft tijd nodig om coherent te blijven denken tussen de threads.
OLLAMA_MAX_LOADED_MODELS houdt meerdere modellen in het geheugen geladen, wat handig is als je switcht tussen verschillende modellen tijdens development. Ik houd dit laag omdat elk geladen model 4-8GB RAM inneemt. Bij weinig geheugen zet ik dit op 1 om memory swapping te voorkomen.
Voor Windows pas je deze instellingen aan via omgevingsvariabelen in het systeem. Ga naar Systeemeigenschappen, Geavanceerd, Omgevingsvariabelen en voeg de variabelen toe aan de systeemvariabelen. Na het instellen herstart je de Ollama service via Services.msc.
Model selectie voor verschillende ontwikkelingstaken
Verschillende AI modellen excelleren in verschillende taken en ik wissel regelmatig tussen modellen afhankelijk van wat ik aan het bouwen ben. Voor code generation en debugging werk ik het liefst met Code Llama omdat dit model specifiek getraind is op programmeercode en beter context begrijpt van programmeertalen:
ollama run codellama:7b-code
Wanneer ik documentatie schrijf of complexere tekstuele taken uitvoer, switch ik naar Llama2 omdat dit model beter is in natuurlijke taal en langere coherente teksten kan produceren. Mistral 7B is mijn go-to voor taken die een balans vereisen tussen code en tekst, zoals het schrijven van API documentatie met codevoorbeelden:
ollama run mistral:7b
Phi-2 van Microsoft presteert verrassend goed voor zo'n klein model (2.7B parameters) en is perfect voor snelle prototyping omdat het veel sneller reageert dan de grotere modellen. Voor projecten waar latency belangrijker is dan absolute accuratesse draai ik vaak Phi-2:
ollama run phi:latest
Het wisselen tussen modellen gaat snel omdat Ollama intelligent cacht welke modellen je recent hebt gebruikt. Het eerste laden van een model duurt 10-30 seconden afhankelijk van je SSD-snelheid, maar daarna gebeurt switchen binnen enkele seconden.
API integratie in PHP projecten
Ollama draait standaard een REST API op poort 11434, wat perfecte integratie met PHP mogelijk maakt. Ik bouw altijd een wrapper klasse die de communicatie met Ollama afhandelt en foutafhandeling implementeert:
<?php
class OllamaClient
{
private $baseUrl;
private $timeout;
public function __construct($host = 'http://127.0.0.1:11434', $timeout = 60)
{
$this->baseUrl = $host;
$this->timeout = $timeout;
}
public function generate($model, $prompt, $options = [])
{
$data = [
'model' => $model,
'prompt' => $prompt,
'stream' => false,
'options' => $options
];
$context = stream_context_create([
'http' => [
'method' => 'POST',
'header' => 'Content-Type: application/json',
'content' => json_encode($data),
'timeout' => $this->timeout
]
]);
$response = file_get_contents($this->baseUrl . '/api/generate', false, $context);
if ($response === false) {
throw new Exception('Failed to connect to Ollama API');
}
return json_decode($response, true);
}
public function listModels()
{
$response = file_get_contents($this->baseUrl . '/api/tags');
return json_decode($response, true);
}
}
Deze klasse handelt de basiscommunicatie af en implementeert timeout handling omdat AI inferentie soms lang kan duren. In Laravel projecten registreer ik deze als een singleton in de service provider zodat ik overal in de applicatie dezelfde Ollama connectie kan hergebruiken.
Streaming responses zijn ook mogelijk door de stream parameter op true te zetten, wat vooral handig is voor lange outputs waar je de gebruiker progressief feedback wilt geven. Dan parse je de response regel voor regel omdat Ollama Server-Sent Events teruggeeft:
public function generateStream($model, $prompt)
{
$data = [
'model' => $model,
'prompt' => $prompt,
'stream' => true
];
$postData = http_build_query($data);
$context = stream_context_create([
'http' => [
'method' => 'POST',
'header' => 'Content-Type: application/x-www-form-urlencoded',
'content' => $postData
]
]);
$handle = fopen($this->baseUrl . '/api/generate', 'r', false, $context);
while (!feof($handle)) {
$line = fgets($handle);
if ($line) {
$data = json_decode($line, true);
if (isset($data['response'])) {
yield $data['response'];
}
}
}
fclose($handle);
}
Performance monitoring en troubleshooting
Het monitoren van Ollama prestaties is cruciaal omdat AI inferentie veel systeemresources kan verbruiken. Ik houd altijd resource usage in de gaten via htop op Linux of Task Manager op Windows terwijl ik met modellen werk. Memory leaks kunnen voorkomen als je veel requests achter elkaar doet zonder de connectie proper af te sluiten.
Temperature en top_p parameters beïnvloeden sterk hoe creatief of conservatief het model antwoordt. Voor code generation zet ik temperature meestal op 0.1 om consistente, voorspelbare output te krijgen. Voor creatieve taken zoals documentatie schrijven verhoog ik dit naar 0.7-0.8:
$options = [
'temperature' => 0.1,
'top_p' => 0.9,
'num_predict' => 512
];
$response = $ollama->generate('codellama:7b-code', $prompt, $options);
num_predict beperkt de lengte van de response, wat belangrijk is omdat lange outputs exponentieel meer tijd kosten. Voor code snippets zet ik dit op 256-512 tokens, voor uitgebreide uitleg op 1024-2048 tokens.
Disk space monitoring is essentieel omdat modellen snel kunnen groeien. Ollama bewaart modellen in ~/.ollama/models op Linux/macOS en %USERPROFILE%\.ollama\models op Windows. Ik ruim regelmatig oude model versies op met ollama rm <model:tag> om ruimte vrij te maken.
Het werken met lokale AI modellen via Ollama heeft mijn development workflow fundamenteel veranderd. Privacy blijft gegarandeerd, er zijn geen API kosten, en de responstijden zijn consistent ongeacht internetverbinding. Voor developers die regelmatig AI assistentie nodig hebben maar controle willen behouden over hun data, is Ollama een onmisbare tool in de moderne development stack.