Slik kobler du dataanalysen til nettsøk – og gir modellen lokal hukommelse

Ja, dette kan bygges inn. Men det er viktig å skille mellom nettsøk og hukommelse.

Nettsøk: søk først, analyser etterpå

Du bruker et tredjeparts OpenAI-kompatibelt endepunkt og modellen deepseek-v4-flash. Da kan du ikke gå ut fra at modellen støtter OpenAIs innebygde nettsøk direkte. OpenAIs nettverktøy tilbys gjennom Responses API, mens et annet base_url ikke nødvendigvis støtter samme funksjon.5

Den mest kompatible løsningen er derfor:

1. Les inn TXT-filen.
2. Lag relevante søkeord.
3. Søk på nettet via Tavily.
4. Send både TXT-dataene og søkeresultatene til modellen.
5. Be modellen skille tydelig mellom observasjoner i datasettet, informasjon fra nettet og egne tolkninger.

Tavily bruker API-nøkler og returnerer strukturerte søkeresultater som kan brukes videre i programmet.13

Konfigurer API-nøklene

Det tryggeste er å lagre nøklene som miljøvariabler:

$env:AI_API_KEY="din AI-nøkkel"
$env:AI_BASE_URL="https://ditt-endepunkt/v1"
$env:TAVILY_API_KEY="din Tavily-nøkkel"

I Python kan de leses slik:

import os

API_KEY = os.getenv("AI_API_KEY", "")
BASE_URL = os.getenv("AI_BASE_URL", "")
TAVILY_API_KEY = os.getenv("TAVILY_API_KEY", "")

Tavily-søket kan for eksempel gjøres slik:

import requests

TAVILY_SEARCH_URL = "https://api.tavily.com/search"

def search_tavily(query):
    headers = {
        "Authorization": f"Bearer {TAVILY_API_KEY}",
        "Content-Type": "application/json",
    }

    payload = {
        "query": query,
        "search_depth": "advanced",
        "max_results": 5,
        "include_answer": False,
        "include_raw_content": False,
        "include_images": False,
    }

    response = requests.post(
        TAVILY_SEARCH_URL,
        headers=headers,
        json=payload,
        timeout=60,
    )
    response.raise_for_status()
    return response.json().get("results", [])

Resultatene bør deretter formateres før de sendes til modellen. Ta med tittel, URL og sammendrag, og gi hver kilde et nummer:

[W1]
Tittel: ...
URL: ...
Sammendrag: ...

[W2]
Tittel: ...
URL: ...
Sammendrag: ...

I instruksjonen til modellen bør du kreve at nettbaserte påstander merkes med [W1], [W2] og så videre. Samtidig må modellen få beskjed om at nettsammendrag ikke kan overstyre tallene i TXT-filen.

Viktig feil i modellkallet

I koden din står denne linjen:

content = response.choices.message.content

For OpenAI-kompatible Chat Completions-svar må du normalt hente det første valget fra listen:

content = response.choices.message.content

Uten `` kan programmet feile fordi choices er en liste.

Har modellen hukommelse?

Nei, ikke automatisk i oppsettet du bruker. Når du kaller chat.completions.create(), må tidligere samtaleinnhold eller analyser sendes inn på nytt av programmet. Det at du bruker samme klient eller samme modell, betyr ikke at modellen dermed husker tidligere forespørsler.26

Det finnes derfor tre ulike ting som ofte blandes sammen:

• Samtalekontekst: Meldinger du sender med i den aktuelle forespørselen.
• Lokal hukommelse: Tekst eller JSON som programmet lagrer på disk og leser inn senere.
• Modelltrening: At data brukes til å endre selve modellen. Det skjer ikke bare fordi du sender data i en API-forespørsel.

Enkel lokal hukommelse

Du kan lagre den ferdige rapporten i en fil og lese den inn neste gang:

from pathlib import Path

MEMORY_FILE = Path("analysis_memory.txt")
ENABLE_PERSISTENT_MEMORY = False
MEMORY_INPUT_MAX_CHARS = 12000


def load_memory():
    if not ENABLE_PERSISTENT_MEMORY or not MEMORY_FILE.exists():
        return ""

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


def save_memory(final_report):
    if not ENABLE_PERSISTENT_MEMORY:
        return

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

    new_memory = old_memory + "\n\n" + final_report
    MEMORY_FILE.write_text(
        new_memory[-50000:],
        encoding="utf-8",
    )

Når rapporten skal analyseres, kan du legge minnet inn i brukerprompten:

memory_text = load_memory()

user_prompt = f"""
Analyser de aktuelle dataene nedenfor.

Tidligere lokal hukommelse er bare bakgrunnsinformasjon.
Den kan være fra et annet prosjekt og må ikke overstyre dagens data.

--- Aktuelle data ---
{chunk}

--- Tidligere hukommelse ---
{memory_text or 'Ingen tidligere hukommelse.'}
"""

Etter at den endelige rapporten er laget, kaller du:

save_memory(final_report)

Når bør hukommelsen være avslått?

I koden er ENABLE_PERSISTENT_MEMORY = False et fornuftig standardvalg. Slå funksjonen på bare når rapportene gjelder samme prosjekt eller samme komponent. Hvis du analyserer et nytt datasett med andre forutsetninger, kan gamle konklusjoner påvirke modellen og gi et misvisende resultat.

Lokal lagring har også en praktisk personvernside: analysis_memory.txt kan inneholde konfidensielle målinger, prosjektnavn eller interne konklusjoner. Begrens derfor hva som lagres, og vurder å lagre strukturerte sammendrag i stedet for hele rapporter.

Anbefalt arbeidsflyt

Den samlede løsningen bør derfor følge denne rekkefølgen:

1. Les TXT-filen med riktig tegnkoding.
2. Del store filer opp i blokker.
3. Generer tekniske søkeord uten å sende unødvendige eller sensitive rådata.
4. Hent kilder fra Tavily.
5. Send data, kilder og eventuelt lokalt minne til modellen.
6. Lagre mellomrapporter underveis.
7. Lag en sluttrapport med kildehenvisninger.
8. Lagre sluttrapporten lokalt bare hvis vedvarende hukommelse er aktivert.

På denne måten får du en modell som kan bruke oppdatert nettinformasjon i analysen, uten å være avhengig av at tredjepartsmodellen støtter innebygde nettverktøy. Samtidig blir det tydelig at «hukommelsen» ikke ligger i modellen av seg selv – den ligger i koden og filene du velger å sende inn igjen.