OpenClaw met Ollama gebruiken: een lokale data-analist bouwen

Waarom OpenClaw met Ollama draaien?

OpenClaw met een lokaal Ollama-model draaien verandert je systeem in een zelfstandige AI-omgeving. In plaats van prompts en data naar externe API's te sturen, draait de volledige workflow, inclusief redeneren, bestands­toegang en het genereren van artefacten, op je eigen machine.

Deze opzet biedt verschillende praktische voordelen:

• Privacy by design: Alle datasets, documenten en tussentijdse outputs blijven op het apparaat. Er wordt niets naar externe diensten verzonden.
• Volledige transparantie en controle: Elke stap is te inspecteren, van het slash-commando dat naar OpenClaw is verzonden tot de gegenereerde bestanden en de uitvoeringstrace.
• Offline werken: Zodra het model via Ollama is gedownload, werkt het systeem zonder internettoegang.
• Agent-stijl uitvoering: Eén gebruikersverzoek kan een workflow met meerdere stappen starten in plaats van slechts één tekstantwoord.

Deze tutorial richt zich op het bouwen van een lokale agentarchitectuur, waarbij OpenClaw fungeert als de uitvoeringsmotor en Ollama de redeneerslaag levert.

OpenClaw Ollama-tutorial: bouw een lokale data-analist

mIn deze sectie bouwen we een Local Data Analyst-toepassing die volledig op je machine draait met OpenClaw en een lokaal Ollama-model. Op hoofdlijnen voert het systeem drie kerntaken uit:

• Een CSV-dataset van de gebruiker accepteren
• Eventueel ondersteunende contextdocumenten (PDF, TXT of Markdown) inlezen
• Een meerstapsanalyse-workflow draaien om inzichten en visualisaties te genereren

Het systeem produceert drie outputartefacten:

• trend_chart.png
• analysis_report.md
• tool_trace.json

Achter de schermen wordt de workflow gecoördineerd door drie componenten:

• Webinterface(web_assistant.py): Dit Python-bestand verwerkt bestandsuploads, maakt een runtime-map aan en stuurt een slash-commando naar OpenClaw.
• OpenClaw-agent: De OpenClaw-agent laadt de workspace-skill, voert lokale commando's uit via tools en gebruikt lokale LLM's gehost via Ollama voor redeneren en samenvatten.
• Analyse-engine (main.py): Dit bestand leest de dataset, leidt relevante kolommen af, genereert grafieken en inzichten en schrijft alle outputs naar schijf.

Zodra de workflow is voltooid, toont de webinterface een preview van de gegenereerde artefacten, zodat de gebruiker de resultaten en de uitvoeringstrace kan bekijken.

Stap 1: Installeer OpenClaw

