# De Ollama API koppelen aan je eigen applicatie

De Ollama API koppelen aan je eigen applicatie opent de deur naar automatisering met lokale AI. Ollama draait een lokale server op poort 11434 die je vanuit elke programmeertaal kunt aanroepen. In dit artikel zie je hoe je dat doet met praktische voorbeelden.

[[TOC]]

## De basis van de Ollama API

Zodra Ollama draait, luistert het op `http://localhost:11434`. De belangrijkste endpoints zijn `/api/generate` voor losse prompts, `/api/chat` voor gesprekken met geschiedenis, en het OpenAI-compatibele `/v1/chat/completions` endpoint. Je stuurt een JSON-verzoek en krijgt een JSON-antwoord terug.

:::info title="Twee API-stijlen"
Ollama biedt zowel zijn eigen native API als een OpenAI-compatibele laag. De native API geeft je toegang tot Ollama-specifieke functies, terwijl de OpenAI-laag handig is om bestaande software zonder aanpassing te laten werken.
:::

In de voorbeelden hieronder gebruiken we het model `llama3.2`. Vervang dat gerust door een model dat jij hebt gedownload, bijvoorbeeld `gemma3` of `qwen3`. Welke modellen lokaal beschikbaar zijn, controleer je met `ollama list` of via het `/api/tags` endpoint.

## Een eerste verzoek

Het eenvoudigste verzoek stuur je met curl vanuit de terminal:

```bash
curl http://localhost:11434/api/generate -d '{"model":"llama3.2","prompt":"Leg uit wat een API is","stream":false}'
```

Met `stream` op `false` krijg je het hele antwoord in een keer. Zet je `stream` op `true`, dan komt het antwoord stukje voor stukje binnen, wat fijn is voor een chatinterface.

## Koppelen vanuit Python en JavaScript

In de praktijk roep je de API aan vanuit code. Hieronder zie je hetzelfde verzoek in twee populaire talen.

### Python

Gebruik de `requests`-bibliotheek voor een simpel verzoek:

```python
import requests

r = requests.post('http://localhost:11434/api/generate', json={
    'model': 'llama3.2',
    'prompt': 'Hallo',
    'stream': False,
})
print(r.json()['response'])
```

Voor productie kun je de officiele `ollama`-bibliotheek voor Python gebruiken, die dit netjes inpakt en streaming eenvoudiger maakt.

### JavaScript

Gebruik `fetch` in Node of de browser:

```javascript
const res = await fetch('http://localhost:11434/api/generate', {
  method: 'POST',
  body: JSON.stringify({ model: 'llama3.2', prompt: 'Hallo', stream: false }),
});
const data = await res.json();
console.log(data.response);
```

Er is ook een officiele `ollama`-bibliotheek voor JavaScript die streaming en gesprekken met geschiedenis eenvoudiger maakt.

## De OpenAI-compatibele endpoint

Heb je al code die met de OpenAI-API werkt? Dan hoef je vaak alleen de basis-URL te wijzigen. Wijs je OpenAI-client naar `http://localhost:11434/v1` en gebruik een willekeurige API-sleutel, en je software praat met je lokale model.

```python
from openai import OpenAI

client = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')
antwoord = client.chat.completions.create(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Hallo'}],
)
print(antwoord.choices[0].message.content)
```

:::tip title="Snel van cloud naar lokaal"
Dit is de snelste manier om een bestaande applicatie van de cloud naar lokaal te verhuizen. Verander de `base_url` en het modelveld, en de rest van je code blijft hetzelfde. Ideaal om te testen of lokaal voor jou werkt zonder je hele app te herschrijven.
:::

De compatibiliteit dekt veel voorkomende functies zoals chat completions, tools en embeddings, maar niet elk randgeval van de OpenAI-API. Test dus per functie of het gedrag is wat je verwacht.

## Streaming verwerken

Voor een soepele gebruikerservaring wil je antwoorden stukje voor stukje tonen. Met streaming krijg je een reeks JSON-regels binnen, elk met een stukje tekst. De volgorde is steeds dezelfde:

1. **Verzoek met stream:** stuur het verzoek met `stream` op `true`.
2. **Regels lezen:** lees de binnenkomende JSON-regels een voor een.
3. **Tekst samenvoegen:** plak de `response`-velden achter elkaar.
4. **Tonen aan gebruiker:** toon de tekst terwijl die binnenkomt.

De laatste regel bevat het veld `done` met de waarde `true`, zodat je weet dat het antwoord compleet is.

:::warn title="Stel de API niet open zonder beveiliging"
De Ollama API heeft standaard geen authenticatie omdat hij voor lokaal gebruik is bedoeld. Stel hem nooit zonder extra beveiliging bloot aan het internet, want iedereen die de poort kan bereiken, kan dan je model aanspreken. Zet er bij externe toegang minimaal een reverse proxy met authenticatie voor.
:::

## Modellen kiezen via de API

Je kunt per verzoek een ander model kiezen door het `model`-veld aan te passen. Met een verzoek aan `/api/tags` krijg je een lijst van beschikbare modellen terug, zodat je applicatie dynamisch kan kiezen welk model het gebruikt. Met de omgevingsvariabele `OLLAMA_HOST` stel je in op welk adres en welke poort de server luistert.

:::faq
### Op welke poort draait de Ollama API?
Standaard op poort 11434 op localhost. Je kunt het adres en de poort aanpassen met de omgevingsvariabele `OLLAMA_HOST`.

### Werkt mijn bestaande OpenAI-code met Ollama?
Vaak wel, via het `/v1` endpoint. Wijzig de basis-URL naar `http://localhost:11434/v1` en pas het modelveld aan, dan blijft de meeste code werken. Niet elk randgeval van de OpenAI-API wordt ondersteund, dus test per functie.

### Ondersteunt de API streaming?
Ja, zet `stream` op `true` in je verzoek. Je krijgt het antwoord dan in stukjes binnen, ideaal voor chatinterfaces.

### Heb ik een API-sleutel nodig?
Voor lokaal gebruik niet. De OpenAI-compatibele laag verwacht wel een sleutelveld, maar de waarde mag willekeurig zijn, bijvoorbeeld `ollama`.

### Wat is het verschil tussen /api/generate en /api/chat?
Gebruik `/api/generate` voor een losse prompt zonder context. Gebruik `/api/chat` als je een gesprek met geschiedenis wilt voeren, waarbij je eerdere berichten meestuurt in het `messages`-veld.

### Hoe weet mijn applicatie welke modellen beschikbaar zijn?
Stuur een verzoek aan `/api/tags`. Je krijgt een lijst terug met de modellen die lokaal gedownload zijn, zodat je dynamisch kunt kiezen welk model je gebruikt.
:::

Met de Ollama API bouw je je eigen AI-toepassingen volledig lokaal. Verdiep je verder in [[lokale-ai-rag-pipeline|een RAG-pipeline met eigen documenten]] of [[open-webui-instellen|een kant-en-klare webinterface]].