Quellenangaben formatieren

Verlässliche Quellenangaben schaffen Vertrauen und helfen beim Lesen, die Richtigkeit von Antworten zu überprüfen. Dieser Leitfaden zeigt dir, wie du zitierfähiges Material aufbereitest und das Modell anweist, Quellenangaben passend zu formatieren. Dabei kommen Muster zum Einsatz, mit denen OpenAI-Modelle vertraut sind.

Übersicht

Ein System für Quellenangaben besteht aus mehreren Teilen: Du legst fest, was zitiert werden darf, stellst das Material übersichtlich dar, erklärst dem Modell, wie es darauf verweisen soll, und validierst das Ergebnis, bevor es angezeigt wird.

Dieser Leitfaden behandelt fünf Kernelemente, mit denen das Modell direkt arbeitet:

1. Zitierfähige Einheiten: Lege fest, was das Modell zitieren darf.
2. Darstellung des Materials: Stelle das Quellenmaterial in einem klaren, strukturierten Format bereit.
3. Format der Quellenangaben: Gib genau vor, welches Format das Modell für Quellenangaben verwenden soll.
4. Anweisungen im Prompt: Erkläre dem Modell, wann es Quellen angeben soll und wie es das korrekt macht.
5. Parsen von Quellenangaben: Extrahiere die Quellenangaben aus der Antwort des Modells für die weitere Verarbeitung.

Zitierfähige Einheiten auswählen

Bevor du Prompts schreibst, lege klar fest, was das Modell zitieren kann. Gängige Optionen sind:

Eine gute zitierfähige Einheit sollte folgende Eigenschaften haben:

• Konsistent: Dieselbe Quelle sollte über mehrere Durchläufe hinweg dieselbe ID behalten.
• Leicht überprüfbar: Menschen sollten sie lesen und den umgebenden Kontext verstehen können.
• Passende Größe: groß genug, um verständlich zu sein, aber klein genug, um präzise zu bleiben.

Für die meisten Systeme sind Quellenangaben auf Blockebene die beste Standardwahl. Sie sind für das Modell in der Regel einfacher als zeilengenaue Quellenangaben und für die Nutzenden hilfreicher als Verweise auf ganze Dokumente.

Zitierfähiges Material darstellen

Das Modell kann kein Material zitieren, das nicht klar dargestellt ist. Unabhängig davon, ob das Material aus einem Tool stammt oder direkt eingefügt wird, sollte es Folgendes enthalten:

• Stabile Quellen-ID: Eine konsistente Kennung wie file1 oder block1.
• Lesbarer Text: Klar formatiertes Quellenmaterial.
• Metadaten (optional): URLs, Zeitstempel, Titel und ähnliche Kontextinformationen.

Citation Marker: {CITATION_START}cite{CITATION_DELIMITER}file0{CITATION_STOP}
Title: Employee Handbook
URL: https://company.example/handbook
Updated: 2026-03-01

[L1] Employees may work remotely up to three days per week.
[L2] Additional remote days require manager approval.
[L3] Exceptions may apply for approved accommodations.

Format der Quellenangaben festlegen

Du musst festlegen, in welchem Format das Modell Quellenangaben erzeugen soll. Verwende ein Format, das eindeutig und konsistent ist und das Modell leicht und zuverlässig reproduzieren kann.

Im Folgenden findest du das von uns empfohlene Format für Quellenangaben und die dazugehörigen Marker. Wir empfehlen diese Quellenmarker ausdrücklich, da sie den Markern sehr nahekommen, mit denen unsere Modelle trainiert wurden. Wenn du andere Markerwerte wählst, halte das Gesamtformat der Quellenangaben möglichst ähnlich.

Vorlage

{CITATION_START}<citation_family>{CITATION_DELIMITER}<source_id>{CITATION_DELIMITER}<locator>{CITATION_STOP}

Beispiel

{CITATION_START}cite{CITATION_DELIMITER}turn0file1{CITATION_DELIMITER}L8-L13{CITATION_STOP}

Wenn dein System keine Positionsangaben verwendet, lasse dieses Feld weg:

{CITATION_START}cite{CITATION_DELIMITER}turn0file1{CITATION_STOP}

Wirksame Anweisungen für Quellenangaben schreiben

