Formato de las citas

Las citas confiables ayudan a los lectores a confiar en las respuestas y a verificar su exactitud. Esta guía explica cómo preparar material que se pueda citar y cómo indicarle al modelo que dé formato a las citas con patrones que los modelos de OpenAI ya conocen.

Descripción general

Un sistema de citas consta de varias partes. Tú decides qué se puede citar, presentas ese material con claridad, le indicas al modelo cómo citarlo y validas el resultado antes de mostrárselo al usuario.

Esta guía abarca cinco elementos que intervienen directamente en la interacción con el modelo:

1. Unidades citables: define qué puede citar el modelo.
2. Representación del material: presenta el material de origen en un formato claro y estructurado.
3. Formato de las citas: especifica el formato exacto que debe usar el modelo para las citas.
4. Instrucciones del prompt: indícale al modelo cuándo citar y cómo hacerlo correctamente.
5. Análisis de las citas: extrae las citas de la respuesta del modelo para usarlas en etapas posteriores.

Elegir las unidades citables

Antes de escribir los prompts, define con claridad qué puede citar el modelo. Estas son algunas opciones habituales:

Una buena unidad citable debe cumplir estos criterios:

• Identificación estable: una misma fuente debe conservar el mismo ID en cada ejecución.
• Facilidad de revisión: cualquier persona debe poder leerla y entender el contexto que la rodea.
• Tamaño adecuado: debe ser lo bastante extensa para que se entienda y lo bastante breve para que la cita sea precisa.

En la mayoría de los sistemas, citar por bloque es la mejor opción predeterminada. Para el modelo suele ser más fácil que citar por línea, y para los usuarios resulta más útil que citar el documento completo.

Representar el material citable

El modelo no puede citar material que no se le haya presentado con claridad. Tanto si el material proviene de una herramienta como si lo insertas directamente, asegúrate de que incluya lo siguiente:

• ID de fuente estable: un identificador que se mantenga constante, como file1 o block1.
• Texto legible: material de origen con un formato claro.
• Metadatos (opcionales): URL, marcas de tiempo, títulos y otros datos de contexto similares.

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.

Definir el formato de las citas

Define el formato de las citas que generará el modelo. Usa un formato explícito y uniforme que el modelo pueda reproducir de manera confiable.

A continuación se muestran el formato y los marcadores de cita que recomendamos. Recomendamos especialmente estos marcadores porque son muy similares a los que se usaron para entrenar nuestros modelos. Si eliges otros valores para los marcadores, procura que el formato general de las citas sea lo más parecido posible al recomendado.

Plantilla

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

Ejemplo

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

Si tu sistema no usa localizadores, omite ese campo:

{CITATION_START}cite{CITATION_DELIMITER}turn0file1{CITATION_STOP}

Redactar instrucciones eficaces para las citas

Para lograr la mayor precisión posible, usa patrones de cita que el modelo conozca. Los formatos personalizados o poco familiares exigen más esfuerzo al modelo, lo que puede provocar errores en las citas, sobre todo en estos casos:

• Cuando el esfuerzo de razonamiento es bajo, el modelo dispone de menos recursos para corregir errores de formato.
• En tareas de alta complejidad, el modelo dedica la mayor parte de su presupuesto de razonamiento a resolver la tarea en sí y le queda poco margen para corregir la sintaxis de las citas.

El formato de cita que recomendamos a continuación se asemeja a los patrones que el modelo ya conoce. Puedes usarlo tal como está o adaptarlo a tu sistema.

Si quieres redactar tu propio prompt, especifica lo siguiente:

• La sintaxis exacta de los marcadores.
• Dónde colocar las citas.
• Cuándo citar y cuándo omitir las citas.
• Cómo citar varias fuentes que respaldan una afirmación.
• Qué formatos están prohibidos.
• Qué hacer si no hay material que respalde una afirmación.

## Citas

La herramienta “tool_1” devuelve los resultados. Cada mensaje de `tool_1` se denomina “fuente”. Su ID de referencia corresponde a la primera coincidencia con el patrón 【turn\d+\w+\d+】 (por ejemplo, 【turn2file1】). En este ejemplo, la cadena “turn2file1” sería el ID de referencia de la fuente.

Las citas hacen referencia a las fuentes de `tool_1`. Una cita puede remitir a una o varias fuentes.

