Formatação de citações

Citações confiáveis dão aos leitores mais segurança nas respostas e permitem verificar sua exatidão. Este guia mostra como preparar o material que pode ser citado e orientar o modelo a formatar as citações corretamente, usando padrões familiares aos modelos da OpenAI.

Visão geral

Um sistema de citações envolve várias etapas. Você decide o que pode ser citado, apresenta esse material com clareza, orienta o modelo sobre como citá-lo e valida o resultado antes de exibi-lo ao usuário.

Este guia aborda cinco elementos diretamente relacionados à forma como o modelo recebe o material e produz as citações:

1. Unidades citáveis: defina o que o modelo pode citar.
2. Representação do material: apresente o material de origem em um formato claro e estruturado.
3. Formato das citações: especifique o formato exato que o modelo deve usar nas citações.
4. Instruções do prompt: indique quando o modelo deve citar e como fazer isso corretamente.
5. Extração das citações: extraia as citações da resposta do modelo para usá-las nas etapas seguintes.

Escolha as unidades citáveis

Antes de escrever os prompts, defina com clareza o que o modelo pode citar. Algumas opções comuns são:

Uma boa unidade citável deve ter:

• Consistência: a mesma fonte deve manter o mesmo ID entre execuções.
• Facilidade de consulta: quem lê a unidade deve conseguir entender o contexto em que ela aparece.
• Tamanho adequado: a unidade deve ser extensa o suficiente para fazer sentido e curta o suficiente para manter a precisão.

Na maioria dos sistemas, citar blocos é a melhor opção padrão. Em geral, é mais fácil para o modelo citar blocos do que linhas, e os usuários obtêm referências mais úteis do que quando a citação aponta para o documento inteiro.

Represente o material citável

O modelo só consegue citar material que tenha sido apresentado com clareza. Tanto para material retornado por uma ferramenta quanto para material inserido diretamente, inclua:

• ID estável da fonte: um identificador consistente, como file1 ou block1.
• Texto legível: o material de origem com formatação clara.
• Metadados (opcionais): URLs, datas e horários, títulos e outras informações de contexto.

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.

Defina o formato das citações

Defina o formato das citações que o modelo vai gerar. Escolha um formato explícito e consistente que o modelo consiga reproduzir com facilidade e de maneira confiável.

A tabela a seguir apresenta o formato de citação e os marcadores recomendados. Recomendamos especialmente esses marcadores porque são muito semelhantes aos usados no treinamento dos nossos modelos. Se você escolher outros valores para os marcadores, mantenha o formato geral da citação o mais próximo possível do recomendado.

Estrutura

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

Exemplo

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

Se o sistema não usar localizadores, omita esse campo:

{CITATION_START}cite{CITATION_DELIMITER}turn0file1{CITATION_STOP}

Escreva instruções eficazes para citações

Para obter a máxima precisão, use padrões de citação familiares ao modelo. Formatos personalizados ou pouco familiares exigem mais esforço do modelo e podem levar a erros nas citações, especialmente em duas situações:

• Quando o esforço de raciocínio é baixo, o modelo dispõe de menos recursos para corrigir erros de formatação.
• Em tarefas complexas, o modelo dedica a maior parte dos recursos de raciocínio à resolução da tarefa em si, o que deixa menos recursos para corrigir a sintaxe das citações.

A seguir, recomendamos um formato de citação próximo dos padrões que o modelo já conhece. Você pode usá-lo como está ou adaptá-lo ao seu sistema.

Se quiser escrever seu próprio prompt, especifique:

• a sintaxe exata dos marcadores.
• onde inserir as citações.
• quando citar e quando não citar.
• como citar várias fontes que sustentam uma afirmação.
• quais formatos são proibidos.
• o que fazer quando nenhuma fonte sustenta a afirmação.

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

Extraia as citações

Depois que o modelo emitir as citações, extraia-as do texto da resposta. Assim, você pode identificar as fontes pelos IDs, exibir links ou remover os marcadores brutos antes de mostrar a resposta aos usuários.

Você pode copiar o código auxiliar a seguir diretamente para o seu aplicativo. Ele extrai citações de uma ou várias fontes e localizadores opcionais de intervalos de linhas, preservando as posições dos caracteres no texto original.

Este exemplo aceita apenas localizadores de linhas. Adapte-o se o seu sistema usar outro formato de localizador.

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

Se os IDs das fontes tiverem outro formato, ajuste SOURCE_ID_RE ao padrão do seu sistema.

Exemplos

Os exemplos a seguir mostram dois padrões comuns de citação:

• Contexto recuperado por uma ferramenta, em que a ferramenta retorna o material citável e os respectivos IDs.
• Contexto inserido no prompt, em que você fornece os blocos citáveis diretamente no prompt.

Formate citações de contexto recuperado por uma ferramenta

Use esse padrão quando o modelo usar uma ferramenta para recuperar contexto e citar esse material na resposta.

Defina as unidades citáveis

Escolha as unidades citáveis de acordo com a precisão exigida pelo seu caso de uso. Os exemplos a seguir mostram alguns resultados possíveis de uma chamada de ferramenta.

Esses exemplos ilustram alguns formatos recomendados para a saída da ferramenta. A ferramenta usada pode variar conforme o aplicativo. O mais importante é apresentar a saída com uma estrutura clara e estável, como nos exemplos.

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

Escreva as instruções do prompt

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

Exemplo de saída:

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

Formate citações de contexto inserido no prompt

Use esse padrão quando você recuperar ou preparar o contexto com antecedência e inseri-lo diretamente no prompt.

Defina as unidades citáveis

Ao inserir o contexto no prompt, uma prática comum é delimitar os trechos de cada fonte com tags explícitas que tenham IDs de referência estáveis.

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

Assim, a unidade citável fica claramente delimitada, o que facilita a referência pelo modelo.

Escreva as instruções do prompt

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

Exemplo de saída:

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