Verwende vertraute Muster für Quellenangaben, um eine möglichst hohe Genauigkeit zu erreichen. Eigene oder ungewohnte Formate erhöhen die kognitive Belastung des Modells und führen dadurch zu Fehlern bei Quellenangaben, besonders in folgenden Fällen:

• niedrigem Reasoning-Aufwand, bei dem das Modell weniger Budget hat, um Formatierungsfehler zu korrigieren.
• hochkomplexen Aufgaben, bei denen der Großteil des Reasoning-Budgets für die eigentliche Aufgabe aufgewendet wird und nicht für die Korrektur der Syntax von Quellenangaben.

Im Folgenden empfehlen wir ein Format für Quellenangaben, das den dem Modell vertrauten Mustern ähnelt. Du kannst es unverändert übernehmen oder an dein eigenes System anpassen.

Wenn du einen eigenen Prompt formulieren möchtest, lege Folgendes fest:

• die genaue Syntax der Markierungen.
• wo Quellenangaben stehen sollen.
• wann Quellen angegeben werden sollen und wann nicht.
• wie mehrere Belege angegeben werden sollen.
• welche Formate nicht zulässig sind.
• was zu tun ist, wenn Belege fehlen.

## Citations

Results are returned by "tool_1". Each message from `tool_1` is called a "source" and identified by its reference ID, which is the first occurrence of 【turn\d+\w+\d+】 (e.g. 【turn2file1】). In this example, the string "turn2file1" would be the source reference ID.

Citations are references to `tool_1` sources. Citations may be used to refer to either a single source or multiple sources.

Citations to a single source must be written as {CITATION_START}cite{CITATION_DELIMITER}turn\d+\w+\d+{CITATION_STOP} (e.g. {CITATION_START}cite{CITATION_DELIMITER}turn2file5{CITATION_STOP}).

Citations to multiple sources must be written as {CITATION_START}cite{CITATION_DELIMITER}turn\d+\w+\d+{CITATION_DELIMITER}turn\d+\w+\d+{CITATION_DELIMITER}...{CITATION_STOP} (e.g. {CITATION_START}cite{CITATION_DELIMITER}turn2file5{CITATION_DELIMITER}turn2file1{CITATION_DELIMITER}...{CITATION_STOP}).

Citations must not be placed inside markdown bold, italics, or code fences, as they will not display correctly. Instead, place the citations outside the markdown block. Citations outside code fences may not be placed on the same line as the end of the code fence.

You must NOT write reference ID turn\d+\w+\d+ verbatim in the response text without putting them between {CITATION_START}...{CITATION_STOP}.

- Place citations at the end of the paragraph, or inline if the paragraph is long, unless the user requests specific citation placement.
- Citations must be placed after punctuation.
- Citations must not be all grouped together at the end of the response.
- Citations must not be put in a line or paragraph with nothing else but the citations themselves.

You *must* cite any results you use from this tool using the:
`\ue200cite\ue202turn0file0\ue202L8-L13\ue201` format ONLY if the item has a corresponding citation marker.

12345678910111213<extra_considerations_for_citations>
- **Relevance:** Include only search results and citations that support the cited response text. Irrelevant sources permanently degrade user trust.
- **Diversity:** You must base your answer on sources from diverse domains, and cite accordingly.
- **Trustworthiness:** To produce a credible response, you must rely on high quality domains, and ignore information from less reputable domains unless they are the only source.
- **Accurate Representation:** Each citation must accurately reflect the source content. Selective interpretation of the source content is not allowed.

Remember, the quality of a domain/source depends on the context.
- When multiple viewpoints exist, cite sources covering the spectrum of opinions to ensure balance and comprehensiveness.
- When reliable sources disagree, cite at least one high-quality source for each major viewpoint.
- Ensure more than half of citations come from widely recognized authoritative outlets on the topic.
- For debated topics, cite at least one reliable source representing each major viewpoint.
- Do not ignore the content of a relevant source because it is low quality.
</extra_considerations_for_citations>

Quellenangaben parsen

Sobald das Modell Quellenangaben ausgibt, musst du sie aus dem Antworttext extrahieren. So kannst du die zugehörigen Quellen anhand ihrer IDs ermitteln, Links anzeigen oder die unverarbeiteten Markierungen entfernen, bevor du die Antwort anzeigst.

Den folgenden Hilfscode kannst du direkt in deine Anwendung kopieren. Er parst Quellenangaben mit einer oder mehreren Quellen sowie optionale Zeilenbereiche als Positionsangaben. Dabei bleiben die Zeichenpositionen im ursprünglichen Text erhalten.

