Enterprise-AI-integratie

De afgelopen jaren heb ik gezien dat veel organisaties met dezelfde onzekerheid rond AI-integratie worstelen. Vrijwel iedereen is het erover eens dat AI een grote transformatie teweegbrengt. Het tijdig opnemen van AI in bedrijfsprocessen wordt inmiddels dan ook als een strategische prioriteit beschouwd.

Vaak ontstaat hetzelfde patroon. Early adopters binnen de organisatie bouwen op eigen initiatief prototypes, presenteren die aan collega’s en moedigen teams aan om ermee te experimenteren. De eerste resultaten kunnen indrukwekkend zijn. Na verloop van tijd worden echter ook latency, onnauwkeurige antwoorden, onvoldoende aansluiting op de bedrijfscontext, ontbrekende toegangscontroles en stijgende tokenkosten zichtbaar. Het prototype groeit niet uit tot een productiesysteem, waarna het project vertraagt of wordt stopgezet.

Het probleem is vaak niet dat het model onvoldoende krachtig is. Het probleem is dat het systeem rond het model nooit is ontworpen.

Wat kan AI een organisatie opleveren?

Generatieve AI kan zoeken, verbanden leggen, samenvatten en content genereren binnen informatievolumes die een individuele gebruiker onmogelijk bij iedere vraag volledig kan doorlezen. Om één relevant antwoord te vinden, zou een medewerker geen duizend pagina’s aan beleid, procedures of technische documentatie hoeven door te nemen. Een goed ontworpen systeem haalt de relevante passages op, baseert het antwoord op die bronnen en toont verifieerbare referenties.

De mogelijkheden zijn niet beperkt tot tekst. Multimodale systemen kunnen tekst, tabellen, afbeeldingen, audio en video binnen dezelfde workflow verwerken. De echte waarde ontstaat echter niet alleen door de capaciteit van het model, maar door die capaciteit te koppelen aan het juiste bedrijfsproces en de juiste beheersmaatregelen.

De eerste use case: toegang tot bedrijfskennis

Documentverwerking en toegang tot interne kennis behoren vaak tot de eerste toepassingen van AI binnen een organisatie. Hier komt Retrieval-Augmented Generation, oftewel RAG, in beeld. Het systeem haalt bronpassages op die relevant zijn voor de vraag van de gebruiker en laat het taalmodel zijn antwoord op deze context baseren.

Voor RAG bestaat geen verantwoord universeel productiviteitspercentage. Het effect verschilt per taak, datakwaliteit, ervaringsniveau van medewerkers en systeemontwerp. Een grootschalig veldonderzoek onder 5.179 klantenservicemedewerkers liet zien dat toegang tot een generatieve AI-assistent het aantal opgeloste vragen per uur gemiddeld met 14 procent verhoogde. Bij minder ervaren medewerkers liep de winst op tot 34 procent.[1] Dit is geen benchmark die rechtstreeks op ieder RAG-project kan worden toegepast. Het onderzoek laat wel zien dat AI, wanneer het in de juiste context wordt ingezet, de toegang tot kennis kan versnellen en expertise breder binnen de organisatie beschikbaar kan maken.

Waarom RAG een rabbit hole kan worden

Chatten met documenten oogt als een eenvoudige demo. Het bouwen van een betrouwbaar enterprise-retrievalsysteem is echter een volwaardig engineeringtraject.

Er zijn tientallen retrievalpatronen mogelijk: dense retrieval, sparse retrieval, hybrid search, metadata filtering, reranking, parent-child retrieval en query expansion zijn slechts enkele voorbeelden. Het juiste ontwerp hangt af van de data, gebruikersvragen, nauwkeurigheidseisen, latencydoelen en het infrastructuurbudget.

Documentverwerking is de eerste kwetsbare laag. Gestructureerde en ongestructureerde content kan niet op dezelfde manier worden geparseerd. Een PDF met uitsluitend tekst verschilt fundamenteel van een document met tabellen, voetnoten, meerdere kolommen, grafieken, gescande afbeeldingen en een complexe leesvolgorde. PDF is een lastiger formaat dan het lijkt. Daarom moeten de inkomende datatypen, parsingstrategie, OCR-behoefte, tabelextractie en chunkingmethode worden beoordeeld voordat de retrievalarchitectuur wordt gekozen.

Docling is een van de tools waarmee PDF’s en andere bedrijfsdocumenten kunnen worden verwerkt, met behoud van bruikbare structuur. De officiële quickstart laat zien hoe een document kan worden geconverteerd en als Markdown kan worden geëxporteerd.[2]

from pathlib import Path
from docling.document_converter import DocumentConverter

source = Path("documents/company_policy.pdf")
converter = DocumentConverter()
result = converter.convert(source)

markdown = result.document.export_to_markdown()
print(markdown[:1500])

Dit voorbeeld is slechts een startpunt. Een productiepipeline heeft daarnaast foutafhandeling, limieten voor bestandsgrootte, OCR-fallback, verwijdering van herhaalde kop- en voetteksten, tabelvalidatie, checksums, versiebeheer en observability nodig.

Ephemeral chat en een permanente bedrijfsindex zijn verschillende systemen

Wanneer de documentpipeline betrouwbaar werkt, kunnen de vectordatabase en de retrieval lifecycle worden ontworpen.

