AI programmeren: Frameworks en implementatie (TensorFlow, PyTorch, LangChain)

Snel antwoord: “Program ai” doe je het meest effectief door één end-to-end pad te bouwen: kies je framework (TensorFlow of PyTorch) voor modellering, kies LangChain voor LLM orkestratie (RAG, tools, agents), verbind alles via een gecontroleerde setup (virtualenv, pinned dependencies, env vars), en schrijf evaluatie plus logging vanaf dag 1.

Daarna pas optimaliseer je. Hieronder krijg je een technische gids met setup guides, minimale codevoorbeelden en best practices, zodat je vandaag nog een werkende AI-app draait.

Wat betekent “program ai” technisch, en welke bouwblokken heb je nodig?

“Program ai” is geen losse tool, het is een ontwerpkeuze voor een pipeline. In de praktijk combineer je drie lagen:

• Model laag, waar je tensormodellen trainde of inferentie draait. Dat is meestal TensorFlow of PyTorch.
• LLM orkestratie laag, waar je prompts, retrieval, tools en eventueel agents samenstelt. Dat is waar LangChain vaak in beeld komt.
• Applicatie laag, waar je API’s, endpoints, input validatie, logging, caching, en evaluatie neerzet.

Als je doel een LLM-app is (zoals RAG, chat met documenten, tool-using workflows), dan is “program ai” vaak: LangChain plus je gekozen model provider of embedding model, en alleen TensorFlow/PyTorch als je zelf modellen traint of speciale inferentie runt.

Setup die niet faalt: Python project, virtualenv, pinned packages

Deze stap bepaalt 80 procent van je tijdswinst. Gebruik altijd een nieuwe omgeving per project.

1) Maak een Python omgeving

1. Python omgeving aanmaken:

Linux/macOS

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip

Windows (PowerShell)

py -m venv .venv
.venvScriptsActivate.ps1
python -m pip install --upgrade pip

2) Installeer de minimale dependencies per use case

Voor “program ai” met LangChain heb je doorgaans minimaal LangChain en een provider integratiepakket nodig. In veel setups werkt dit als basis: langchain, plus provider integraties.

LangChain installation verwijst naar pip install langchain als basis installatie. (langchain-doc.readthedocs.io)

pip install langchain

TensorFlow en PyTorch zijn groot, dus installeer pas wat je nodig hebt. De officiële TensorFlow install pagina geeft expliciet install varianten en afhankelijkheden. (tensorflow.org)

De officiële TensorFlow install guide is gericht op de juiste pip eisen en platform varianten. (tensorflow.org)

3) Pinned model providers en env vars

API keys moeten buiten je code. OpenAI raadt aan om keys te laden vanuit een omgevingsvariabele of key management service. (platform.openai.com)

Minimale best practice:

# Linux/macOS
export OPENAI_API_KEY="<je_key>"

# In je code lees je de variabele, niet de key in broncode.

TensorFlow vs PyTorch voor “program ai”: wanneer welke kiezen?

Kort beslissen, dan bouwen.

Wanneer TensorFlow

• Je werkt binnen een TensorFlow ecosysteem (SavedModel, TFX, TF Serving).
• Je volgt bestaande training pipelines die al op TensorFlow draaien.
• Je wil snellere start met high-level training loops binnen TF.

Wanneer PyTorch

• Je wil research snelheid en flexibele debugging.
• Je stack is PyTorch-first (community, tooling, model code die je hergebruikt).
• Je verwacht custom training loops en wil directe controle.

Install quick start (conceptueel, check altijd platform docs)

TensorFlow biedt officiële install pages met CPU en platform specifieke instructies. (tensorflow.org)

Gebruik bij pip install TensorFlow de official pip install gids voor je gewenste variant. (tensorflow.org)

Voor PyTorch liggen de exacte install commando’s op hun officiële pagina’s afhankelijk van CUDA en platform. In de docs staat dat de PyTorch homepage de meest autoritatieve installatie-instructies bevat. (docs.pytorch.org)

Praktisch advies: kies CPU eerst voor je ontwikkelt. Pas daarna GPU optimalisaties toevoegen, anders maak je debugging onnodig moeilijk.

LangChain als “AI programmeren” laag: RAG in code, minimaal maar correct

Als je LLM-apps bouwt, is RAG meestal de snelste waarde. LangChain helpt je retrieval, chunking en prompt chaining te structureren.

RAG voorbeeld, conceptueel recept

Een RAG-app heeft dezelfde stappen:

1. Documenten laden.
2. Tekst chunking.
3. Embeddings genereren.
4. Vector store opbouwen.
5. User query embedded en retrieved context meegeven aan LLM.

Minimale code skeleton (Python)

Dit is een compacte skeleton. De exacte provider classes verschillen per pakket, maar de structuur blijft hetzelfde: load, split, embed, retrieve, prompt, generate.

from langchain.text_splitter import RecursiveCharacterTextSplitter

# Pseudocode structuur, vul provider en vector store in die bij je stack passen

def build_retriever(docs):
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=150,
    )
    splits = splitter.split_text("n".join(docs))

    # embeddings = ...
    # vectorstore = ...
    # return vectorstore.as_retriever(k=4)
    return splits


def answer(query, retriever_splits):
    # retrieved_context = ...
    # prompt = f"Context: {retrieved_context}nVraag: {query}"
    # return llm.invoke(prompt).content
    return f"Antwoord (stub) op: {query}"

if __name__ == "__main__":
    docs = ["Doc 1 tekst...", "Doc 2 tekst..."]
    retriever_splits = build_retriever(docs)
    print(answer("Wat staat er in doc 1?", retriever_splits))