Dieses Beispiel unterstützt nur Positionsangaben anhand von Zeilen. Passe es an, wenn dein System ein anderes Format für Positionsangaben verwendet.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75const CITATION_START = "\uE200";
const CITATION_DELIMITER = "\uE202";
const CITATION_STOP = "\uE201";

const SOURCE_ID_RE = /^[A-Za-z0-9_-]+$/;
const LINE_LOCATOR_RE = /^L\d+(?:-L\d+)?$/;

// Extract citations such as:
//
//   {CITATION_START}cite{CITATION_DELIMITER}turn0file0{CITATION_STOP}
//   {CITATION_START}cite{CITATION_DELIMITER}turn0file0{CITATION_DELIMITER}L8-L13{CITATION_STOP}
//   {CITATION_START}cite{CITATION_DELIMITER}turn0search0{CITATION_DELIMITER}turn1news2{CITATION_STOP}
function extractCitations(text, { families = ["cite"] } = {}) {
  if (families.length === 0) {
    return [];
  }

  const familyPattern = families
    .map((family) => family.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
    .join("|");

  const tokenRe = new RegExp(
    `${CITATION_START}(?<family>${familyPattern})${CITATION_DELIMITER}(?<body>[\\s\\S]*?)${CITATION_STOP}`,
    "g"
  );

  const citations = [];

  for (const match of text.matchAll(tokenRe)) {
    const body = match.groups?.body ?? "";
    const parts = body
      .split(CITATION_DELIMITER)
      .map((part) => part.trim())
      .filter(Boolean);

    if (parts.length === 0) {
      continue;
    }

    let locator = null;
    const lastPart = parts[parts.length - 1];
    if (LINE_LOCATOR_RE.test(lastPart)) {
      locator = parts.pop() ?? null;
    }

    if (parts.length === 0 || parts.some((part) => !SOURCE_ID_RE.test(part))) {
      continue;
    }

    citations.push({
      raw: match[0],
      family: match.groups?.family ?? "",
      source_ids: parts,
      locator,
      start: match.index ?? 0,
      end: (match.index ?? 0) + match[0].length,
    });
  }

  return citations;
}

function stripCitations(text, citations) {
  let cleanText = text;
  const sortedCitations = Array.from(citations).sort(
    (left, right) => right.start - left.start
  );

  for (const citation of sortedCitations) {
    cleanText =
      cleanText.slice(0, citation.start) + cleanText.slice(citation.end);
  }

  return cleanText;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87import re
from collections.abc import Iterable
from typing import TypedDict

CITATION_START = "\ue200"
CITATION_DELIMITER = "\ue202"
CITATION_STOP = "\ue201"

SOURCE_ID_RE = re.compile(r"^[A-Za-z0-9_-]+$")
LINE_LOCATOR_RE = re.compile(r"^L\d+(?:-L\d+)?$")


class Citation(TypedDict):
    raw: str
    family: str
    source_ids: list[str]
    locator: str | None
    start: int
    end: int


def extract_citations(
    text: str,
    *,
    families: tuple[str, ...] = ("cite",),
) -> list[Citation]:
    """
    Extract citations such as:

      {CITATION_START}cite{CITATION_DELIMITER}turn0file0{CITATION_STOP}
      {CITATION_START}cite{CITATION_DELIMITER}turn0file0{CITATION_DELIMITER}L8-L13{CITATION_STOP}
      {CITATION_START}cite{CITATION_DELIMITER}turn0search0{CITATION_DELIMITER}turn1news2{CITATION_STOP}
    """
    if not families:
        return []

    family_pattern = "|".join(re.escape(family) for family in families)
    token_re = re.compile(
        rf"{re.escape(CITATION_START)}"
        rf"(?P<family>{family_pattern})"
        rf"{re.escape(CITATION_DELIMITER)}"
        rf"(?P<body>.*?)"
        rf"{re.escape(CITATION_STOP)}",
        re.DOTALL,
    )

    citations: list[Citation] = []

    for match in token_re.finditer(text):
        parts = [part.strip() for part in match.group("body").split(CITATION_DELIMITER)]
        parts = [part for part in parts if part]

        if not parts:
            continue

        locator = None
        if LINE_LOCATOR_RE.fullmatch(parts[-1]):
            locator = parts.pop()

        if not parts or any(not SOURCE_ID_RE.fullmatch(part) for part in parts):
            continue

        citations.append(
            {
                "raw": match.group(0),
                "family": match.group("family"),
                "source_ids": parts,
                "locator": locator,
                "start": match.start(),
                "end": match.end(),
            }
        )

    return citations


def strip_citations(text: str, citations: Iterable[Citation]) -> str:
    """
    Remove raw citation markers from text using offsets returned by
    extract_citations().
    """
    clean_text = text

    for citation in sorted(citations, key=lambda item: item["start"], reverse=True):
        clean_text = clean_text[: citation["start"]] + clean_text[citation["end"] :]

    return clean_text

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47CITATION_START = "\u{E200}"
CITATION_DELIMITER = "\u{E202}"
CITATION_STOP = "\u{E201}"

SOURCE_ID_RE = /\A[A-Za-z0-9_-]+\z/
LINE_LOCATOR_RE = /\AL\d+(?:-L\d+)?\z/

def extract_citations(text, families: ["cite"])
  return [] if families.empty?

  family_pattern = families.map { |family| Regexp.escape(family) }.join("|")
  token_re = Regexp.new(
    "#{Regexp.escape(CITATION_START)}" \
      "(?<family>#{family_pattern})" \
      "#{Regexp.escape(CITATION_DELIMITER)}" \
      "(?<body>.*?)" \
      "#{Regexp.escape(CITATION_STOP)}",
    Regexp::MULTILINE
  )

  text.enum_for(:scan, token_re).map do
    match = Regexp.last_match
    next unless match

    body = match[:body]
    next unless body

    parts = body.split(CITATION_DELIMITER).map(&:strip).reject(&:empty?)
    locator = parts.pop if parts.last&.match?(LINE_LOCATOR_RE)
    next if parts.empty? || parts.any? { |part| !part.match?(SOURCE_ID_RE) }

    {
      raw: match[0],
      family: match[:family],
      source_ids: parts,
      locator: locator,
      start: match.begin(0),
      end: match.end(0)
    }
  end.compact
end

def strip_citations(text, citations)
  citations.sort_by { |citation| -citation.fetch(:start) }.each_with_object(text.dup) do |citation, clean|
    clean[citation.fetch(:start)...citation.fetch(:end)] = ""
  end
end

Wenn deine Quellen-IDs anders aufgebaut sind, passe SOURCE_ID_RE an dein System an.

Beispiele

Die folgenden Beispiele zeigen zwei gängige Muster für Quellenangaben:

• Über ein Tool abgerufener Kontext, bei dem dein Tool zitierfähiges Material und IDs zurückgibt.
• Direkt eingefügter Kontext, bei dem du zitierfähige Blöcke im Prompt bereitstellst.

Quellenangaben für über Tools abgerufenen Kontext formatieren

Verwende dieses Muster, wenn das Modell Kontext über ein Tool abruft und diesen in seiner Antwort als Quelle angibt.

Zitierfähige Einheiten definieren

Wähle die zitierfähigen Einheiten danach aus, wie präzise die Quellenangaben für deinen Anwendungsfall sein müssen. Die folgenden Beispiele zeigen einige mögliche Tool-Ausgaben.

Die folgenden Beispiele zeigen einige empfohlene Formate für Tool-Ausgaben. Das zugrunde liegende Tool kann je nach Anwendung variieren. Entscheidend ist, dass die Ausgabe wie in diesen Beispielen eine klare, stabile Struktur hat.

Citation Marker: {CITATION_START}cite{CITATION_DELIMITER}turn0file0{CITATION_STOP}
[L1] The service agreement states that termination for convenience requires thirty (30) days’ written notice, unless superseded by a customer-specific addendum.
[L2] In practice, renewal terms auto-extend for successive one-year periods when no written non-renewal notice is received before the deadline.
[L3] Appendix B further clarifies that pricing exceptions must be approved in writing by both Finance and the account owner.

Citation Marker: {CITATION_START}cite{CITATION_DELIMITER}turn0file1{CITATION_STOP}
...

Citation Marker: {CITATION_START}cite{CITATION_DELIMITER}turn0file0{CITATION_STOP}
[Block1]
The service agreement states that termination for convenience requires thirty (30) days’ written notice, unless superseded by a customer-specific addendum.
In practice, renewal terms auto-extend for successive one-year periods when no written non-renewal notice is received before the deadline.
Appendix B further clarifies that pricing exceptions must be approved in writing by both Finance and the account owner.

Citation Marker: {CITATION_START}cite{CITATION_DELIMITER}turn0file1{CITATION_STOP}
[Block2]
...

Prompt-Anweisungen formulieren

## Citations

Results are returned by "tool_1". Each message from `tool_1` is called a "source" and identified by its reference ID, which is the first occurrence of `turn\\d+file\\d+` (for example, `turn0file0` or `turn2file1`). In this example, the string `turn0file0` would be the source reference ID.

Citations are references to `tool_1` sources. Citations may be used to refer to either a single source or multiple sources.

A citation to a single source must be written as:
{CITATION_START}cite{CITATION_DELIMITER}turn\d+file\d+{CITATION_STOP}

If line-level citations are supported, a citation to a specific line range must be written as:
{CITATION_START}cite{CITATION_DELIMITER}turn\d+file\d+{CITATION_DELIMITER}L\d+-L\d+{CITATION_STOP}

Citations to multiple sources must be written by emitting multiple citation markers, one for each supporting source.

You must NOT write reference IDs like `turn0file0` verbatim in the response text without putting them between {CITATION_START}...{CITATION_STOP}.

- Place citations at the end of the supported sentence, or inline if the sentence is long and contains multiple supported clauses.
- Citations must be placed after punctuation.
- Cite only retrieved sources that directly support the cited text.
- Never invent source IDs, line ranges, or block locators that were not returned by the tool.
- If multiple retrieved sources materially support a proposition, cite all of them.
- If the retrieved sources disagree, cite the conflicting sources and describe the disagreement accurately.

Beispielausgabe:

The on-call handoff process is documented in the weekly support sync notes. \ue200cite\ue202turn0file0\ue202L8-L13\ue201

Quellenangaben für direkt eingefügten Kontext formatieren

Verwende dieses Muster, wenn du den Kontext vorab abrufst oder vorbereitest und direkt in den Prompt einfügst.

Zitierfähige Einheiten definieren

Bei direkt eingefügtem Kontext ist es üblich, Quellabschnitte mit expliziten Tags und stabilen Referenz-IDs zu umschließen.

12345678910<BLOCK id="block1">
The service agreement states that termination for convenience requires thirty (30) days’ written notice, unless superseded by a customer-specific addendum.
In practice, renewal terms auto-extend for successive one-year periods when no written non-renewal notice is received before the deadline.
Appendix B further clarifies that pricing exceptions must be approved in writing by both Finance and the account owner.
</BLOCK>

<BLOCK id="block2">
Syllabus
</BLOCK>
...

So ist die zitierfähige Einheit klar abgegrenzt, und das Modell kann leicht darauf verweisen.

Prompt-Anweisungen formulieren

## Citations

Supporting context is provided directly in the prompt as citable units. Each citable unit is identified by the value of its `id` attribute in the first occurrence of a tag such as `<BLOCK id="block5"> ... </BLOCK>`. In this example, `block5` would be the source reference ID.

Because this pattern does not invoke tools, there is no tool turn counter to increment. That means you do not need to use a `turn#` prefix for the citation marker. You can keep IDs in a `turn0block5` style if that matches the rest of your system, or use plain IDs like `block5` as shown here. The key requirement is that the citation marker matches the injected context ID exactly and consistently.

Citations are references to these provided citable units. Citations may be used to refer to either a single source or multiple sources.

A citation to a single source must be written as:
{CITATION_START}cite{CITATION_DELIMITER}<block_id>{CITATION_STOP}

For example:
{CITATION_START}cite{CITATION_DELIMITER}block5{CITATION_STOP}

Citations to multiple sources must be written by emitting multiple citation markers, one for each supporting block.

You must NOT write block IDs verbatim in the response text without putting them between {CITATION_START}...{CITATION_STOP}.

- Place citations at the end of the supported sentence, or inline if the sentence is long and contains multiple supported clauses.
- Citations must be placed after punctuation.
- Cite only blocks that appear in the provided context.
- Never invent new block IDs.
- Never cite outside knowledge or outside authorities.
- If multiple blocks materially support a proposition, cite all of them.
- If the provided blocks conflict, cite the conflicting blocks and describe the conflict accurately.

Beispielausgabe:

The Court held that the District Court lacked personal jurisdiction over the petitioner. \ue200cite\ue202block5\ue201