Format des citations

Des citations fiables inspirent confiance et permettent aux lecteurs de vérifier l’exactitude des réponses. Ce guide explique comment préparer les contenus à citer et donner au modèle des instructions de mise en forme adaptées aux formats que les modèles d’OpenAI connaissent déjà.

Vue d’ensemble

La mise en place d’un système de citation comporte plusieurs étapes. Vous déterminez ce qui peut être cité, présentez clairement les contenus correspondants, indiquez au modèle comment les citer et validez le résultat avant de l’afficher à l’utilisateur.

Ce guide couvre cinq éléments qui concernent directement le modèle :

1. Unités citables : définissez ce que le modèle est autorisé à citer.
2. Présentation des sources : fournissez le contenu des sources dans un format clair et structuré.
3. Format des citations : précisez le format exact que le modèle doit utiliser.
4. Instructions du prompt : indiquez au modèle quand citer ses sources et comment le faire correctement.
5. Analyse des citations : extrayez les citations de la réponse du modèle pour les exploiter ensuite.

Choisissez les unités citables

Avant de rédiger vos prompts, définissez précisément ce que le modèle peut citer. Voici les options les plus courantes :

Une bonne unité citable répond à trois critères :

• Stabilité : une même source doit conserver le même identifiant d’une exécution à l’autre.
• Lisibilité : une personne doit pouvoir lire l’unité et en comprendre le contexte.
• Taille adaptée : l’unité doit être assez longue pour être compréhensible, mais assez courte pour que la citation reste précise.

Pour la plupart des systèmes, citer des blocs est le meilleur choix par défaut. Il est généralement plus facile pour le modèle de citer un bloc que des lignes précises, et plus utile pour l’utilisateur de retrouver un bloc qu’un document entier.

Présentez les contenus à citer

Le modèle ne peut pas citer un contenu qui ne lui a pas été présenté clairement. Que ce contenu provienne d’un outil ou soit injecté directement, veillez à fournir les éléments suivants :

• Identifiant de source stable : utilisez un identifiant qui reste le même, comme file1 ou block1.
• Texte lisible : mettez en forme le contenu de la source pour en faciliter la lecture.
• Métadonnées (facultatives) : URL, horodatages, titres et autres éléments de contexte.

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.

Définissez le format des citations

Définissez le format des citations que le modèle doit générer. Choisissez un format explicite et cohérent que le modèle peut reproduire de manière fiable.

Le tableau ci-dessous présente le format de citation et les marqueurs que nous recommandons. Nous vous conseillons vivement d’utiliser ces marqueurs, car ils sont très proches de ceux utilisés lors de l’entraînement de nos modèles. Si vous choisissez d’autres valeurs pour les marqueurs, conservez un format de citation aussi proche que possible de celui proposé.

Gabarit

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

Exemple

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

Si votre système n’utilise pas de repères de position, omettez ce champ :

{CITATION_START}cite{CITATION_DELIMITER}turn0file1{CITATION_STOP}

Rédigez des instructions de citation efficaces

Pour obtenir la meilleure précision possible, utilisez des formats de citation familiers au modèle. Les formats personnalisés ou peu familiers demandent davantage d’effort au modèle et entraînent des erreurs de citation, en particulier dans les cas suivants :

• Lorsque l’effort de raisonnement est faible, le modèle dispose d’un budget de raisonnement plus limité pour corriger ses erreurs de format.
• Lorsque la tâche est très complexe, le modèle consacre l’essentiel de son budget de raisonnement à la résolution de la tâche elle-même et dispose de peu de ressources pour corriger la syntaxe des citations.

Nous recommandons ci-dessous un format de citation proche de ceux que le modèle connaît déjà. Vous pouvez l’utiliser tel quel ou l’adapter à votre système.

Si vous rédigez votre propre prompt, précisez :

• la syntaxe exacte des marqueurs ;
• où placer les citations ;
• quand citer une source et quand s’en abstenir ;
• comment citer plusieurs sources à l’appui d’une même affirmation ;
• quels formats sont interdits ;
• quoi faire lorsqu’aucune source n’étaye une affirmation.

## Citations

L’outil « tool_1 » renvoie les résultats. Chaque message de `tool_1` constitue une « source ». Pour trouver son identifiant de référence, repérez la première occurrence du motif 【turn\d+\w+\d+】 dans le message (par exemple 【turn2file1】). Dans cet exemple, la chaîne « turn2file1 » est l’identifiant de référence de la source.

