Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

File Search kontra anpassad RAG: När ska du använda vad?

Lektion 16 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. File Search: OpenAI:s hanterade RAG
  3. Vad File Search ger dig, och vad det tar ifrån dig
  4. Beslutsmatris
  5. Hybridarkitektur: Det bästa från båda världarna
  6. Viktiga punkter

Mål

  • Förstå OpenAI:s hanterade RAG (File Search)
  • Jämför File Search med en anpassad RAG-pipeline
  • Välj rätt metod för ditt användningsområde

File Search: OpenAI:s hanterade RAG

Du har precis byggt varje lager i en RAG-pipeline, lektion för lektion. File Search gör allt detta åt dig. Det är ett verktyg inbyggt i OpenAI Responses API som automatiskt hanterar chunking, inbäddning, vektorlagring och sökning: du laddar upp dina filer och ställer sedan frågor. Denna lektion är inte ett avvisande av det som kommit tidigare, utan en ärlig fråga du måste ställa dig innan du skriver någon kod: vad är rätt abstraktionsnivå för ditt projekt?

Allt börjar med ett vektorarkiv, containern som huserar dina indexerade dokument. Du skapar det, pushar filer in i det en efter en, och väntar sedan på att indexeringen ska bli klar innan du börjar fråga. Denna vänteslinga är inte kosmetisk: indexering är asynkron, och en fråga som skickas för tidigt kommer bara att se en del av korpusen.

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")

Själva frågeställningen sker sedan med ett enda anrop: du deklarerar verktyget file_search med arkiv-ID:t, så avgör modellen när information ska hämtas. Det intressanta är att läsa annotationerna, som innehåller filciteringarna. Detta låter dig visa källor för användaren – ett beteende du var tvungen att implementera manuellt i den anpassade pipelinen.

# 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}")

Två inställningar låter dig finjustera beteendet utan att lämna det hanterade verktyget. max_num_results anger antalet hämtade chunkar, och score_threshold filtrerar bort resultat med låg poäng, precis som den relevanströskel du tillämpade efter omrangordning.

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
        }
    }]
)

Vad File Search ger dig, och vad det tar ifrån dig

Det avgörande argumentet för File Search är den totala frånvaron av infrastruktur: ingen vektordatabas att provisionera, säkerhetskopiera eller övervaka. Chunking sköts åt dig och optimeras av OpenAI, att uppdatera korpusen är lika enkelt som att lägga till eller ta bort en fil, citeringar genereras automatiskt och vanliga format stöds inbyggt – PDF, DOCX, MD, TXT, HTML, JSON, med flera. Ett team utan infrastrukturkompetens kan få en kunskapsbas online på en eftermiddag.

Baksidan av denna bekvämlighet är förlusten av kontroll över varje länk i kedjan. Du väljer inte chunk-storleken, så avvägningen mellan precision och kontext från lektion 12 hamnar utanför din räckvidd. Sökningen är rent semantisk: ingen hybrid sökning, vilket gör att produktreferenser och exakta felkoder förblir bräckliga. Du kan inte heller koppla in Cohere eller en hemmagjord cross-encoder för omrangordning. Lägg därtill tre ytterligare strategiska överväganden: vektorlagring debiteras utöver API-anrop, dina data finns på OpenAI:s servrar, och indexering täcker endast text.

En anpassad pipeline vänder på denna lista term för term. Du behärskar chunking, inbäddning, sökning, omrangordning och promptning; du kombinerar semantisk och lexikal sökning; du blandar modellleverantörer, eller håller allt on-premise om dina data kräver det; och framför allt optimerar du varje komponent oberoende genom att mäta dess effekt. Denna kontroll kommer till priset av kod som måste skrivas och underhållas, en vektordatabas att administrera, och expertis – chunking, utvärdering och omrangordning improviseras inte, vilket är precis vad denna kurs behandlar.

Beslutsmatris

KriteriumFile SearchAnpassad RAG
Snabb prototypning✅ Idealiskt⚠️ Långsammare
Kontroll över chunking❌✅
Hybrid sökning❌✅
Känsliga data⚠️ Hos OpenAI✅ On-premise
Kostnad i skala⚠️ Kan bli hög✅ Förutsägbar
Underhåll✅ Noll⚠️ Att hantera
Maximal prestanda⚠️ God✅ Optimerbar

Hybridarkitektur: Det bästa från båda världarna

Valet behöver inte vara definitivt, och det bör det inte vara. Den mest kostnadseffektiva metoden är att börja med File Search för att validera att ditt användningsområde håller, och sedan byta till en anpassad pipeline den dag du stöter på en identifierad begränsning. Att kapsla in båda bakom en enda respond-metod gör denna övergång smärtfri för resten av 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 blir nödvändig följer den en precis ordning:

  1. Exportera dina filer från vektorarkivet
  2. Implementera chunking anpassat till ditt innehåll
  3. Generera inbäddningar med text-embedding-3-large
  4. Indexera i en vektordatabas (Qdrant, Pinecone, etc.)
  5. Lägg till omrangordning och hybrid sökning
  6. Utvärdera med din testdataset
  7. Jämför mätvärden med File Search innan byte

Det sista steget är det som oftast hoppas över, och det är det enda som rättfärdigar allt annat: utan en kvantitativ jämförelse kan du ha ersatt ett dugligt hanterat system med ett sämre hemmagjort, plus overheaden för underhåll.

Viktiga punkter

  • File Search är idealiskt för att snabbt prototypa ett RAG-system utan infrastruktur
  • En anpassad RAG-pipeline erbjuder total kontroll och optimerbar prestanda
  • Börja med File Search, migrera till anpassat när du stöter på begränsningar
  • Beslutskriterier: kontroll, känsliga data, kostnad, prestanda