De belangrijkste tip voor productie is: maak retrieval voorspelbaar. Pin embedding model, pin chunking parameters, en log retrieved passages per request, zodat je fouten kunt reproduceren.

Best practice: controleer import paden en versies

LangChain is snel evoluerend; import paths en pakketten kunnen verschuiven. De officiële LangChain installatiepagina geeft in elk geval de basis install instructie. (langchain-doc.readthedocs.io)

Gebruik daarom altijd een clean env en log je installed versions in CI.

pip freeze | sed -n '1,120p'

AI programmeren met tools en agents: waar het misgaat, en hoe je het oplost

Agents en tool calling zijn waar veel teams tijd verliezen. Niet omdat het onmogelijk is, maar omdat het gedrag moeilijk te testen is.

Ontwerpregel 1: beperk tool surface

• Expose alleen tools die idempotent zijn of goed te rollbacken.
• Geef tools een strak schema voor input, valideer server-side.
• Beperk uitvoer: max tokens, max items, max tijd.

Ontwerpregel 2: maak “planner” en “executor” scheidbaar

In plaats van alles in één prompt te stoppen, laat je:

• een stap een plan of tool call voorstel doen
• een tweede stap de tool calls uitvoeren met checks

Dat is niet alleen betrouwbaarder, het maakt evaluatie eenvoudiger.

Ontwerpregel 3: altijd evals en tracing

Minimaal:

• log prompt input, retrieved context, tool calls, output
• meet “antwoord juistheid” met een rubric (of exact match waar mogelijk)
• bewaar testcases die regressies veroorzaakten

TensorFlow of PyTorch integreren in een LangChain-app: twee routes

Er zijn twee realistische manieren om TF/PyTorch te gebruiken in een LangChain app.

Route A: alleen inference, model achter een API

Train je model in TF of PyTorch, deploy als service, en laat LangChain via HTTP of SDK calls doen.

• Pro: LangChain blijft de orchestratie laag, model blijft model.
• Con: latency en deployment overhead.

Route B: embeddings lokaal met TF/PyTorch

Als je embeddings lokaal compute, kun je vectorisatie volledig onder controle houden. Dan draait LangChain alleen retrieval en prompt composition.

• Pro: minder externe afhankelijkheden.
• Con: je moet embedding caching en batching regelen.

Voor embeddings moet je vooral consistentie bewaken: dezelfde preprocessing, hetzelfde model, zelfde chunking over tijd.

Setup guides die je meteen kunt toepassen

Hier zijn drie concrete setup routes die je binnen 30 tot 60 minuten werkend kunt krijgen.

Setup 1, RAG met LangChain en env vars

Doel: een app die een vraag stelt en context uit documenten haalt.

1. Maak env: python -m venv .venv.
2. Installeer LangChain: pip install langchain. (langchain-doc.readthedocs.io)
3. Zet API key via env var, niet in code. (platform.openai.com)
4. Implementeer chunking en retrieval, log retrieved passages per query.

Setup 2, TensorFlow training notebook naar “service”

Doel: een TF model dat je kunt aanroepen.

1. Installeer TensorFlow via de official install pagina voor je OS en gewenste variant. (tensorflow.org)
2. Train en exporteer als SavedModel.
3. Start een inference endpoint (TF Serving of eigen wrapper).
4. LangChain doet alleen retrieval en call naar je endpoint.

Setup 3, PyTorch model met lokale inferentie

Doel: snelle iteratie met PyTorch inference.

1. Volg de PyTorch officiële installatie-instructies via hun homepage, afhankelijk van je platform en CUDA. (docs.pytorch.org)
2. Implementeer batched inference.
3. Cache outputs per input waar zinvol.
4. Expose embeddings of predictions als functies die LangChain kan aanroepen (via eigen interface).

Best practices voor “program ai” die je regressies voorkomen

• Pin alles: Python versie, pip packages, model ids, embedding model, chunking parameters.
• Beperk nondeterminisme: seed waar mogelijk, en registreer sampling parameters.
• Maak retrieval auditbaar: bewaar retrieved passages, scores, en top-k selectie.
• Eval vóór optimalisatie: definieer een set vragen, verwachte output, en run regressietests bij elke wijziging.
• Observability: log input size, latency per stap (retrieval, LLM call, postprocessing).
• Security: API keys in env vars, nooit in repo. (platform.openai.com)
• Fail hard: als retrieval leeg is of tool calls falen, return een gecontroleerde fout of fallback.

Praktische vervolgvragen (interne links)

Als je “program ai” verder wil trekken naar automation, is het nuttig om dezelfde principes te gebruiken op workflow niveaus. Zie ook: AI-automatisering: Implementatie en ROI.

En als je termen helder wil maken voor je team, begin met de basisdefinitie: AI: Definitie, toepassingen en praktijkvoorbeelden.

Conclusie: bouw een end-to-end pad, niet een losse demo

Als je “program ai” serieus neemt, ga dan zo te werk:

1. Kies wat je bouwt, model training (TensorFlow of PyTorch) of LLM app orkestratie (LangChain).
2. Start met een harde setup (venv, pinned dependencies, env vars, auditeerbare retrieval).
3. Werk van skeleton naar werkend systeem met logging en evaluatie vanaf dag 1.
4. Pas daarna optimaliseer je performance en complexiteit.

Als je wil, geef je doel door (bijvoorbeeld: “RAG op interne docs”, “tool-using agent voor support”, of “train een classificatiemodel”) en je runtime constraints (CPU-only, GPU, latentie). Dan kan ik je een concrete projectstructuur en minimaal werkend scaffold geven voor jouw stack.