Les citations renvoient aux sources fournies par `tool_1`. Une citation peut renvoyer à une ou plusieurs sources.

Pour citer une seule source, utilisez le format {CITATION_START}cite{CITATION_DELIMITER}turn\d+\w+\d+{CITATION_STOP} (par exemple {CITATION_START}cite{CITATION_DELIMITER}turn2file5{CITATION_STOP}).

Pour citer plusieurs sources, utilisez le format {CITATION_START}cite{CITATION_DELIMITER}turn\d+\w+\d+{CITATION_DELIMITER}turn\d+\w+\d+{CITATION_DELIMITER}...{CITATION_STOP} (par exemple {CITATION_START}cite{CITATION_DELIMITER}turn2file5{CITATION_DELIMITER}turn2file1{CITATION_DELIMITER}...{CITATION_STOP}).

Placez les citations en dehors des passages en gras ou en italique et des blocs de code Markdown pour qu’elles s’affichent correctement. Ne placez aucune citation sur la même ligne que le délimiteur de fermeture d’un bloc de code.

N’écrivez JAMAIS un identifiant de référence de la forme turn\d+\w+\d+ tel quel dans le texte de la réponse sans l’encadrer par {CITATION_START}...{CITATION_STOP}.

- Placez les citations à la fin du paragraphe ou, si le paragraphe est long, dans le corps du texte, sauf si l’utilisateur demande un emplacement précis.
- Placez les citations après la ponctuation.
- Ne regroupez pas toutes les citations à la fin de la réponse.
- Ne placez pas les citations sur une ligne ou dans un paragraphe qui ne contient rien d’autre.

Vous *devez* citer chaque résultat de cet outil que vous utilisez, mais UNIQUEMENT si ce résultat possède un marqueur de citation correspondant. Utilisez le format suivant :
`\ue200cite\ue202turn0file0\ue202L8-L13\ue201`.

12345678910111213<extra_considerations_for_citations>
- **Pertinence :** incluez uniquement les résultats de recherche et les citations qui étayent le passage concerné de la réponse. Les sources sans rapport avec ce passage nuisent durablement à la confiance des utilisateurs.
- **Diversité :** appuyez votre réponse sur des sources provenant de domaines variés et citez-les à l’appui des passages correspondants.
- **Fiabilité :** pour produire une réponse crédible, appuyez-vous sur des domaines de qualité. Écartez les informations provenant de domaines moins réputés, sauf si ces domaines sont votre seule source d’information.
- **Fidélité aux sources :** chaque citation doit refléter fidèlement le contenu de la source. Toute interprétation sélective de ce contenu est interdite.

Gardez à l’esprit que la qualité d’un domaine ou d’une source dépend du contexte.
- Lorsqu’il existe plusieurs points de vue, citez des sources qui couvrent l’éventail des opinions pour en rendre compte de manière équilibrée et complète.
- Lorsque des sources fiables divergent, citez au moins une source de qualité pour chaque point de vue majeur.
- Veillez à ce que plus de la moitié des citations renvoient à des publications largement reconnues comme faisant autorité sur le sujet.
- Pour les sujets controversés, citez au moins une source fiable représentant chaque point de vue majeur.
- N’écartez pas le contenu d’une source pertinente au seul motif qu’elle est de faible qualité.
</extra_considerations_for_citations>

Analysez les citations

Une fois les citations générées par le modèle, extrayez-les du texte de la réponse. Vous pourrez ainsi retrouver les sources à partir de leurs identifiants, afficher des liens ou supprimer les marqueurs bruts avant de présenter la réponse aux utilisateurs.

Vous pouvez copier les fonctions ci-dessous directement dans votre application. Elles analysent les citations qui renvoient à une ou plusieurs sources ainsi que les éventuels repères de position exprimés en plages de lignes, tout en conservant la position des caractères dans le texte d’origine.

Cet exemple ne prend en charge que les repères de position exprimés en lignes. Adaptez-le si votre système utilise un autre format de repère.

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63// Start and End are UTF-8 byte offsets, suitable for Go string slicing.
type Citation struct {
	Raw, Family string
	SourceIDs   []string
	Locator     string
	Start, End  int
}

var sourceID = regexp.MustCompile(`^[A-Za-z0-9_-]+$`)
var lineLocator = regexp.MustCompile(`^L\d+(?:-L\d+)?$`)