Bij een ephemeral chat kunnen door de gebruiker geüploade bestanden alleen gedurende de actieve sessie worden bewaard. Een in-memory Chroma-collectie kan hiervoor een praktische keuze zijn. Zonder persistence-parameter blijft de collectie beperkt tot de levensduur van het proces.[3]

from langchain_chroma import Chroma
from langchain_huggingface import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)

# No persist_directory: the collection lives only for this session.
vector_store = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    collection_name="session_documents",
)

retriever = vector_store.as_retriever(
    search_type="mmr",
    search_kwargs={"k": 5, "fetch_k": 20},
)

Een permanente kennisbank voor de organisatie brengt andere eisen met zich mee: indexversies, tenant- of afdelingsisolatie, rechten op documentniveau, metadatafilters, verwijder- en updatebeleid, back-ups en auditregistratie. Het onderstaande Qdrant-voorbeeld toont een basisstructuur voor lokale permanente opslag en tenantfiltering tijdens retrieval. Qdrant kan daarnaast in local mode, als self-hosted service of als managed cloud deployment worden gebruikt.[4]

from langchain_huggingface import HuggingFaceEmbeddings
from langchain_qdrant import QdrantVectorStore
from qdrant_client import QdrantClient, models
from qdrant_client.http.models import Distance, VectorParams

embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)
client = QdrantClient(path="./qdrant_data")
collection = "company_knowledge"

if not client.collection_exists(collection):
    client.create_collection(
        collection_name=collection,
        vectors_config=VectorParams(size=384, distance=Distance.COSINE),
    )

vector_store = QdrantVectorStore(
    client=client,
    collection_name=collection,
    embedding=embeddings,
)
vector_store.add_documents(chunks)

# Enforce tenant or department isolation during retrieval.
retriever = vector_store.as_retriever(
    search_kwargs={
        "k": 5,
        "filter": models.Filter(
            must=[
                models.FieldCondition(
                    key="metadata.tenant_id",
                    match=models.MatchValue(value="tenant-42"),
                )
            ]
        ),
    }
)

De code vormt op zichzelf geen beveiligingsgrens. Een client mag niet zelf een willekeurige tenant_id of toegangsfilter kunnen meegeven. Filters moeten worden gegenereerd op basis van de geauthenticeerde identiteit en het autorisatiebeleid aan de serverzijde.

Ontwerp retrieval als een tool

Binnen een enterprise-AI-systeem is het doorgaans beter om retrieval via een gecontroleerde tool beschikbaar te stellen dan het model onbeperkte, directe toegang tot de vectordatabase te geven. De tool bepaalt welke index mag worden doorzocht, hoeveel resultaten worden teruggegeven, welke metadatafilters gelden en hoe bronnen worden weergegeven.

from langchain_core.tools import tool

@tool
def search_company_knowledge(query: str) -> str:
    """Search approved internal sources and return grounded context."""
    documents = retriever.invoke(query)

    if not documents:
        return "No relevant approved source was found."

    passages = []
    for doc in documents[:5]:
        source = doc.metadata.get("source", "unknown")
        page = doc.metadata.get("page", "?")
        passages.append(
            f"[Source: {source}, page: {page}]\n{doc.page_content}"
        )

    return "\n\n".join(passages)

Deze laag maakt retrieval ook meetbaar. Recall@k, precision, answer groundedness, source coverage, latency en kosten per antwoord kunnen afzonderlijk worden gevolgd.

Retrieval verbinden met inference

Nadat retrieval is ingericht, moet de relevante context via een wrapper of AI-service met de inference engine worden verbonden. Deze service doet meer dan alleen een prompt doorsturen. Zij kan verantwoordelijk zijn voor authenticatie, autorisatie, model routing, context assembly, tokenbudgetten, caching, logging, rate limiting, content controls en bronvermelding.

Voor de interfacelaag kan een self-hosted platform zoals OpenWebUI worden gebruikt. OpenWebUI kan verbinding maken met Ollama, vLLM en services die een OpenAI-compatible API aanbieden.[5] Zo kunnen de gebruikerservaring, de enterprise-AI-service en de gekozen inference-infrastructuur onafhankelijk van elkaar worden ontwikkeld.

flowchart TD
    U["Employee"] --> UI["Open WebUI"]
    UI --> S["AI service<br>OpenAI-compatible API"]
    S --> R["Retrieval tool"]
    R --> V[("Vector database")]
    S --> I["Inference engine"]

Conclusie: ontwerp een systeem, geen prototype

Enterprise-AI-integratie wordt niet succesvol door uitsluitend een krachtig model te selecteren. Waarde ontstaat wanneer documenten correct worden verwerkt, retrievalkwaliteit wordt gemeten, toegangsgrenzen worden afgedwongen, inferencekosten worden beheerst en medewerkers een ervaring krijgen waarop zij kunnen vertrouwen.

Een overtuigende demo kan binnen enkele dagen worden gebouwd. Voor een productiesysteem moeten de data-, retrieval-, beveiligings-, inference- en operationele lagen gezamenlijk worden ontworpen.

LMXAI helpt organisaties bij het end-to-end ontwerpen en beoordelen van enterprise-AI-architecturen: van documentpipelines en retrievalkwaliteit tot inference-economie, beveiliging en adoptie.