Para citar una sola fuente, usa el formato {CITATION_START}cite{CITATION_DELIMITER}turn\d+\w+\d+{CITATION_STOP} (por ejemplo, {CITATION_START}cite{CITATION_DELIMITER}turn2file5{CITATION_STOP}).

Para citar varias fuentes, incluye sus ID en un solo marcador con el formato {CITATION_START}cite{CITATION_DELIMITER}turn\d+\w+\d+{CITATION_DELIMITER}turn\d+\w+\d+{CITATION_DELIMITER}...{CITATION_STOP} (por ejemplo, {CITATION_START}cite{CITATION_DELIMITER}turn2file5{CITATION_DELIMITER}turn2file1{CITATION_DELIMITER}...{CITATION_STOP}).

En Markdown, coloca las citas fuera del texto en negrita o cursiva y fuera de los bloques de código para que se muestren correctamente. Coloca la cita en una línea distinta de la que cierra el bloque de código.

NO escribas literalmente en la respuesta ningún ID de referencia que siga el patrón turn\d+\w+\d+ sin colocarlo entre los delimitadores de {CITATION_START}...{CITATION_STOP}.

- Coloca las citas al final del párrafo o, si el párrafo es largo, dentro del texto, salvo que el usuario indique dónde colocarlas.
- Coloca las citas después del signo de puntuación.
- No agrupes todas las citas al final de la respuesta.
- No dejes una línea o un párrafo que contenga únicamente citas.

Si usas un resultado de esta herramienta, *debes* citarlo con el formato
`\ue200cite\ue202turn0file0\ue202L8-L13\ue201` SOLO si ese resultado tiene el marcador de cita correspondiente.

12345678910111213<extra_considerations_for_citations>
- **Pertinencia:** incluye solo resultados de búsqueda y citas que respalden el pasaje de la respuesta al que se refieren. Citar fuentes irrelevantes perjudica de forma permanente la confianza del usuario.
- **Diversidad:** basa tu respuesta en fuentes de distintos dominios y cita las que uses.
- **Confiabilidad:** para ofrecer una respuesta creíble, usa fuentes de dominios de alta calidad. Descarta la información de dominios de menor reputación, salvo que sean la única fuente disponible.
- **Fidelidad a la fuente:** cada cita debe reflejar con exactitud el contenido de la fuente. No interpretes su contenido de manera selectiva.

Recuerda que la calidad de un dominio o de una fuente depende del contexto.
- Cuando existan varios puntos de vista, cita fuentes que abarquen todo el espectro de opiniones para ofrecer una respuesta equilibrada y completa.
- Cuando las fuentes confiables discrepen, cita al menos una fuente de alta calidad por cada postura principal.
- Asegúrate de que más de la mitad de las citas provengan de publicaciones ampliamente reconocidas como autoridades en el tema.
- En temas controvertidos, cita al menos una fuente confiable por cada postura principal, de modo que todas queden representadas.
- No descartes el contenido de una fuente pertinente solo porque sea de baja calidad.
</extra_considerations_for_citations>

Analizar las citas

Una vez que el modelo genera las citas, debes extraerlas del texto de la respuesta para poder resolver los ID de fuente, mostrar enlaces o quitar los marcadores sin procesar antes de mostrarles la respuesta a los usuarios.

Puedes copiar directamente en tu aplicación la función auxiliar que se muestra a continuación. Analiza citas de una o varias fuentes y localizadores opcionales de rangos de líneas. Al hacerlo, conserva las posiciones de los caracteres en el texto original.

Este ejemplo solo admite localizadores de líneas. Si tu sistema usa otro formato de localizador, adapta el ejemplo.

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 tus ID de fuente tienen otro formato, actualiza SOURCE_ID_RE para que coincida con el de tu sistema.

Ejemplos

Los siguientes ejemplos muestran dos patrones habituales de cita:

• Contexto recuperado con una herramienta: la herramienta devuelve material citable y sus ID.
• Contexto insertado: proporcionas los bloques citables directamente en el prompt.

Dar formato a las citas de contexto recuperado con una herramienta

Usa este patrón cuando el modelo recupere contexto mediante una herramienta y lo cite en su respuesta.

Definir las unidades citables

Elige las unidades citables según el grado de precisión que requiera tu caso de uso. Los siguientes ejemplos muestran algunos resultados que podría devolver una herramienta.

Estos ejemplos ilustran algunos formatos de salida recomendados. La herramienta puede variar según la aplicación. Lo más importante es que presente los resultados con una estructura clara y estable, como en estos ejemplos.

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

