Cara Menambah Carian Web pada Analisis AI — dan Adakah Model Ini Mempunyai Memori?

Jika model digunakan melalui antara muka OpenAI yang serasi tetapi menggunakan base_url pihak ketiga, sokongan terhadap alat carian web tidak boleh dianggap tersedia secara automatik. Carian web terbina dalam OpenAI disediakan melalui Responses API, manakala pelayan pihak ketiga mungkin tidak menyokong fungsi tersebut.5

Penyelesaian yang lebih serasi untuk skrip Python anda ialah menggunakan Tavily sebagai lapisan carian luaran. Program akan mencari maklumat di internet menggunakan API Tavily, menyusun hasilnya, kemudian menghantar ringkasan sumber itu bersama data TXT kepada model. Tavily menerima API key dan mengembalikan hasil carian berstruktur.13

Adakah model akan mengingati perkara yang pernah diberikan?

Tidak secara automatik. Penggunaan objek client yang sama atau model yang sama tidak bermaksud model menyimpan semua permintaan terdahulu. Dalam aliran chat.completions.create(), konteks perbualan perlu disimpan oleh aplikasi dan dihantar semula dalam permintaan seterusnya.26

Dengan kata lain, “memori” perlu dibina di peringkat program. Untuk skrip anda, pendekatan mudah ialah:

1. Baca analysis_memory.txt apabila program bermula.
2. Masukkan laporan lama sebagai konteks tambahan kepada model.
3. Selepas analisis selesai, tambah laporan baharu ke dalam fail tersebut.

Namun, laporan lama hanyalah rujukan. Jika ia bercanggah dengan data TXT semasa, data semasa mesti diutamakan.

Tetapan utama yang perlu ditambah

Gunakan pemboleh ubah persekitaran untuk menyimpan kunci API:

import os
from pathlib import Path

AI_API_KEY = os.getenv("AI_API_KEY", "")
AI_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

Jika menggunakan Windows PowerShell, pemboleh ubah tersebut boleh ditetapkan seperti berikut:

$env:AI_API_KEY="kunci-model-anda"
$env:AI_BASE_URL="https://alamat-api-anda/v1"
$env:TAVILY_API_KEY="kunci-tavily-anda"

Pasang pakej yang diperlukan terlebih dahulu:

pip install openai requests

Fungsi carian Tavily

Fungsi berikut menghantar kata kunci ke Tavily dan mengambil hasil carian berstruktur:

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", [])

Hasil carian wajar disimpan bersama tajuk, URL dan ringkasan. Kemudian, berikan setiap sumber nombor seperti [W1], [W2] dan seterusnya. Dengan cara ini, model boleh membezakan fakta daripada data TXT dan penjelasan umum yang datang daripada internet.

def format_web_context(results, max_chars=18000):
    parts = []
    total_chars = 0

    for index, result in enumerate(results, start=1):
        title = str(result.get("title", "Tiada tajuk")).strip()
        url = str(result.get("url", "")).strip()
        content = str(result.get("content", "")).strip()[:1200]

        block = (
            f"[W{index}]\n"
            f"Tajuk: {title}\n"
            f"URL: {url}\n"
            f"Ringkasan: {content}\n"
        )

        if parts and total_chars + len(block) > max_chars:
            break

        parts.append(block)
        total_chars += len(block)

    return "\n".join(parts) or "Tiada hasil carian web tersedia."

Hantar data TXT dan hasil carian kepada model

Selepas membaca fail TXT, gabungkan data itu dengan konteks web dalam user_prompt:

from openai import OpenAI

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

if AI_BASE_URL:
    client_options["base_url"] = AI_BASE_URL

client = OpenAI(**client_options)

web_results = []

if ENABLE_WEB_SEARCH:
    queries = [
        "MOSFET gate length threshold voltage Idsat Ioff DIBL",
        "subthreshold swing short channel effects physical interpretation",
    ]

    for query in queries:
        try:
            web_results.extend(search_tavily(query))
        except Exception as error:
            print(f"Carian gagal untuk {query}: {error}")

web_context = format_web_context(web_results)

prompt = f"""
Analisis data TXT di bawah.

Keperluan:
- Anggap x atau X sebagai data hilang atau tidak sah, bukan angka sifar.
- Jangan reka nilai yang tiada dalam data.
- Bezakan fakta daripada data, maklumat web dan kesimpulan anda.
- Jika menggunakan maklumat daripada konteks web, sertakan [W1], [W2] dan sebagainya.
- Jika bukti tidak mencukupi, nyatakan dengan jelas bahawa bukti tidak mencukupi.

================ DATA TXT ================
{txt_data}
================ KONTEKS WEB ============
{web_context}
"""

response = client.chat.completions.create(
    model=MODEL_NAME,
    messages=[
        {
            "role": "system",
            "content": "Anda ialah pembantu analisis data semikonduktor yang teliti.",
        },
        {
            "role": "user",
            "content": prompt,
        },
    ],
    temperature=0.2,
)

report = response.choices.message.content

Perhatikan pembetulan penting pada baris terakhir: gunakan response.choices.message.content, bukan response.choices.message.content. choices ialah senarai, jadi elemen pertama perlu diambil dahulu.

Simpan dan baca memori tempatan

Memori boleh diaktifkan dengan menetapkan:

ENABLE_PERSISTENT_MEMORY = True

Contoh fungsi bacaan dan penyimpanan:

from datetime import datetime


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

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


def save_memory(report, max_chars=50000):
    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{'=' * 60}\n"
        f"Masa analisis: {timestamp}\n"
        f"{'=' * 60}\n"
        f"{report}\n"
    )

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

Sebelum memanggil model, masukkan hasil load_memory() ke dalam prompt. Tambahkan arahan bahawa memori lama tidak boleh menggantikan data semasa:

memory_text = load_memory()

memory_context = memory_text or "Tiada memori terdahulu."

prompt = f"""
Memori terdahulu di bawah hanyalah konteks tambahan.
Jangan anggap nilainya berasal daripada fail TXT semasa.
Jika terdapat percanggahan, utamakan data semasa.

================ MEMORI ================
{memory_context}
================ DATA SEMASA ===========
{txt_data}
"""

Selepas laporan akhir berjaya dihasilkan, panggil:

save_memory(report)

Bila memori patut dimatikan?

Jika anda menganalisis data daripada projek, wafer atau peranti yang berbeza, lebih selamat menetapkan ENABLE_PERSISTENT_MEMORY = False. Jika tidak, kesimpulan daripada analisis lama mungkin mempengaruhi tafsiran data baharu.

Selain itu, contoh ini hanya menyimpan laporan akhir, bukannya keseluruhan data asal. Had aksara juga perlu ditetapkan supaya fail memori tidak berkembang tanpa kawalan.

Ringkasnya

Struktur yang disyorkan ialah:

Fail TXT
   ↓
Pecahkan data kepada beberapa bahagian
   ↓
Cari topik teknikal melalui Tavily
   ↓
Hantar data + sumber web kepada model
   ↓
Gabungkan laporan setiap bahagian
   ↓
Simpan laporan akhir sebagai memori pilihan

Pendekatan ini tidak menjadikan model mempunyai memori terbina dalam. Sebaliknya, aplikasi anda mengurus konteks, sejarah dan sumber secara jelas—lebih mudah diaudit serta lebih selamat untuk analisis teknikal.