Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

File Search vs. Custom RAG: wanneer gebruikt u wat?

Les 16 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. File Search: OpenAI’s beheerde RAG
  3. Wat File Search u biedt, en wat het u ontneemt
  4. Beslissingsmatrix
  5. Hybride architectuur: het beste van twee werelden
  6. Belangrijkste punten

Doelstellingen

  • Inzicht krijgen in OpenAI’s beheerde RAG (File Search)
  • File Search vergelijken met een custom RAG-pipeline
  • De juiste aanpak kiezen voor uw use case

File Search: OpenAI’s beheerde RAG

U heeft zojuist laag voor laag een volledige RAG-pipeline gebouwd. File Search doet dit allemaal voor u. Het is een tool die is ingebouwd in de OpenAI Responses API en die automatisch zorgt voor chunking, embedding, vectoropslag en zoekopdrachten: u uploadt uw bestanden en stelt vervolgens uw vragen. Deze les is geen afwijzing van wat eraan voorafging, maar een eerlijke vraag die u zich moet stellen voordat u ook maar één regel code schrijft: wat is het juiste abstractieniveau voor uw project?

Alles begint met een vector store, de container die uw geïndexeerde documenten huisvest. U maakt deze aan, uploadt bestanden één voor één en wacht tot het indexeren voltooid is voordat u query’s uitvoert. Deze wachttijd is niet louter cosmetisch: indexeren gebeurt asynchroon, en een query die te vroeg wordt gestart, ziet slechts een deel van de corpus.

from openai import OpenAI

client = OpenAI()

# 1. Create a vector store
vector_store = client.vector_stores.create(
    name="product-documentation"
)
print(f"Vector store created: {vector_store.id}")

# 2. Upload files
files = ["user_guide.pdf", "faq.md", "changelog.txt"]

for file in files:
    with open(file, "rb") as f:
        file_obj = client.files.create(file=f, purpose="assistants")
        client.vector_stores.files.create(
            vector_store_id=vector_store.id,
            file_id=file_obj.id
        )
        print(f"  Uploaded: {file}")

# Wait for indexing to complete
import time
while True:
    vs = client.vector_stores.retrieve(vector_store.id)
    if vs.file_counts.completed == vs.file_counts.total:
        break
    time.sleep(2)
print("Indexing complete")

Query’s uitvoeren vereist vervolgens slechts één aanroep: u declareert de file_search-tool met de store-ID, en het model beslist wanneer het informatie moet ophalen. Het interessante deel is het lezen van de annotaties, die de bestandsverwijzingen bevatten. Hiermee kunt u bronnen aan de gebruiker tonen—gedrag dat u in de custom pipeline handmatig moest implementeren.

# Query with File Search
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What are the new features in v3.2?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [vector_store.id]
    }]
)

print(response.output_text)

# Access cited sources
for annotation in response.output:
    if hasattr(annotation, "annotations"):
        for ann in annotation.annotations:
            if ann.type == "file_citation":
                print(f"  Source: file {ann.file_citation.file_id}")

Twee instellingen laten u het gedrag fijnafstemmen zonder de beheerde tool te verlaten. max_num_results stelt het aantal opgehaalde chunks in, en score_threshold filtert resultaten met een lage score eruit, precies zoals de relevantiedrempel die u na het reranken toepaste.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I configure SSO?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [vector_store.id],
        "max_num_results": 10,         # Number of chunks to retrieve
        "ranking_options": {
            "ranker": "auto",           # Automatic ranker
            "score_threshold": 0.3      # Relevance threshold
        }
    }]
)

Wat File Search u biedt, en wat het u ontneemt

Het doorslaggevende argument voor File Search is de volledige afwezigheid van infrastructuur: geen vectordatabase om te provisioneren, back-uppen of monitoren. Chunking wordt voor u gedaan en geoptimaliseerd door OpenAI, het updaten van de corpus is even eenvoudig als het toevoegen of verwijderen van een bestand, citaten worden automatisch gegenereerd en veelvoorkomende formaten worden native ondersteund—PDF, DOCX, MD, TXT, HTML, JSON, onder andere. Een team zonder infrastructuur-expertise kan zo in één middag een kennisbank online zetten.