Redactar las instrucciones del prompt

## Citas

La herramienta “tool_1” devuelve los resultados. Cada mensaje de `tool_1` se denomina “fuente”. Su ID de referencia corresponde a la primera coincidencia con el patrón `turn\\d+file\\d+` (por ejemplo, `turn0file0` o `turn2file1`). En este ejemplo, la cadena `turn0file0` sería el ID de referencia de la fuente.

Las citas hacen referencia a las fuentes de `tool_1`. Puedes citar una o varias fuentes.

Para citar una sola fuente, usa este formato:
{CITATION_START}cite{CITATION_DELIMITER}turn\d+file\d+{CITATION_STOP}

Si se admiten citas por línea, usa este formato para citar un rango de líneas específico:
{CITATION_START}cite{CITATION_DELIMITER}turn\d+file\d+{CITATION_DELIMITER}L\d+-L\d+{CITATION_STOP}

Para citar varias fuentes, genera un marcador de cita distinto para cada fuente que respalde la afirmación.

NO escribas literalmente en el texto de la respuesta ID de referencia como `turn0file0` sin colocarlos entre los delimitadores de {CITATION_START}...{CITATION_STOP}.

- Coloca las citas al final de la oración que respaldan. Si la oración es larga y contiene varias afirmaciones respaldadas por fuentes, puedes colocar cada cita junto a la afirmación correspondiente.
- Coloca las citas después del signo de puntuación.
- Cita solo las fuentes recuperadas que respalden directamente el texto citado.
- Nunca inventes ID de fuente, rangos de líneas ni localizadores de bloque que la herramienta no haya devuelto.
- Si varias fuentes recuperadas aportan respaldo sustancial a una afirmación, cítalas todas.
- Si las fuentes recuperadas discrepan, cita las fuentes en cuestión y describe con precisión en qué discrepan.

Ejemplo de salida:

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

Dar formato a las citas de contexto insertado

Usa este patrón cuando recuperes o prepares el contexto de antemano y lo insertes directamente en el prompt.

Definir las unidades citables

Una práctica habitual al insertar contexto es delimitar los fragmentos de las fuentes con etiquetas explícitas que tengan ID de referencia estables.

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

Así, el modelo puede identificar con claridad la unidad citable y hacer referencia a ella con facilidad.

Redactar las instrucciones del prompt

## Citas

El prompt incluye directamente el contexto de apoyo en forma de unidades citables. Cada unidad se identifica por el valor de su atributo `id` en la primera aparición de una etiqueta como `<BLOCK id="block5"> ... </BLOCK>`. En este ejemplo, `block5` sería el ID de referencia de la fuente.

Como este patrón no requiere llamadas a herramientas, no hay un contador de turnos de herramienta que incrementar. Por eso, no necesitas usar el prefijo `turn#` en el marcador de cita. Puedes conservar ID con el formato `turn0block5` si el resto de tu sistema lo usa, o usar ID simples como `block5`, tal como se muestra aquí. El ID que incluyas en el marcador de cita siempre debe coincidir exactamente con el ID del contexto insertado.

Las citas hacen referencia a las unidades citables proporcionadas. Puedes citar una o varias fuentes.

Para citar una sola fuente, usa este formato:
{CITATION_START}cite{CITATION_DELIMITER}<block_id>{CITATION_STOP}

Por ejemplo:
{CITATION_START}cite{CITATION_DELIMITER}block5{CITATION_STOP}

Para citar varias fuentes, genera un marcador de cita distinto para cada bloque que respalde la afirmación.

NO escribas literalmente los ID de bloque en el texto de la respuesta sin colocarlos entre los delimitadores de {CITATION_START}...{CITATION_STOP}.

- Coloca las citas al final de la oración que respaldan. Si la oración es larga y contiene varias afirmaciones respaldadas por fuentes, puedes colocar cada cita junto a la afirmación correspondiente.
- Coloca las citas después del signo de puntuación.
- Cita solo los bloques que aparezcan en el contexto proporcionado.
- Nunca inventes ID de bloque.
- Nunca cites conocimientos ni autoridades ajenos al contexto proporcionado.
- Si varios bloques aportan respaldo sustancial a una afirmación, cítalos todos.
- Si los bloques proporcionados se contradicen, cita los bloques en cuestión y describe con precisión la contradicción.

Ejemplo de salida:

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