> ## 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-gestützte Antworten

Ein Modell allein kann keine Fragen zu Ereignissen nach dem Ende seines Trainingszeitraums beantworten oder eine Quelle angeben. Die Lösung ist *Grounding*: Rufen Sie zur Anfragezeit relevante Webinhalte ab und übergeben Sie sie dem Modell als Kontext. Dieser Leitfaden zeigt das Muster mit Novita [AI Search](/docs/de/guides/ai-search-quickstart) für Retrieval und die [LLM API](/docs/de/guides/llm-api) für die Synthese — alles hinter einem einzigen API-Schlüssel.

## Was ist RAG?

Retrieval-augmented generation (RAG) ist das Muster hinter jeder fundierten Antwort hier: Anstatt sich darauf zu verlassen, was das Modell während des Trainings auswendig gelernt hat, *rufst* du zum Zeitpunkt der Anfrage relevante Dokumente ab und *erweiterst* den Prompt damit, sodass das Modell seine Antwort aus diesem frischen, überprüfbaren Kontext *generiert*.

Genau diesen Abrufschritt stellt AI Search bereit. Das Web wird zu deiner Wissensbasis, und du musst keine Vektordatenbank aufbauen oder pflegen, um loszulegen — ein Search-Aufruf gibt die Textpassagen zurück, und das LLM erledigt den Rest. Wenn du später Abruf über deine *eigenen* privaten Dokumente möchtest, gilt dieselbe dreistufige Struktur; du tauschst lediglich die Websuche gegen einen Vektorspeicher aus.

RAG bringt dir drei Dinge, die ein reines Modell nicht bieten kann:

* **Aktualität** — Antworten spiegeln Inhalte wider, die nach dem Trainings-Cutoff des Modells veröffentlicht wurden.
* **Zuordnung** — jede Behauptung kann auf eine Quell-URL verweisen, die der Nutzer prüfen kann.
* **Reduzierte Halluzinationen** — die Fundierung des Modells in abgerufenem Text hält es davon ab, Fakten zu erfinden.

## Wie Grounding funktioniert

Ein einzelner RAG-Durchlauf folgt drei Schritten:

1. **Suchen** (abrufen) im Web nach Seiten, die für die Frage relevant sind.
2. **Extrahieren** (erweitern) des benötigten Inhalts — Snippets oder vollständiger Seitentext — in den Prompt.
3. **Synthetisieren** (generieren) einer Antwort, indem dieser Inhalt an ein LLM übergeben wird, mit der Aufforderung, Quellen zu zitieren.

Du kannst das mit zwei Aufrufen tun (Search + LLM) oder sogar mit einem, da sowohl Exa als auch Tavily eine Antwort für dich synthetisieren können. Wähle danach, wie viel Kontrolle du über die endgültige Formulierung und die Zitationen brauchst.

## Lass den Anbieter die Antwort schreiben

Der schnellste Weg. Tavilys Search gibt eine LLM-generierte Antwort zurück, wenn du festlegst `include_answer`, und Exa bietet eine dedizierte [Antwort](/docs/de/api-reference/model-apis-exa-answer) Endpunkt. Ein Aufruf, keine Orchestrierung.

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

Verwende dies, wenn du eine gute Antwort mit minimalem Code möchtest. Greife auf den unten beschriebenen Abrufen-dann-Synthetisieren-Ansatz zurück, wenn du Kontrolle über das Modell, den Ton, das Ausgabeformat oder die Darstellung von Quellenangaben benötigst.

## Abrufen, dann mit einem LLM synthetisieren

Dies gibt dir volle Kontrolle. Suche nach Quellen und übergib die Ergebnisse dann an die [LLM API](/docs/de/guides/llm-api) mit Anweisungen, nur anhand dieses Kontexts zu antworten und jede Behauptung zu belegen.

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

Derselbe Ablauf funktioniert mit Exa Search — ersetze die Route durch `/v3/exa/search` und lesen `text` aus jedem Ergebnis statt `raw_content`.

## Optimierung der Retrieval-Qualität

Die Qualität einer fundierten Antwort hängt weit mehr davon ab, *was du abrufst*, als vom Modell. Ein paar Stellschrauben mit großer Wirkung:

* **Aktualität.** Schränke bei zeitkritischen Fragen nach Datum ein. Tavily stellt `time_range` und `start_date`/`end_date`; Exa stellt bereit `startPublishedDate`/`endPublishedDate`. Dadurch bleiben veraltete Seiten aus dem Kontext.
* **Quellenvertrauen.** Verwenden Sie `include_domains`/`excludeDomains` um den Abruf auf Quellen zu beschränken, denen du vertraust (offizielle Dokumentation, seriöse Verlage), und Websites von geringer Qualität auszuschließen.
* **Themenhinweise.** Tavilys `topic` (`news`, `finance`, `general`) und Exas `category` die Engine auf die richtige Art von Ergebnis ausrichten.
* **Kontext passend dimensionieren.** Begrenze extrahierten Text (Tavily `chunks_per_source`, Exa `maxCharacters`) sodass du genügend Signal weitergibst, ohne das Kontextfenster des Modells oder dein Token-Budget zu sprengen.

## Search vs. Extract vs. Crawl

Wähle das Retrieval-Primitiv, das deinem Bedarf entspricht:

* **Search** — du hast eine Frage und musst relevante Seiten *entdecken*. Der standardmäßige Ausgangspunkt.
* **Extract / Contents** — du kennst die URLs bereits und möchtest sauberen Text daraus. Gut für die Fundierung auf einer festen Dokumentenmenge. Siehe [Tavily Extract](/docs/de/api-reference/model-apis-tavily-extract) und [Exa Contents](/docs/de/api-reference/model-apis-exa-contents).
* **Crawl / Map** — Sie möchten eine ganze Website oder einen Abschnitt erfassen und dabei Links folgen. Gut geeignet, um offline eine Wissensdatenbank aufzubauen. Siehe [Tavily Crawl](/docs/de/api-reference/model-apis-tavily-crawl) und [Tavily Map](/docs/de/api-reference/model-apis-tavily-map).

<Tip>
  Einen umfassenderen Agenten, der iterativ sucht und über viele Quellen schlussfolgert, finden Sie in der [DeepSearcher-Integration](/docs/de/guides/deepsearcher).
</Tip>

## Für die Produktion vorbereiten

* **Behandle leere Ergebnisse.** Wenn die Suche nichts Relevantes zurückgibt, lasse das Modell sagen, dass es die Frage nicht beantworten kann, statt eine Antwort zu erfinden. Der System-Prompt oben tut dies.
* **Cache, wann immer du kannst.** Identische Abfragen liefern ähnliche Ergebnisse; das Caching von Retrieval reduziert Kosten und Latenz.
* **Beachte Rate Limits.** Retrieval- und LLM-Aufrufe sind separat begrenzt — eine Suchanfrage belastet dein LLM-Kontingent nicht. Führe Backoff durch bei `429` für beides. Siehe [LLM-Ratenlimits](/docs/de/guides/llm-rate-limits) für die LLM-Seite.
* **Schlüssel serverseitig halten.** Ihr Novita-Schlüssel authentifiziert hier jeden Aufruf — liefern Sie ihn niemals in clientseitigem Code aus.