func extractCitations(text string, families []string) []Citation {
	citations := []Citation{}
	if len(families) == 0 {
		return citations
	}
	escaped := make([]string, len(families))
	for i, family := range families {
		escaped[i] = regexp.QuoteMeta(family)
	}
	token := regexp.MustCompile("(?s)\uE200(" + strings.Join(escaped, "|") + ")\uE202(.*?)\uE201")
	for _, match := range token.FindAllStringSubmatchIndex(text, -1) {
		parts := []string{}
		for _, part := range strings.Split(text[match[4]:match[5]], "\uE202") {
			if part = strings.TrimSpace(part); part != "" {
				parts = append(parts, part)
			}
		}
		locator := ""
		if len(parts) > 0 && lineLocator.MatchString(parts[len(parts)-1]) {
			locator = parts[len(parts)-1]
			parts = parts[:len(parts)-1]
		}
		valid := len(parts) > 0
		for _, part := range parts {
			if !sourceID.MatchString(part) {
				valid = false
				break
			}
		}
		if valid {
			citations = append(citations, Citation{
				text[match[0]:match[1]],
				text[match[2]:match[3]],
				parts,
				locator,
				match[0],
				match[1],
			})
		}
	}
	return citations
}
func stripCitations(text string, citations []Citation) string {
	sorted := append([]Citation(nil), citations...)
	sort.Slice(sorted, func(i, j int) bool {
		return sorted[i].Start > sorted[j].Start
	})
	for _, citation := range sorted {
		text = text[:citation.Start] + text[citation.End:]
	}
	return 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
47
48
49import java.util.*;
import java.util.regex.Pattern;

// Java string offsets are UTF-16 code units, matching substring().
record Citation(
    String raw, String family, List<String> sourceIds, String locator, int start, int end) {}

static final Pattern SOURCE_ID = Pattern.compile("^[A-Za-z0-9_-]+$");
static final Pattern LINE_LOCATOR = Pattern.compile("^L\\d+(?:-L\\d+)?$");

static List<Citation> extractCitations(String text, List<String> families) {
  var citations = new ArrayList<Citation>();
  if (families.isEmpty()) return citations;
  var familyPattern =
      families.stream().map(Pattern::quote).collect(java.util.stream.Collectors.joining("|"));
  var matcher =
      Pattern.compile("\uE200(" + familyPattern + ")\uE202(.*?)\uE201", Pattern.DOTALL)
          .matcher(text);
  while (matcher.find()) {
    var parts =
        new ArrayList<>(
            Arrays.stream(matcher.group(2).split("\uE202"))
                .map(String::strip)
                .filter(s -> !s.isEmpty())
                .toList());
    String locator = null;
    if (!parts.isEmpty() && LINE_LOCATOR.matcher(parts.get(parts.size() - 1)).matches())
      locator = parts.remove(parts.size() - 1);
    if (parts.isEmpty() || parts.stream().anyMatch(s -> !SOURCE_ID.matcher(s).matches()))
      continue;
    citations.add(
        new Citation(
            matcher.group(),
            matcher.group(1),
            List.copyOf(parts),
            locator,
            matcher.start(),
            matcher.end()));
  }
  return citations;
}

static String stripCitations(String text, List<Citation> citations) {
  var sorted = new ArrayList<>(citations);
  sorted.sort(Comparator.comparingInt(Citation::start).reversed());
  for (var citation : sorted)
    text = text.substring(0, citation.start()) + text.substring(citation.end());
  return 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

Si vos identifiants de source suivent un autre format, adaptez SOURCE_ID_RE à votre système.

Exemples

Les exemples ci-dessous illustrent deux façons courantes de citer des sources :

• Contexte récupéré par un outil : votre outil renvoie les contenus à citer et leurs identifiants.
• Contexte injecté : vous fournissez les blocs à citer directement dans le prompt.

Formatez les citations d’un contexte récupéré par un outil

Utilisez cette méthode lorsque le modèle récupère du contexte à l’aide d’un outil et le cite dans sa réponse.

Définissez les unités citables

Choisissez les unités citables en fonction du degré de précision qu’exige votre cas d’usage. Les exemples ci-dessous illustrent quelques résultats possibles d’un appel d’outil.

Ces exemples présentent plusieurs formats de sortie recommandés. L’outil peut varier d’une application à l’autre. L’essentiel est qu’il renvoie les résultats dans une structure claire et stable, comme dans ces exemples.

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

Rédigez les instructions du prompt

## Citations

L’outil « tool_1 » renvoie les résultats. Chaque message de `tool_1` constitue une « source ». Son identifiant de référence est la première chaîne du message qui correspond au motif `turn\\d+file\\d+` (par exemple `turn0file0` ou `turn2file1`). Dans cet exemple, la chaîne `turn0file0` est l’identifiant de référence de la source.

Les citations renvoient aux sources fournies par `tool_1`. Une citation peut renvoyer à une ou plusieurs sources.

Pour citer une seule source, utilisez le format suivant :
{CITATION_START}cite{CITATION_DELIMITER}turn\d+file\d+{CITATION_STOP}

Si le système prend en charge les citations par lignes, utilisez le format suivant pour citer une plage de lignes précise :
{CITATION_START}cite{CITATION_DELIMITER}turn\d+file\d+{CITATION_DELIMITER}L\d+-L\d+{CITATION_STOP}

Pour citer plusieurs sources, produisez un marqueur de citation distinct pour chaque source qui étaye le passage.

N’écrivez JAMAIS d’identifiants de référence comme `turn0file0` tels quels dans le texte de la réponse sans les encadrer par {CITATION_START}...{CITATION_STOP}.

- Placez les citations à la fin de la phrase qu’elles étayent ou, si la phrase est longue et contient plusieurs propositions étayées, au fil du texte après les propositions concernées.
- Placez les citations après la ponctuation.
- Citez uniquement les sources récupérées qui étayent directement le passage concerné.
- N’inventez jamais d’identifiants de source, de plages de lignes ou de repères de bloc que l’outil n’a pas renvoyés.
- Si plusieurs sources récupérées contribuent de manière substantielle à étayer une affirmation, citez-les toutes.
- Si les sources récupérées se contredisent, citez les sources concernées et décrivez précisément leur désaccord.

Exemple de sortie :

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

Formatez les citations d’un contexte injecté

Utilisez cette méthode lorsque vous récupérez ou préparez le contexte à l’avance et l’injectez directement dans le prompt.

Définissez les unités citables

Pour le contexte injecté, une pratique courante consiste à encadrer chaque segment de la source par des balises explicites portant un identifiant de référence stable.

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

Le modèle peut ainsi repérer clairement chaque unité citable et y faire référence facilement.

Rédigez les instructions du prompt

## Citations

Le prompt fournit directement le contexte à l’appui de la réponse sous forme d’unités citables. Pour identifier chaque unité, lisez la valeur de son attribut `id` dans la première occurrence d’une balise telle que `<BLOCK id="block5"> ... </BLOCK>`. Dans cet exemple, `block5` est l’identifiant de référence de la source.

Cette méthode ne fait appel à aucun outil. Il n’y a donc aucun compteur d’appels d’outil à incrémenter, et le préfixe `turn#` est facultatif dans le marqueur de citation. Vous pouvez conserver des identifiants de la forme `turn0block5` si le reste de votre système utilise ce format, ou employer un identifiant simple comme `block5` dans cet exemple. Dans chaque marqueur de citation, reproduisez exactement l’identifiant fourni dans le contexte injecté.

Les citations renvoient aux unités citables fournies. Une citation peut renvoyer à une ou plusieurs sources.

Pour citer une seule source, utilisez le format suivant :
{CITATION_START}cite{CITATION_DELIMITER}<block_id>{CITATION_STOP}

Par exemple :
{CITATION_START}cite{CITATION_DELIMITER}block5{CITATION_STOP}

Pour citer plusieurs sources, produisez un marqueur de citation distinct pour chaque bloc qui étaye le passage.

N’écrivez JAMAIS les identifiants de bloc tels quels dans le texte de la réponse sans les encadrer par {CITATION_START}...{CITATION_STOP}.

- Placez les citations à la fin de la phrase qu’elles étayent ou, si la phrase est longue et contient plusieurs propositions étayées, au fil du texte après les propositions concernées.
- Placez les citations après la ponctuation.
- Citez uniquement les blocs qui figurent dans le contexte fourni.
- N’inventez jamais de nouveaux identifiants de bloc.
- Ne citez jamais de connaissances ni de sources de référence extérieures au contexte fourni.
- Si plusieurs blocs contribuent de manière substantielle à étayer une affirmation, citez-les tous.
- Si les blocs fournis se contredisent, citez les blocs concernés et décrivez précisément la contradiction.

Exemple de sortie :

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