De keerzijde van dit gemak is het verlies van controle over elke schakel in de keten. U kiest niet de chunk-grootte, dus de afweging tussen precisie en context uit Les 12 ligt buiten uw handen. Zoeken is puur semantisch: geen hybride zoeken, waardoor productreferenties en exacte foutcodes kwetsbaar blijven. Ook kunt u geen Cohere of een zelfgebouwde cross-encoder koppelen voor reranking. Voeg hier drie strategische overwegingen aan toe: vectoropslag wordt extra gefactureerd naast API-oproepen, uw data resideert op servers van OpenAI, en indexering dekt alleen tekst.

Een custom pipeline draait deze lijst term voor term om. U beheerst chunking, embedding, zoeken, reranking en prompting; u combineert semantisch en lexicaal zoeken; u mixt modelproviders, of houdt alles on-premise als uw data dat vereist; en bovenal optimaliseert u elke component onafhankelijk door het effect ervan te meten. Deze controle gaat ten koste van code die geschreven en onderhouden moet worden, een vectordatabase die beheerd moet worden, en expertise—chunking, evaluatie en reranking improviseren werkt niet, en dat is precies wat deze cursus behandelt.

Beslissingsmatrix

CriteriumFile SearchCustom RAG
Snel prototypen✅ Ideaal⚠️ Langzamer
Controle over chunking❌✅
Hybride zoeken❌✅
Gevoelige data⚠️ Bij OpenAI✅ On-premise
Kosten op schaal⚠️ Kan hoog zijn✅ Voorspelbaar
Onderhoud✅ Nul⚠️ Te beheren
Maximale prestatie⚠️ Goed✅ Optimaliseerbaar

Hybride architectuur: het beste van twee werelden

De keuze hoeft niet definitief te zijn, en dat moet hij ook niet zijn. De meest kosteneffectieve aanpak is om te beginnen met File Search om te valideren of uw use case houdbaar is, en vervolgens over te stappen op een custom pipeline op het moment dat u tegen een geïdentificeerde limiet aanloopt. Door beide achter één enkele respond-methode te kapselen, maakt u deze overstap pijnloos voor de rest van uw applicatie.

class HybridRAG:
    """Start with File Search, switch to custom if needed."""

    def __init__(self, mode: str = "file_search"):
        self.client = OpenAI()
        self.mode = mode

    def respond_file_search(self, question: str, vs_id: str) -> str:
        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=question,
            tools=[{
                "type": "file_search",
                "vector_store_ids": [vs_id]
            }]
        )
        return response.output_text

    def respond_custom(self, question: str, pipeline) -> str:
        result = pipeline.respond(question)
        return result["response"]

    def respond(self, question: str, **kwargs) -> str:
        if self.mode == "file_search":
            return self.respond_file_search(
                question, kwargs["vs_id"]
            )
        else:
            return self.respond_custom(
                question, kwargs["pipeline"]
            )

Wanneer migratie noodzakelijk wordt, volgt dit een precieze volgorde:

  1. Exporteer uw bestanden uit de vector store
  2. Implementeer chunking afgestemd op uw inhoud
  3. Genereer embeddings met text-embedding-3-large
  4. Indexeer in een vectordatabase (Qdrant, Pinecone, etc.)
  5. Voeg reranking en hybride zoeken toe
  6. Evalueer met uw testdataset
  7. Vergelijk de metrics met File Search voordat u overstapt

De laatste stap is degene die het vaakst wordt overgeslagen, en het is de enige die al het andere rechtvaardigt: zonder een kwantitatieve vergelijking heeft u mogelijk een degelijk beheerd systeem vervangen door een inferieur zelfgebouwd systeem, plus de onderhoudslast.

Belangrijkste punten

  • File Search is ideaal om snel een RAG-systeem te prototypen zonder infrastructuur
  • Een custom RAG-pipeline biedt totale controle en optimaliseerbare prestaties
  • Begin met File Search en migreer naar custom wanneer u tegen limieten aanloopt
  • Beslissingscriteria: controle, gevoelige data, kosten, prestaties