> ## Documentation Index
> Fetch the complete documentation index at: https://novita.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Web-gefundeerde antwoorden

Een model alleen kan geen vragen beantwoorden over gebeurtenissen na de cutoff van zijn training, of een bron citeren. De oplossing is *grounding*: haal relevante webcontent op op het moment van de aanvraag en geef die als context door aan het model. Deze gids laat het patroon zien met Novita [AI-zoeken](/docs/nl/guides/ai-search-quickstart) voor ophalen en de [LLM API](/docs/nl/guides/llm-api) voor synthese — allemaal achter één API-sleutel.

## Wat is RAG?

Retrieval-augmented generation (RAG) is het patroon achter elk gefundeerd antwoord hier: in plaats van te vertrouwen op wat het model tijdens training heeft onthouden, *haal je* relevante documenten op tijdens de request en *verrijk je* de prompt ermee, zodat het model zijn antwoord *genereert* op basis van die actuele, verifieerbare context.

Die ophaalstap is precies wat AI Search biedt. Het web wordt je kennisbank, en je hoeft geen vectordatabase te bouwen of te onderhouden om te beginnen — een search-call retourneert de passages, en de LLM doet de rest. Wanneer je later retrieval over je *eigen* privédocumenten wilt, is dezelfde vorm in drie stappen van toepassing; je vervangt web search gewoon door een vector store.

RAG levert je drie dingen op die een kaal model niet kan bieden:

* **Actualiteit** — antwoorden weerspiegelen content die is gepubliceerd na de training cutoff van het model.
* **Attributie** — elke bewering kan terugwijzen naar een bron-URL die de gebruiker kan controleren.
* **Minder hallucinatie** — het model gronden in opgehaalde tekst voorkomt dat het feiten verzint.

## Hoe grounding werkt

Eén RAG-beurt volgt drie stappen:

1. **Search** (retrieve) het web naar pagina's die relevant zijn voor de vraag.
2. **Extract** (augment) de content die je nodig hebt — snippets of volledige paginetekst — naar de prompt.
3. **Synthesize** (generate) een antwoord door die content aan een LLM door te geven en te vragen bronnen te citeren.

Je kunt dit doen met twee calls (search + LLM) of zelfs één, aangezien zowel Exa als Tavily een antwoord voor je kunnen synthetiseren. Kies op basis van hoeveel controle je nodig hebt over de uiteindelijke formulering en citaties.

## Laat de provider het antwoord schrijven

De snelste route. Tavily's Search retourneert een door een LLM gegenereerd antwoord wanneer je instelt `include_answer`, en Exa biedt een speciale [Antwoord](/docs/nl/api-reference/model-apis-exa-answer) endpoint. Eén aanroep, geen orchestratie.

<CodeGroup>
  ```bash Tavily theme={"system"}
  curl -X POST 'https://api.novita.ai/v3/tavily/search' \
    -H "Authorization: Bearer ${NOVITA_API_KEY}" \
    -H 'Content-Type: application/json' \
    -d '{
      "query": "What changed in the latest Python release?",
      "include_answer": "advanced",
      "max_results": 5
    }'
  ```

  ```bash Exa theme={"system"}
  curl -X POST 'https://api.novita.ai/v3/exa/answer' \
    -H "Authorization: Bearer ${NOVITA_API_KEY}" \
    -H 'Content-Type: application/json' \
    -d '{
      "query": "What changed in the latest Python release?",
      "text": true
    }'
  ```
</CodeGroup>

Gebruik dit wanneer je een goed antwoord wilt met minimale code. Kies voor de aanpak eerst ophalen en dan synthetiseren hieronder wanneer je controle nodig hebt over het model, de toon, de uitvoerindeling of hoe citaties worden gepresenteerd.

## Ophalen, dan synthetiseren met een LLM

Dit geeft je volledige controle. Zoek naar bronnen en geef de resultaten vervolgens aan de [LLM-API](/docs/nl/guides/llm-api) met instructies om uitsluitend op basis van die context te antwoorden en elke bewering te citeren.

