Zo voeg je webzoekopdrachten en lokaal geheugen toe aan je data-analyse

Kort antwoord

Ja, je kunt je data-analyse uitbreiden met actuele informatie van het internet. Omdat je een derde partij gebruikt via een OpenAI-compatibele base_url, is echter niet gegarandeerd dat het model de ingebouwde webzoekfunctie van OpenAI ondersteunt. OpenAI biedt web search als ingebouwde tool binnen de Responses API, maar compatibele diensten hoeven die functionaliteit niet over te nemen. 5

De meest draagbare oplossing is daarom:

1. laat je Python-programma zoekopdrachten uitvoeren via Tavily;
2. verzamel de titel, URL en samenvatting van de resultaten;
3. stuur die informatie samen met je TXT-data naar het model;
4. laat het model onderscheid maken tussen gemeten data, webbronnen en eigen interpretaties.

Tavily gebruikt een API-key en kan zoekresultaten als gestructureerde gegevens teruggeven. 13

Heeft het model geheugen?

Niet automatisch. Een aanroep van chat.completions.create() onthoudt eerdere verzoeken niet alleen omdat je dezelfde client of hetzelfde model blijft gebruiken. De benodigde context moet je applicatie zelf bewaren en bij een volgende aanvraag opnieuw meesturen. 26

Je kunt dat op twee manieren oplossen:

• Gespreksgeschiedenis bewaren: sla eerdere messages op en stuur ze opnieuw mee.
• Samenvattingen bewaren: sla alleen eerdere analyserapporten op, bijvoorbeeld in analysis_memory.txt.

Voor data-analyse is de tweede optie vaak overzichtelijker. Zet het geheugen wel uit wanneer je met een ander project of een ander type apparaat werkt; oude conclusies kunnen anders de interpretatie van nieuwe data beïnvloeden.

Voorbeeldimplementatie in Python

Installeer eerst de benodigde pakketten:

pip install openai requests

Gebruik vervolgens bijvoorbeeld deze kern van de aanpak:

from pathlib import Path
from datetime import datetime
import json
import os
import time

import requests
from openai import OpenAI

# API-configuratie
API_KEY = os.getenv("AI_API_KEY", "")
BASE_URL = os.getenv("AI_BASE_URL", "")
TAVILY_API_KEY = os.getenv("TAVILY_API_KEY", "")
MODEL_NAME = "deepseek-v4-flash"

TXT_FILE = Path("data.txt")
MEMORY_FILE = Path("analysis_memory.txt")
ENABLE_WEB_SEARCH = True
ENABLE_PERSISTENT_MEMORY = False

client_options = {
    "api_key": API_KEY,
    "timeout": 180.0,
    "max_retries": 0,
}

if BASE_URL:
    client_options["base_url"] = BASE_URL

client = OpenAI(**client_options)


def call_model(system_prompt: str, user_prompt: str) -> str:
    """Roep het OpenAI-compatibele chat-endpoint aan."""
    last_error = None

    for attempt in range(1, 4):
        try:
            response = client.chat.completions.create(
                model=MODEL_NAME,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_prompt},
                ],
                temperature=0.2,
            )

            if not response.choices:
                raise RuntimeError("De API gaf geen choices terug.")

            # Let op: choices is een lijst.
            content = response.choices.message.content

            if not content or not content.strip():
                raise RuntimeError("Het model gaf een leeg antwoord terug.")

            return content.strip()

        except Exception as error:
            last_error = error
            print(f"AI-aanvraag mislukt ({attempt}/3): {error}")

            if attempt < 3:
                time.sleep(5 * attempt)

    raise RuntimeError(f"Maximaal aantal pogingen bereikt: {last_error}")


def search_web(query: str) -> list[dict]:
    """Haal webresultaten op via Tavily."""
    if not TAVILY_API_KEY:
        raise ValueError("TAVILY_API_KEY ontbreekt.")

    response = requests.post(
        "https://api.tavily.com/search",
        headers={
            "Authorization": f"Bearer {TAVILY_API_KEY}",
            "Content-Type": "application/json",
        },
        json={
            "query": query,
            "search_depth": "advanced",
            "max_results": 5,
            "include_answer": False,
            "include_raw_content": False,
            "include_images": False,
        },
        timeout=60,
    )
    response.raise_for_status()
    return response.json().get("results", [])


def format_sources(results: list[dict], max_chars: int = 18000) -> str:
    """Maak compacte broncontext voor het model."""
    parts = []
    total = 0

    for index, result in enumerate(results, start=1):
        text = (
            f"[W{index}]\n"
            f"Titel: {result.get('title', 'Zonder titel')}\n"
            f"URL: {result.get('url', '')}\n"
            f"Samenvatting: {result.get('content', '')[:1200]}\n"
        )

        if parts and total + len(text) > max_chars:
            break

        parts.append(text)
        total += len(text)

    return "\n".join(parts) or "Geen webresultaten beschikbaar."


