Så får du AI-modellen att söka på webben – och komma ihåg tidigare analyser

Det går att lägga till webbsökning i ditt program, men det är viktigt att skilja på modellens inbyggda verktyg och en extern söktjänst.

Du använder en OpenAI-kompatibel klient med en egen base_url och modellen deepseek-v4-flash. Därför går det inte att utgå från att just den leverantören stöder OpenAI:s inbyggda webbsökningsverktyg. OpenAI:s officiella webbsökning erbjuds via Responses API, medan en tredjepartsserver inte nödvändigtvis stöder samma funktioner. 5

Den mest portabla lösningen är därför:

1. Läs in TXT-filen.
2. Skapa tekniska sökfrågor.
3. Sök med Tavily.
4. Skicka TXT-data och sökresultat till modellen.
5. Spara den färdiga rapporten lokalt om du vill återanvända den senare.

Så fungerar webbsökningen

Tavily använder en API-nyckel och returnerar strukturerade sökresultat, bland annat titel, URL och sammanfattning. 13

Lägg först till nödvändiga inställningar i programmet:

import os
import requests

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

TAVILY_SEARCH_URL = "https://api.tavily.com/search"
SEARCH_RESULTS_PER_QUERY = 5
SEARCH_DEPTH = "advanced"

Du kan sätta nycklarna i Windows PowerShell så här:

$env:AI_API_KEY="din AI-nyckel"
$env:AI_BASE_URL="din Base URL"
$env:TAVILY_API_KEY="din Tavily-nyckel"

Undvik helst att skriva API-nycklar direkt i källkoden, särskilt om projektet ska delas eller läggas på GitHub.

Funktion för att söka med Tavily

Använd en separat funktion för sökningen. Då blir det enklare att hantera timeout, fel och flera sökfrågor:

def search_tavily(query):
    if not TAVILY_API_KEY:
        raise ValueError("TAVILY_API_KEY saknas")

    headers = {
        "Authorization": f"Bearer {TAVILY_API_KEY}",
        "Content-Type": "application/json",
    }

    payload = {
        "query": query,
        "search_depth": SEARCH_DEPTH,
        "max_results": SEARCH_RESULTS_PER_QUERY,
        "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", [])

Resultaten kan sedan formateras så att modellen får tydliga käll-ID:n:

def format_web_context(results):
    parts = []

    for index, result in enumerate(results, start=1):
        parts.append(
            f"[W{index}]\n"
            f"Titel: {result.get('title', 'Utan titel')}\n"
            f"URL: {result.get('url', '')}\n"
            f"Sammanfattning: {result.get('content', '')}\n"
        )

    return "\n".join(parts)

När modellen får sökresultaten bör instruktionen vara tydlig: aktuella sökresultat får användas för att förklara generella samband, men får inte ersätta fakta i den aktuella TXT-filen.

Exempel på en sådan instruktion:

ANALYSIS_REQUIREMENT = """
Analysera TXT-datan och skilj tydligt mellan:
1. Fakta som direkt kan utläsas ur datan.
2. Information från webbkällor.
3. Egna analytiska slutsatser.

Tecknet x eller X betyder saknat, ogiltigt eller ej beräkningsbart värde.
Det får aldrig behandlas som siffran 0.

Om information från webben används ska källan anges som [W1], [W2] och så vidare.
Om underlaget inte räcker ska du skriva: Evidensen är otillräcklig.
""".strip()

I anropet till modellen kombinerar du sedan analyskravet, TXT-blocket och webbkonteksten:

user_prompt = f"""
{ANALYSIS_REQUIREMENT}

================ DATA BEGIN ================
{txt_chunk}
================= DATA END =================

================ WEB BEGIN =================
{web_context}
================= WEB END ==================
"""

Har modellen ett minne?

Nej – inte i den betydelsen att den automatiskt minns alla tidigare körningar.

När du använder chat.completions.create() behöver programmet själv skicka med den kontext som ska finnas kvar vid nästa anrop. Det räcker alltså inte att återanvända samma client eller samma modellnamn. 26

Det innebär att tidigare information bara finns kvar om du till exempel:

• sparar den i en fil eller databas,
• skickar med den i nästa prompt,
• använder ett särskilt konversations- eller trådssystem,
• eller bygger en separat lösning med sökbar dokumentlagring.

Enkel lokal minnesfunktion

I ditt upplägg kan du spara den färdiga rapporten i analysis_memory.txt:

from pathlib import Path
from datetime import datetime

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

Läs in minnet när programmet startar:

def load_memory():
    if not ENABLE_PERSISTENT_MEMORY:
        return ""

    if not MEMORY_FILE.exists():
        return ""

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

Efter att slutrapporten har skapats kan den sparas så här:

def save_memory(final_report, data_file_name):
    if not ENABLE_PERSISTENT_MEMORY:
        return

    old_memory = ""

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

    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    new_record = (
        f"\n\n{'=' * 72}\n"
        f"Analystid: {timestamp}\n"
        f"Datafil: {data_file_name}\n"
        f"{'=' * 72}\n"
        f"{final_report}\n"
    )

    memory = (old_memory + new_record)[-MEMORY_FILE_MAX_CHARS:]
    MEMORY_FILE.write_text(memory, encoding="utf-8")

Skicka sedan med minnet som bakgrund i prompten:

memory_text = load_memory()

memory_context = f"""
Tidigare lokala analysrapporter finns nedan.
De får endast användas som bakgrund. Aktuell TXT-data har alltid företräde.

================ MEMORY BEGIN ================
{memory_text or 'Inget tidigare minne finns.'}
================= MEMORY END =================
"""

Slå på funktionen med:

ENABLE_PERSISTENT_MEMORY = True

Viktigt: blanda inte ihop olika projekt

Ett enda minne i analysis_memory.txt kan bli problematiskt om du analyserar flera olika komponenter eller projekt. En gammal rapport kan då påverka den nya analysen trots att datan gäller något annat.

För separata projekt är det säkrare att använda olika minnesfiler, exempelvis:

MEMORY_FILE = Path("memory_mosfet_project_a.txt")

eller att spara minnet i en databas med projekt-ID, enhetsnamn och datum.

En liten korrigering i din kod

I funktionen som läser modellens svar bör du kontrollera det första valet i listan choices. Använd:

content = response.choices.message.content

inte:

content = response.choices.message.content

Annars riskerar programmet att få ett fel när API-svaret ska läsas.

Slutsats

Din idé fungerar bra med en extern sökmodul:

• Tavily hämtar aktuell information från webben.
• TXT-filen innehåller den data som ska analyseras.
• AI-modellen tolkar datan och kopplar den till sökresultaten.
• En lokal minnesfil gör att tidigare rapporter kan skickas med vid nästa körning.

Kom ihåg att lokalt minne inte är samma sak som att modellen själv har lärt sig något permanent. Det är ditt program som sparar texten och väljer att skicka tillbaka den senare. För känsliga eller långsiktiga projekt bör du dessutom begränsa minnet, skilja olika projekt åt och kontrollera webbkällorna innan du låter dem påverka slutsatserna.