Voordat we de Local Data Analyst-workflow bouwen, hebben we de OpenClaw Gateway op je machine nodig. Zie OpenClaw als de uitvoeringslaag in dit project, die verzoeken van de web-UI ontvangt, de workspace-skill laadt, lokale tools (zoals shell-commando's en Python-scripts) draait en de volledige workflow end-to-end coördineert.

curl -fsSL https://openclaw.ai/install.sh | bash
openclaw onboard --install-daemon

Dit commando installeert de OpenClaw-CLI, draait de onboarding-wizard om de lokale omgeving te configureren en zet de gateway-daemon op zodat je deze gemakkelijk kunt starten en stoppen. Hoewel we de gateway voor deze demo op de voorgrond draaien, zorgt het installeren van de daemon voor een standaardopzet en maakt het oplossen van problemen eenvoudiger.

Laten we nu bevestigen dat alles werkt:

openclaw doctor
openclaw gateway status

De OpenClaw doctor meldt dat OpenClaw correct is geïnstalleerd. De OpenClaw gateway status vertelt je of de gateway momenteel draait. In dit stadium kan er "not running" staan, maar dat is prima. Het belangrijkste is dat het commando werkt en de installatie wordt herkend.

Als je een gedetailleerde uitleg wilt van elke onboarding-optie (kanalen, auth, skills, gatewaybeveiliging), kun je de OpenClaw-tutorial raadplegen voor een complete stap-voor-stap-setup.

Stap 2: Installeer Ollama

Vervolgens richten we Ollama in, dat zal fungeren als de lokale LLM-backend voor dit project. OpenClaw blijft de workflow orkestreren, maar wanneer er modelintelligentie nodig is voor samenvatten of redeneren, roept het LLM's aan via Ollama. 

Voer de volgende commando's uit:

brew install ollama
ollama serve
ollama pull qwen3:8b

De bovenstaande commando's installeren de Ollama-runtime, starten de lokale modelserver waarmee OpenClaw zal communiceren en downloaden het qwen3:8b-model. We gebruiken qwen3:8b omdat het een goede balans biedt tussen prestaties en kwaliteit voor de meeste laptops, maar je kunt een ander model kiezen op basis van de resources van je systeem. Je kunt ook deze handleiding van Ollama raadplegen voor deze setup. 

Stap 3: Configureer OpenClaw

Vervolgens moeten we OpenClaw configureren om de lokale Ollama-instantie te gebruiken. Dit zorgt ervoor dat al het redeneren, samenvatten en analyseren volledig op je eigen machine gebeurt, zonder externe API-calls.

Maak een lokale configuratiemap aan:

mkdir -p .openclaw-local

Maak vervolgens het bestand aan:

.openclaw-local/openclaw.json

{
  "models": {
    "providers": {
      "ollama": {
        "baseUrl": "http://127.0.0.1:11434/v1",
        "apiKey": "ollama-local",
        "api": "openai-completions",
        "models": [
          {
            "id": "qwen3:8b",
            "name": "qwen3:8b",
            "reasoning": false,
            "input": ["text"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 131072,
            "maxTokens": 8192
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": { "primary": "ollama/qwen3:8b" }
    }
  },
  "tools": {
    "web": {
      "search": { "enabled": false },
      "fetch": { "enabled": true }
    }
  }
}

De bovenstaande configuratie definieert drie belangrijke componenten:

• De baseUrl wijst naar het lokale API-eindpunt dat door ollama serve wordt blootgesteld, terwijl de instelling api: openai-completions OpenAI-compatibele communicatie inschakelt. De modelregistratie voor qwen3:8b specificeert de mogelijkheden, waaronder een groot 131K contextvenster voor het verwerken van omvangrijke datasets en een tokenlimiet voor gecontroleerde responses. Omdat het model lokaal draait, staan alle kostwaarden op nul.
• De sectie agent defaults bepaalt welk model OpenClaw-agents gebruiken voor redeneren. Door het primaire model in te stellen op ollama/qwen3:8b, wordt elke agenttaak, zoals het interpreteren van prompts, het genereren van samenvattingen of redeneren over data, automatisch doorgestuurd naar het lokale Ollama-model zonder externe API-calls.
• De toolconfiguratie beheert externe mogelijkheden zoals websearch, die is uitgeschakeld om privacy te waarborgen en uitgaande verzoeken te voorkomen. De fetch-tool blijft ingeschakeld voor beperkte resource-opvraging wanneer nodig. 

Samen zorgen deze instellingen ervoor dat de volledige workflow privé op je machine draait, waarbij OpenClaw de orkestratie verzorgt en Ollama lokale intelligentie levert.

Stap 4: Definieer de workspace-skill

In deze stap definiëren we de workspace-skill die OpenClaw vertelt hoe onze workflow moet worden uitgevoerd. In plaats van het model te laten plannen welke tools worden gebruikt, gebruiken we command dispatch-modus, waarmee een slash-commando direct een lokaal uitvoeringscommando triggert. Dat maakt de workflow sneller en volledig lokaal.

Laten we het volgende SKILL.md bestand in je workspace maken:

---
name: local-data-analyst
description: Local Data Analyst: analyze private local data with Ollama, generate chart/report, and keep all data on-device.
user-invocable: true
command-dispatch: tool
command-tool: exec
command-arg-mode: raw
---
Invoke as /local-data-analyst <raw command>.
This skill bypasses model planning and dispatches raw command text directly to the exec tool.
Use this exact command template in this workspace:
python3 /……/main.py --docs-dir <context_dir> --data-file <data_file> --output-dir <output_dir> --prompt "<prompt>" --use-ollama --model qwen3:8b
Expected outputs under <output_dir>:
- trend_chart.png
- analysis_report.md
- tool_trace.json

Deze skillconfiguratie bepaalt hoe OpenClaw de analyse uitvoert:

• De front matter(een gestructureerd metadata-blok helemaal bovenaan een bestand) definieert een door de gebruiker aanroepbare skill met de naam local-data-analyst, die beschikbaar komt als het slash-commando /local-data-analyst.
• Een slash-commando is de manier van OpenClaw om gestructureerde acties te triggeren vanuit chat of de UI.
• De instelling command-dispatch: tool schakelt de command dispatch-modus in, waarbij OpenClaw het commando direct naar een tool stuurt in plaats van het model te vragen wat te doen.
• Met command-arg-mode: raw wordt de volledige commandoregel ongewijzigd doorgegeven aan de exec-tool, wat zorgt voor voorspelbare uitvoering.
• Het commando draait het lokale main.py-script, dat:
• De dataset en optionele contextdocumenten laadt
• Ollama (qwen3:8b) gebruikt voor redeneren en samenvattingen
• Drie artefacten genereert, waaronder een grafiek, een markdown-rapport en een tool-uitvoeringstrace

Zo verzorgt OpenClaw de orkestratie en uitvoering, terwijl Ollama lokaal redeneert. In de volgende stap verbinden we deze skill met een webinterface zodat gebruikers data kunnen uploaden en de analyse met één actie kunnen starten.

Stap 5: Maak een webinterface

Op dit punt hebben we al twee kernonderdelen werkend: een OpenClaw workspace-skill en een lokale modelbackend (Ollama) die redeneert. Nu hebben we een lichtgewicht interface nodig waarmee je bestanden kunt uploaden en runs kunt starten zonder telkens de terminal te gebruiken.

Het bestand web_assistant.py fungeert als een dunne frontendserver die:

• Bestandsuploads accepteert,
• Voor elke uitvoering een geïsoleerde runtime-map aanmaakt,
• Een OpenClaw slash-commando opbouwt dat naar de bestanden op schijf wijst,
• De OpenClaw-agent lokaal aanroept,
• Op outputs wacht,
• Artefacten gereed voor preview naar de browser terugstuurt.

De belangrijkste ontwerpkeuze hier is dat de webserver zelf nooit analyselogica draait. Alles wordt gedelegeerd aan OpenClaw, zodat de UI eenvoudig blijft. 

Stap 5.1: Het slash-commando bouwen

Het doel hier is om één string te produceren die OpenClaw als chatbericht kan ontvangen, zoals: /local-data-analyst python3 ... --data-file ... --output-dir …

def build_slash_command(
    data_path: Path,
    docs_dir: Path,
    output_dir: Path,
    prompt: str,
    model: str,
    x_col: str,
    y_col: str,
) -> str:
    args = [
        "python3",
        str(BASE_DIR / "src" / "main.py"),
        "--docs-dir", str(docs_dir),
        "--data-file", str(data_path),
        "--output-dir", str(output_dir),
        "--prompt", prompt,
        "--use-ollama",
        "--model", model,
    ]
    if x_col:
        args.extend(["--x-column", x_col])
    if y_col:
        args.extend(["--y-column", y_col])
    raw = " ".join(shlex.quote(a) for a in args)
    return f"/local-data-analyst {raw}"

De functie build_slash_command() bereidt de exacte instructie voor die naar OpenClaw wordt gestuurd. In plaats van de analyse direct uit te voeren, construeert de webapp een gestructureerd slash-commando dat OpenClaw kan routeren naar de juiste workspace-skill. Deze functie voert vier kerntaken uit:

• De lijst args definieert de CLI-aanroep naar src/main.py. Dit is hetzelfde commando dat je handmatig vanuit de terminal zou kunnen draaien.
• De vlaggen --x-column en --y-column worden alleen toegevoegd wanneer ze zijn opgegeven. Als deze waarden ontbreken, kan het analysescript de kolommen automatisch uit de dataset afleiden.
• De aanroep shlex.quote() ontsnapt alle argumenten, inclusief de gebruikersprompt. Dit is cruciaal voor het afhandelen van spaties en speciale tekens en voorkomt command-injectionrisico's bij het doorgeven van gebruikersinvoer aan een shell-commando.

De functie retourneert een string die begint met: /local-data-analyst. Deze prefix komt overeen met de skillnaam gedefinieerd in SKILL.md. Wanneer OpenClaw dit slash-commando ontvangt, routeert het het verzoek direct naar de local-data-analyst workspace-skill, die het commando vervolgens uitvoert via de exec-tool.

Stap 5.2: OpenClaw-uitvoering 

Nu we het slash-commando hebben, sturen we het naar OpenClaw met de CLI agent runner. Hier draagt de webapp de uitvoering over.

slash_message = build_slash_command(
    data_path=data_path,
    docs_dir=docs_dir,
    output_dir=output_dir,
    prompt=prompt,
    model=model,
    x_col=x_col,
    y_col=y_col,
)
agent_cmd = [
    "openclaw", "agent",
    "--local",
    "--session-id", f"stealth-web-{run_id}",
    "--message", slash_message,
    "--timeout", "120",
]
proc = subprocess.run(agent_cmd, capture_output=True, 
                     text=True, env=openclaw_env())

De OpenClaw-agentaanroep is het overdrachtspunt waar de webapp stopt met werken en in plaats daarvan aan OpenClaw vraagt om de workflow end-to-end uit te voeren. 

• Met --local zorg je ervoor dat de run op je eigen machine blijft, en verwerkt de agent het verzoek via je lokale gateway en het door Ollama ondersteunde model in plaats van een gehoste dienst.
• De vlag --session-id stealth-web-{run_id} geeft elke run een eigen, geïsoleerde sessienaamruimte, wat voorkomt dat state tussen runs lekt en het eenvoudig maakt een specifieke uitvoering later te debuggen. 
• Het argument --message geeft de slash-commando­string door precies zoals een gebruiker die in chat zou typen; OpenClaw ontvangt deze, routeert hem naar de /local-data-analyst-skill en voert het onderliggende commando uit via de exec-tool. 
• Tot slot fungeert --timeout 120 als een veiligheidsklep zodat de web-UI niet eindeloos blijft hangen als de analyse vastloopt, en dwingt env=openclaw_env() het subprocess om je project-lokale OpenClaw-config en -statedirectory te gebruiken, zodat het consistent de beoogde Ollama-setup aanstuurt.

In de volgende stap laden we de gegenereerde artefacten, waaronder een grafiek, rapport en tooltrace, en renderen we lichte previews in de browser.

Stap 5.3: Server-setup

Tot slot draait web_assistant.py een piepkleine lokale HTTP-server zodat je via de browser kunt interacteren.

 def main() -> int:
    host = "127.0.0.1"
    port = 8765
    server = ThreadingHTTPServer((host, port), Handler)
    print(f"Local Data Analyst web UI: http://{host}:{port}")
    print("Press Ctrl+C to stop.")
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        pass
    return 0

Dit houdt deployment eenvoudig:

• ThreadingHTTPServer maakt meerdere verzoeken mogelijk zonder de hele app te blokkeren.
• Al het "echte werk" gebeurt in de request-Handler, die uploads ontvangt, run-mappen aanmaakt, OpenClaw triggert en previews terugstuurt.

Let op: De volledige implementatie van web_assistant.py is beschikbaar in de GitHub-repo van het project.

Stap 6: Bouw de lokale analyse-engine

Op dit punt kan OpenClaw de workflow al uitvoeren via de workspace-skill en kan de web-UI runs triggeren via een slash-commando. Het resterende onderdeel is de analyse-engine die je geüploade bestanden verwerkt, de workflowstappen draait en de artefacten produceert.

Het bestand main.py in deze repo richt zich op twee functies die de kern van de pipeline vormen, namelijk het laden van tabeldata en het aanroepen van Ollama voor lokaal redeneren. 

Stap 6.1: Tabeldata laden 

Deze helper ondersteunt meerdere invoerformaten terwijl de workflow consistent blijft.

def load_tabular_data(data_path: Path, events: List[SkillEvent]) -> pd.DataFrame:
    ext = data_path.suffix.lower()
    if ext == ".csv":
        df = pd.read_csv(data_path)
    elif ext in {".tsv", ".tab"}:
        df = pd.read_csv(data_path, sep="\t")
    elif ext in {".json", ".jsonl"}:
        try:
            df = pd.read_json(data_path)
        except ValueError:
            df = pd.read_json(data_path, lines=True)
    elif ext in {".xlsx", ".xls"}:
        df = pd.read_excel(data_path)
    else:
        raise ValueError(f"Unsupported data file...")
    log_event(events, "fs", "read", f"Loaded data file: {data_path.name}")
    return df

De functie load_tabular_data() detecteert het bestandstype met data_path.suffix en stuurt het door naar de juiste pandas-loader. CSV- en TSV-bestanden worden verwerkt met read_csv(), waarbij TSV/tab-bestanden simpelweg de scheidingsteken wijzigen naar \t. JSON-inputs worden eerst verwerkt met read_json() en als pandas een ValueError geeft, valt het terug op lines=True voor JSONL. Excel-ondersteuning is toegevoegd via read_excel() zodat gebruikers .xlsx-bestanden kunnen uploaden zonder preprocessing.

Tot slot registreert de aanroep log_event() een gestructureerde trace-entry die de pipeline later kan serialiseren naar tool_trace.json. 

Stap 6.2: Ollama-integratie 

Omdat deze demo niet afhankelijk is van een SDK, roept hij rechtstreeks de lokale HTTP-API van Ollama aan.

def ollama_generate(model: str, prompt: str) -> str:
    url = "http://localhost:11434/api/generate"
    payload = json.dumps({
        "model": model, 
        "prompt": prompt, 
        "stream": False
    }).encode("utf-8")
    req = request.Request(url, data=payload, 
                         headers={"Content-Type": "application/json"})    
    with request.urlopen(req, timeout=45) as resp:
        body = json.loads(resp.read().decode("utf-8"))
    return str(body.get("response", "")).strip()

De functie ollama_generate() stuurt een JSON-payload naar Ollama's /api/generate-endpoint op localhost. De payload specificeert de modelnaam (bijvoorbeeld qwen3:8b), de uiteindelijke promptstring en schakelt streaming uit zodat de functie één compleet antwoord retourneert.

Door urllib.request te gebruiken blijft deze wrapper lichtgewicht en draagbaar, en de guard timeout=45 voorkomt dat onze workflow oneindig blijft hangen als het model traag is of de server uitvalt. Tot slot extraheert de functie de modeloutput uit het veld response en retourneert schone tekst, die later wordt gebruikt om het bestand analysis_report.md te schrijven.

Stap 7: Bouw de webserver

Hier is een klein startscript om de lokale web-UI te starten die uploads accepteert en OpenClaw-runs achter de schermen triggert.

set -euo pipefail
ROOT="$(cd "$(dirname "$0")" && pwd)"
cd "$ROOT/.."
python3 ../web_assistant.py

Dit script doet drie dingen:

• set -euo pipefail laat het script snel falen, d.w.z. het stopt bij fouten, behandelt niet-ingestelde variabelen als fouten en voorkomt stille fouten in pipelines.
• ROOT=... bepaalt de map waarin het script zich bevindt, zodat het werkt zelfs als je het vanaf een andere locatie draait.
• cd "$ROOT/.." gaat naar de verwachte projectroot en start vervolgens web_assistant.py, die de UI host en de volledige pipeline afhandelt.

Zodra dit script draait, wordt je browser-UI de voordeur voor de demo.

Stap 8: Start het systeem

Voor de laatste stap draaien we het systeem met een tweestatus-setup. De OpenClaw-gateway handelt alle taakuitvoering af, terwijl de webinterface fungeert als de gebruikerslaag voor het indienen van verzoeken en het bekijken van de gegenereerde outputs.

Terminal 1:  Gateway

Voordat we de interface starten, starten we eerst de OpenClaw-gateway. Dit proces fungeert als de uitvoeringslaag voor het systeem, verwerkt agentverzoeken, laadt de workspace-skill, roept lokale tools aan en routeert redeneer-calls naar het Ollama-model.

export OPENCLAW_CONFIG_PATH="$PWD/.openclaw-local/openclaw.json"
openclaw gateway --force

In deze terminal wijst OPENCLAW_CONFIG_PATH OpenClaw naar de project-lokale config, waar we het standaardmodel hebben vastgezet op ollama/qwen3:8b en websearch hebben uitgeschakeld voor privacy.  Vervolgens start openclaw gateway --force de gateway zelfs als OpenClaw denkt dat er al iets draait of gedeeltelijk geconfigureerd is. 

Als de gateway actief is, is hij klaar om lokale agentberichten te accepteren (inclusief ons slash-commando /local-data-analyst).

Terminal 2: Web-UI

Zodra de gateway draait, starten we de webinterface, die gebruikersinputs verzamelt, elk verzoek naar de lokale OpenClaw-agent stuurt en de gegenereerde grafieken, rapporten en uitvoeringstraces weergeeft.

./local_data_analyst/run_web.sh

Open vervolgens:

http://127.0.0.1:8765

De webserver draait op 127.0.0.1, dus is alleen toegankelijk vanaf je eigen machine. Wanneer je op Run Analysis klikt, schrijft de UI een run-map weg, construeert het slash-commando, roept openclaw agent --local aan en polt vervolgens de schijf op de outputbestanden zodat het een preview kan tonen van:

• trend_chart.png
• analysis_report.md
• tool_trace.json

De uiteindelijke output zal er ongeveer zo uitzien. Je kunt deze demo testen met een paar voorbeeldbestanden.

Conclusie

In deze tutorial hebben we een local-first AI-toepassing gebouwd waarbij een eenvoudige webinterface een volledige agentworkflow triggert, aangestuurd door OpenClaw en een lokaal Ollama-model. In plaats van externe API's aan te roepen, blijft de hele lus op je eigen machine.

OpenClaw verzorgt orkestratie en tooluitvoering, terwijl Ollama de lokale intelligentielaag biedt. Het resultaat is een agent-stijl workflow waarbij één verzoek gestructureerde artefacten oplevert, zoals visualisaties, rapporten en audittrails.

Vanaf hier kun je dit project in verschillende richtingen uitbreiden. Je kunt nieuwe workspace-skills toevoegen voor andere workflows, extra lokale tools integreren (bijvoorbeeld database­queries of documentsearch), of OpenClaw verbinden met messagingkanalen zoals Slack of WhatsApp voor veilige externe toegang. 

Je kunt ook experimenteren met verschillende Ollama-modellen om prestaties en kwaliteit in balans te brengen op basis van je hardware.

Wil je meer leren over werken met AI in je workflows? Bekijk dan de AI-Assisted Coding for Developers-cursus. Bekijk ook onze gids voor Moltbook.