def load_memory(max_chars: int = 12000) -> str:
    if not ENABLE_PERSISTENT_MEMORY or not MEMORY_FILE.exists():
        return "Geen eerdere analyse beschikbaar."

    text = MEMORY_FILE.read_text(encoding="utf-8")
    return text[-max_chars:]


def save_memory(report: str, max_chars: int = 50000) -> None:
    if not ENABLE_PERSISTENT_MEMORY:
        return

    old_text = ""
    if MEMORY_FILE.exists():
        old_text = MEMORY_FILE.read_text(encoding="utf-8")

    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    record = (
        f"\n\n{'=' * 60}\n"
        f"Analyse: {timestamp}\n"
        f"{'=' * 60}\n"
        f"{report}\n"
    )

    MEMORY_FILE.write_text(
        (old_text + record)[-max_chars:],
        encoding="utf-8",
    )


def analyse_file() -> str:
    data = TXT_FILE.read_text(encoding="utf-8-sig")
    memory = load_memory()

    queries = [
        "MOSFET gate length threshold voltage Idsat Ioff DIBL subthreshold swing",
        "semiconductor device VtSat VtLin IdSat IdLin physical interpretation",
    ]

    results = []
    if ENABLE_WEB_SEARCH:
        for query in queries:
            try:
                results.extend(search_web(query))
            except Exception as error:
                print(f"Zoekopdracht mislukt: {error}")

    web_context = format_sources(results)

    system_prompt = """
Je bent een assistent voor technische data-analyse.
Gebruik alleen de gegevens die werkelijk zijn aangeleverd.
De tekens x en X betekenen ontbrekend, ongeldig of niet berekenbaar en
mogen niet als nul worden geïnterpreteerd.

Gebruik [W1], [W2] enzovoort uitsluitend voor informatie uit de webbronnen.
Maak duidelijk onderscheid tussen datafeiten, broninformatie en gevolgtrekkingen.
Als het bewijs onvoldoende is, schrijf dan expliciet: 'bewijs onvoldoende'.
Antwoord in het Nederlands.
""".strip()

    user_prompt = f"""
Analyseer het onderstaande TXT-bestand.

Bespreek:
1. de structuur en kolommen;
2. trends, minima, maxima en uitschieters;
3. ontbrekende of ongeldige waarden;
4. verbanden en eventuele afwegingen tussen variabelen;
5. een mogelijke technische verklaring met bronverwijzingen;
6. welke grafieken of aanvullende berekeningen nuttig zijn.

================ DATA ================
{data}
============== EINDE DATA =============

================ WEBBRONNEN ================
{web_context}
============== EINDE WEBBRONNEN =============

Eerdere lokale herinneringen zijn alleen achtergrondinformatie. De huidige
TXT-data heeft altijd voorrang:

{memory}
""".strip()

    report = call_model(system_prompt, user_prompt)
    save_memory(report)
    return report


if __name__ == "__main__":
    print(analyse_file())

Belangrijke verbeteringen ten opzichte van de oorspronkelijke code

1. Gebruik de eerste keuze uit het antwoord

In de oorspronkelijke versie staat in feite:

response.choices.message.content

choices is echter een lijst. Gebruik daarom:

response.choices.message.content

Zonder die wijziging kan het verwerken van een geldig modelantwoord mislukken.

2. Stuur bronnen mee, maar behandel ze niet als instructies

Zoekresultaten zijn externe tekst. Zet ze daarom duidelijk in een apart blok, zoals WEB BEGIN en WEB END, en instrueer het model dat deze inhoud geen opdrachten bevat. Laat het model bovendien alleen [W1], [W2] enzovoort gebruiken wanneer een bewering echt op een webbron is gebaseerd.

3. Houd webcontext beperkt

Een zoekdienst kan meerdere resultaten en lange samenvattingen teruggeven. Beperk daarom zowel het aantal resultaten als het totale aantal tekens. Dat voorkomt dat de webcontext de eigenlijke data-analyse verdringt.

4. Gebruik geheugen selectief

De optie:

ENABLE_PERSISTENT_MEMORY = False

staat bewust standaard uit. Zet deze alleen op True wanneer eerdere rapporten relevant zijn voor nieuwe analyses. Het voorbeeld bewaart uitsluitend de uiteindelijke rapporten in analysis_memory.txt, niet automatisch het volledige oorspronkelijke TXT-bestand.

Wat wordt dan precies onthouden?

Met deze implementatie wordt alleen onthouden wat je programma expliciet naar analysis_memory.txt schrijft. Het model heeft dus geen permanent persoonlijk geheugen van alles wat je ooit hebt aangeleverd. Als je een nieuw Python-proces start, kan het alleen informatie gebruiken die je opnieuw meestuurt, bijvoorbeeld vanuit dat bestand.

De veiligste werkwijze is om het geheugen per project of apparaat te scheiden. Bewaar bijvoorbeeld aparte geheugenbestanden voor verschillende datasets en verwijder oude rapporten wanneer ze niet meer relevant zijn.