File Search vs. brugerdefineret RAG: Hvornår skal du bruge hvad?
På denne side
Mål
- Forstå OpenAIs administrerede RAG (File Search)
- Sammenlign File Search med en brugerdefineret RAG-pipeline
- Vælg den rigtige tilgang til dit brugstilfælde
File Search: OpenAIs administrerede RAG
Du har lige bygget hvert lag i en RAG-pipeline, lektion for lektion. File Search gør alt dette for dig. Det er et værktøj indbygget i OpenAI Responses API, der automatisk håndterer chunking, embedding, vektorlagring og søgning: du uploader dine filer, og du forespørger. Denne lektion er ikke en afvisning af det foregående, men et ærligt spørgsmål, du skal stille, før du skriver én eneste linje kode: Hvad er det rette abstraktionsniveau for dit projekt?
Alt starter med et vektorlager, beholderen der huser dine indekserede dokumenter. Du opretter det, pusher filer ind én efter én og venter derefter på, at indekseringen er færdig, før du forespørger. Denne venteloop er ikke kosmetisk: indeksering er asynkron, og en forespørgsel, der lanceres for tidligt, vil kun se en del af korpussen.
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")
Selve forespørgslen kræver kun ét kald: du deklarerer værktøjet file_search med lager-ID’et, og modellen beslutter, hvornår den skal hente information. Det interessante er at læse annotationerne, som indeholder filcitationerne. Dette giver dig mulighed for at vise kilder til brugeren – den adfærd, du skulle implementere manuelt i den brugerdefinerede pipeline.
# 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}")
To indstillinger lader dig finjustere adfærden uden at forlade det administrerede værktøj. max_num_results sætter antallet af hentede chunks, og score_threshold filtrerer resultater med lav score fra, præcis som den relevanstærskel, du anvendte efter genrangering.
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
}
}]
)
Hvad File Search giver dig, og hvad det tager fra dig
Det afgørende argument for File Search er det totale fravær af infrastruktur: ingen vektordatabase der skal klargøres, sikkerhedskopieres eller overvåges. Chunking udføres for dig og optimeres af OpenAI, opdatering af korpussen er så simpelt som at tilføje eller fjerne en fil, citationer genereres automatisk, og almindelige formater understøttes nativt – PDF, DOCX, MD, TXT, HTML, JSON, blandt andre. Et team uden infrastruktur-ekspertise kan få en vidensbase online på en eftermiddag.
Bagsiden af denne bekvemmelighed er tabet af kontrol over hvert led i kæden. Du vælger ikke chunk-størrelsen, så afvejningen mellem præcision og kontekst fra lektion 12 er uden for din rækkevidde. Søgningen er rent semantisk: ingen hybrid søgning, så produktreferencer og nøjagtige fejlkoder forbliver skrøbelige. Du kan heller ikke tilslutte Cohere eller en hjemmelavet cross-encoder til genrangering. Læg dertil tre yderligere strategiske overvejelser: vektorlagring faktureres ud over API-kald, dine data resides på OpenAIs servere, og indeksering dækker kun tekst.
En brugerdefineret pipeline vender denne liste på hovedet led for led. Du mestrer chunking, embedding, søgning, genrangering og prompting; du kombinerer semantisk og leksikalsk søgning; du blander modeludbydere, eller holder alt on-premise, hvis dine data kræver det; og frem for alt optimerer du hver komponent uafhængigt ved at måle dens effekt. Denne kontrol kommer til prisen af kode, der skal skrives og vedligeholdes, en vektordatabase der skal administreres, og ekspertise – chunking, evaluering og genrangering er ikke noget, man improviserer, hvilket er præcis, hvad dette kursus dækker.
Beslutningsmatrix
| Kriterium | File Search | Brugerdefineret RAG |
|---|---|---|
| Hurtig prototyping | ✅ Ideel | ⚠️ Langsommere |
| Kontrol over chunking | ❌ | ✅ |
| Hybrid søgning | ❌ | ✅ |
| Følsomme data | ⚠️ På OpenAI | ✅ On-premise |
| Omkostninger ved skala | ⚠️ Kan være høje | ✅ Forudsigelige |
| Vedligeholdelse | ✅ Nul | ⚠️ Skal håndteres |
| Maksimal ydeevne | ⚠️ God | ✅ Kan optimeres |
Hybrid arkitektur: Det bedste fra begge verdener
Valget behøver ikke være endeligt, og det bør det ikke være. Den mest omkostningseffektive tilgang er at starte med File Search for at validere, at dit brugstilfælde holder vand, og derefter skifte til en brugerdefineret pipeline den dag, du rammer en identificeret grænse. At kapsle begge bag en enkelt respond-metode gør dette skift smertefrit for resten af din applikation.
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"]
)
Når migration bliver nødvendig, følger den en præcis rækkefølge:
- Eksporter dine filer fra vektorlageret
- Implementer chunking tilpasset dit indhold
- Generer embeddings med
text-embedding-3-large - Indeksér i en vektordatabase (Qdrant, Pinecone osv.)
- Tilføj genrangering og hybrid søgning
- Evaluér med dit testsæt
- Sammenlign metriker med File Search før skiftet
Det sidste trin er det, der oftest springes over, og det er det eneste, der retfærdiggør alt andet: uden en kvantitativ sammenligning kan du have erstattet et anstændigt administreret system med et ringere hjemmelavet ét, plus omkostningerne ved vedligeholdelse.
Vigtige pointer
- File Search er ideel til hurtigt at prototypere et RAG-system uden infrastruktur
- En brugerdefineret RAG-pipeline tilbyder total kontrol og optimerbar ydeevne
- Start med File Search, migrér til brugerdefineret, når du rammer grænser
- Beslutningskriterier: kontrol, følsomme data, omkostninger, ydeevne