```python theme={"system"}
import os
import requests
from openai import OpenAI

NOVITA_KEY = os.environ["NOVITA_API_KEY"]
QUESTION = "What changed in the latest Python release?"

# 1. Retrieve relevant web content.
search = requests.post(
    "https://api.novita.ai/v3/tavily/search",
    headers={"Authorization": f"Bearer {NOVITA_KEY}"},
    json={
        "query": QUESTION,
        "max_results": 5,
        "include_raw_content": "text",
    },
).json()

# 2. Build a compact, numbered context block the model can cite.
sources = []
for i, r in enumerate(search["results"], start=1):
    body = (r.get("raw_content") or r.get("content") or "")[:1500]
    sources.append(f"[{i}] {r['title']} ({r['url']})\n{body}")
context = "\n\n".join(sources)

# 3. Synthesize a grounded, cited answer.
client = OpenAI(base_url="https://api.novita.ai/openai", api_key=NOVITA_KEY)
completion = client.chat.completions.create(
    model="deepseek/deepseek-v4-flash",
    messages=[
        {
            "role": "system",
            "content": (
                "Answer using ONLY the provided sources. "
                "Cite claims with [n] referring to the source number. "
                "If the sources don't contain the answer, say so."
            ),
        },
        {"role": "user", "content": f"Question: {QUESTION}\n\nSources:\n{context}"},
    ],
)
print(completion.choices[0].message.content)
```

Dezelfde flow werkt met Exa Search — vervang de route door `/v3/exa/search` en lees `text` uit elk resultaat in plaats van `raw_content`.

## Retrievalkwaliteit afstemmen

De kwaliteit van een gefundeerd antwoord hangt veel meer af van *wat je ophaalt* dan van het model. Een paar knoppen met grote impact:

* **Actualiteit.** Beperk bij tijdgevoelige vragen op datum. Tavily biedt `time_range` en `start_date`/`end_date`; Exa stelt beschikbaar `startPublishedDate`/`endPublishedDate`. Dit houdt verouderde pagina's buiten de context.
* **Bronvertrouwen.** Gebruik `include_domains`/`excludeDomains` om het ophalen te beperken tot bronnen die je vertrouwt (officiële documentatie, gerenommeerde uitgevers) en sites van lage kwaliteit buiten te houden.
* **Onderwerphints.** Tavily's `topic` (`news`, `finance`, `general`) en Exa's `category` stuur de engine naar het juiste soort resultaat.
* **Context op de juiste grootte brengen.** Beperk geëxtraheerde tekst (Tavily `chunks_per_source`, Exa `maxCharacters`) zodat je genoeg signaal doorgeeft zonder het contextvenster van het model of je tokenbudget te overschrijden.

## Zoeken vs. extraheren vs. crawlen

Kies de retrieval-primitief die past bij je behoefte:

* **Zoeken** — je hebt een vraag en moet relevante pagina's *ontdekken*. Het standaard startpunt.
* **Extraheren / Inhoud** — je kent de URL's al en wilt er schone tekst uit halen. Goed voor grounding op een vaste set documenten. Zie [Tavily Extract](/docs/nl/api-reference/model-apis-tavily-extract) en [Exa Inhoud](/docs/nl/api-reference/model-apis-exa-contents).
* **Crawlen / in kaart brengen** — je wilt een hele site of sectie inlezen door links te volgen. Geschikt om offline een kennisbank op te bouwen. Zie [Tavily Crawl](/docs/nl/api-reference/model-apis-tavily-crawl) en [Tavily Map](/docs/nl/api-reference/model-apis-tavily-map).

<Tip>
  Voor een completere agent die iteratief zoekt en redeneert over veel bronnen, zie de [DeepSearcher-integratie](/docs/nl/guides/deepsearcher).
</Tip>

## In productie nemen

* **Handel lege resultaten af.** Als search niets relevants retourneert, laat het model dan zeggen dat het niet kan antwoorden in plaats van er een te verzinnen. De bovenstaande system prompt doet dit.
* **Cache wanneer je kunt.** Identieke queries retourneren vergelijkbare resultaten; retrieval cachen verlaagt kosten en latency.
* **Let op rate limits.** Retrieval en LLM-calls worden afzonderlijk gelimiteerd — een search request gaat niet ten koste van je LLM-quota. Doe een back-off bij `429` voor beide. Zie [LLM-snelheidslimieten](/docs/nl/guides/llm-rate-limits) voor de LLM-kant.
* **Houd sleutels server-side.** Je Novita-sleutel authenticeert elke aanroep hier — lever die nooit mee in client-side code.