---
title: Synthèse juridique
url: https://platform.claude.com/docs/fr/about-claude/use-case-guides/legal-summarization
description: Ce guide explique comment exploiter les capacités avancées de traitement du langage naturel de Claude pour résumer efficacement des documents juridiques, en extrayant les informations clés et en accélérant la recherche juridique. Avec Claude, vous pouvez rationaliser l'examen des contrats, la préparation des litiges et le travail réglementaire, ce qui vous permet de gagner du temps et de garantir l'exactitude de vos processus juridiques.
---

> Consultez le [cookbook de synthèse](https://platform.claude.com/cookbook/capabilities-summarization-guide) pour voir un exemple d'implémentation de synthèse juridique avec Claude.

## Avant de construire avec Claude

### Décider d'utiliser ou non Claude pour la synthèse juridique

Voici quelques indicateurs clés montrant que vous devriez employer un « large language model » (grand modèle de langage), ou LLM, tel que Claude pour résumer des documents juridiques :

<AccordionGroup>
  <Accordion title="Vous souhaitez examiner un volume élevé de documents de manière efficace et abordable">
    L'examen de documents à grande échelle peut être long et coûteux lorsqu'il est effectué manuellement. Claude peut traiter et résumer rapidement de vastes quantités de documents juridiques, réduisant considérablement le temps et les coûts associés à l'examen des documents. Cette capacité est particulièrement précieuse pour des tâches telles que la due diligence, l'analyse de contrats ou la communication de pièces dans le cadre d'un litige, où l'efficacité est cruciale.
  </Accordion>

  <Accordion title="Vous avez besoin d'une extraction automatisée des métadonnées clés">
    Claude peut extraire et catégoriser efficacement les métadonnées importantes des documents juridiques, telles que les parties impliquées, les dates, les conditions contractuelles ou des clauses spécifiques. Cette extraction automatisée peut aider à organiser l'information, facilitant la recherche, l'analyse et la gestion de grands ensembles de documents. Elle est particulièrement utile pour la gestion des contrats, les contrôles de conformité ou la création de bases de données consultables d'informations juridiques. 
  </Accordion>

  <Accordion title="Vous souhaitez générer des résumés clairs, concis et standardisés">
    Claude peut générer des résumés structurés qui suivent des formats prédéterminés, ce qui permet aux professionnels du droit de saisir rapidement les points clés de divers documents. Ces résumés standardisés peuvent améliorer la lisibilité, faciliter la comparaison entre documents et renforcer la compréhension globale, en particulier face à un langage juridique complexe ou à un jargon technique.
  </Accordion>

  <Accordion title="Vous avez besoin de citations précises pour vos résumés">
    Lors de la création de résumés juridiques, une attribution et des citations appropriées sont cruciales pour garantir la crédibilité et la conformité aux normes juridiques. Claude peut être invité à inclure des citations exactes pour tous les points juridiques référencés, ce qui permet aux professionnels du droit d'examiner et de vérifier plus facilement les informations résumées.
  </Accordion>

  <Accordion title="Vous souhaitez rationaliser et accélérer votre processus de recherche juridique">
    Claude peut vous assister dans la recherche juridique en analysant rapidement de grands volumes de jurisprudence, de lois et de commentaires juridiques. Il peut identifier les précédents pertinents, extraire les principes juridiques clés et résumer des arguments juridiques complexes. Cette capacité peut accélérer considérablement le processus de recherche, permettant aux professionnels du droit de se concentrer sur l'analyse de plus haut niveau et l'élaboration de stratégies.
  </Accordion>
</AccordionGroup>

### Déterminer les détails que vous souhaitez extraire par la synthèse

Il n'existe pas de résumé unique et correct pour un document donné. Sans orientation claire, il peut être difficile pour Claude de déterminer quels détails inclure. Pour obtenir des résultats optimaux, identifiez les informations spécifiques que vous souhaitez inclure dans le résumé.

Par exemple, lors de la synthèse d'un contrat de sous-location, vous pourriez vouloir extraire les points clés suivants :

<CodeGroup exclude="shell">
  ```python Python
  details_to_extract = [
      "Parties involved (sublessor, sublessee, and original lessor)",
      "Property details (address, description, and permitted use)",
      "Term and rent (start date, end date, monthly rent, and security deposit)",
      "Responsibilities (utilities, maintenance, and repairs)",
      "Consent and notices (landlord's consent, and notice requirements)",
      "Special provisions (furniture, parking, and subletting restrictions)",
  ]
  ```

  ```typescript TypeScript
  const detailsToExtract = [
    "Parties involved (sublessor, sublessee, and original lessor)",
    "Property details (address, description, and permitted use)",
    "Term and rent (start date, end date, monthly rent, and security deposit)",
    "Responsibilities (utilities, maintenance, and repairs)",
    "Consent and notices (landlord's consent, and notice requirements)",
    "Special provisions (furniture, parking, and subletting restrictions)"
  ];
  ```

  ```csharp C#
  List<string> detailsToExtract =
  [
      "Parties involved (sublessor, sublessee, and original lessor)",
      "Property details (address, description, and permitted use)",
      "Term and rent (start date, end date, monthly rent, and security deposit)",
      "Responsibilities (utilities, maintenance, and repairs)",
      "Consent and notices (landlord's consent, and notice requirements)",
      "Special provisions (furniture, parking, and subletting restrictions)",
  ];
  ```

  ```go Go
  var detailsToExtract = []string{
  	"Parties involved (sublessor, sublessee, and original lessor)",
  	"Property details (address, description, and permitted use)",
  	"Term and rent (start date, end date, monthly rent, and security deposit)",
  	"Responsibilities (utilities, maintenance, and repairs)",
  	"Consent and notices (landlord's consent, and notice requirements)",
  	"Special provisions (furniture, parking, and subletting restrictions)",
  }
  ```

  ```java Java
  List<String> detailsToExtract = List.of(
          "Parties involved (sublessor, sublessee, and original lessor)",
          "Property details (address, description, and permitted use)",
          "Term and rent (start date, end date, monthly rent, and security deposit)",
          "Responsibilities (utilities, maintenance, and repairs)",
          "Consent and notices (landlord's consent, and notice requirements)",
          "Special provisions (furniture, parking, and subletting restrictions)");
  ```

  ```php PHP
  $detailsToExtract = [
      'Parties involved (sublessor, sublessee, and original lessor)',
      'Property details (address, description, and permitted use)',
      'Term and rent (start date, end date, monthly rent, and security deposit)',
      'Responsibilities (utilities, maintenance, and repairs)',
      "Consent and notices (landlord's consent, and notice requirements)",
      'Special provisions (furniture, parking, and subletting restrictions)',
  ];
  ```

  ```ruby Ruby
  details_to_extract = [
    "Parties involved (sublessor, sublessee, and original lessor)",
    "Property details (address, description, and permitted use)",
    "Term and rent (start date, end date, monthly rent, and security deposit)",
    "Responsibilities (utilities, maintenance, and repairs)",
    "Consent and notices (landlord's consent, and notice requirements)",
    "Special provisions (furniture, parking, and subletting restrictions)"
  ]
  ```
</CodeGroup>

### Établir des critères de réussite

L'évaluation de la qualité des résumés est une tâche notoirement difficile. Contrairement à de nombreuses autres tâches de traitement du langage naturel, l'évaluation des résumés manque souvent de métriques objectives et tranchées. Le processus peut être très subjectif, différents lecteurs valorisant différents aspects d'un résumé. Voici des critères que vous pourriez prendre en compte pour évaluer la performance de Claude en matière de synthèse juridique.

<AccordionGroup>
  <Accordion title="Exactitude factuelle">
    Le résumé doit représenter fidèlement les faits, les concepts juridiques et les points clés du document.
  </Accordion>

  <Accordion title="Précision juridique">
    La terminologie et les références aux lois, à la jurisprudence ou aux réglementations doivent être correctes et conformes aux normes juridiques.
  </Accordion>

  <Accordion title="Concision">
     Le résumé doit condenser le document juridique à ses points essentiels sans perdre de détails importants.
  </Accordion>

  <Accordion title="Cohérence">
    En cas de synthèse de plusieurs documents, le LLM doit maintenir une structure et une approche cohérentes pour chaque résumé.
  </Accordion>

  <Accordion title="Lisibilité">
    Le texte doit être clair et facile à comprendre. Si le public n'est pas composé d'experts juridiques, la synthèse ne doit pas inclure de jargon juridique susceptible de le dérouter.
  </Accordion>

  <Accordion title="Biais et équité">
    Le résumé doit présenter une description impartiale et équitable des arguments et positions juridiques.
  </Accordion>
</AccordionGroup>

Consultez le guide sur [l'établissement de critères de réussite](https://platform.claude.com/docs/fr/test-and-evaluate/develop-tests) pour plus d'informations.

***

## Comment résumer des documents juridiques avec Claude

### Sélectionner le bon modèle Claude

La précision du modèle est extrêmement importante lors de la synthèse de documents juridiques. Claude Opus 5.5 est un excellent choix pour des cas d'usage comme celui-ci, où une grande précision est requise. Si la taille et la quantité de vos documents sont telles que les coûts commencent à devenir une préoccupation, vous pouvez également essayer un modèle plus petit tel que Claude Haiku 5.5.

Pour vous aider à estimer ces coûts, voici une comparaison du coût de synthèse de 1 000 contrats de sous-location avec les modèles Opus et Haiku :

* **Taille du contenu**

  * Nombre de contrats : 1 000
  * Caractères par contrat : 300 000
  * Total de caractères : 300 M

* **Tokens estimés**

  * « Input tokens » (tokens d'entrée) : 108 M, soit environ 108 000 par contrat (environ 1 token pour 2,8 caractères, le ratio observé pour les deux modèles sur le contrat d'exemple de ce guide)
  * « Output tokens » (tokens de sortie) par résumé, y compris les éventuels « thinking tokens » (tokens de réflexion), qui sont facturés comme des tokens de sortie : environ 6 200 sur Claude Opus 5.5 et 3 100 sur Claude Haiku 5.5
  * Total des tokens de sortie : 6,2 M sur Claude Opus 5.5 et 3,1 M sur Claude Haiku 5.5

* **Coût estimé avec Claude Opus 5.5**

  * Coût des tokens d'entrée : 108 MTok \* 4,00 $ / MTok = 432,00 $ USD
  * Coût des tokens de sortie : 6,2 MTok \* 20,00 $ / MTok = 124,00 $ USD
  * Coût total : 432,00 $ + 124,00 $ = 556,00 $ USD

* **Coût estimé avec Claude Haiku 5.5**, à ses tarifs pour les prompts de plus de 100 000 tokens

  * Coût des tokens d'entrée : 108 MTok \* 0,50 $ / MTok = 54,00 $ USD
  * Coût des tokens de sortie : 3,1 MTok \* 2,50 $ / MTok = 7,75 $ USD
  * Coût total : 54,00 $ + 7,75 $ = 61,75 $ USD

<Tip>
  Les coûts réels peuvent différer de ces estimations. Les nombres de tokens proviennent de l'exécution de l'exemple de la section 

  [Construire un prompt solide](https://platform.claude.com/docs/fr/about-claude/use-case-guides/legal-summarization#build-a-strong-prompt)

   sur le contrat d'exemple de ce guide, soit environ 105 000 tokens d'entrée, et la longueur de la sortie varie selon le document et d'une exécution à l'autre. Chaque contrat correspond ici à un prompt d'environ 108 000 tokens, au-delà du seuil de 100 000 tokens des 

  [tarifs pour les prompts longs](https://platform.claude.com/docs/fr/about-claude/pricing#long-context-pricing)

   de Claude Haiku 5.5. Un document dont le prompt reste inférieur ou égal à 100 000 tokens est facturé 0,10 $ / MTok en entrée et 0,50 $ / MTok en sortie. Pour savoir quels tarifs s'appliquent, comptez les tokens de vos documents avec le 

  [comptage de tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting)

   en définissant 

  `model`

   sur 

  `claude-haiku-5-5`

  .
</Tip>

### Transformer les documents dans un format que Claude peut traiter

Avant de commencer à résumer des documents, vous devez préparer vos données. Cela implique d'extraire le texte des PDF, de nettoyer le texte et de vous assurer qu'il est prêt à être traité par Claude.

Voici une démonstration de ce processus sur un exemple de PDF :

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Extrayez le texte du PDF dans le code.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Extrayez le texte du PDF dans le code.
  </CodeGroupItem>

  ```python Python
  from io import BytesIO
  import re

  import pypdf
  import requests


  def get_llm_text(pdf_file):
      reader = pypdf.PdfReader(pdf_file)
      text = "\n".join([page.extract_text() for page in reader.pages])

      # Supprimer les numéros de page
      text = re.sub(r"\n\s*\d+\s*\n", "\n", text)

      # Supprimer les espaces superflus
      text = re.sub(r"\s+", " ", text)

      return text


  # Construire l'URL complète à partir du dépôt GitHub
  url = "https://raw.githubusercontent.com/anthropics/claude-cookbooks/main/capabilities/summarization/data/Sample Sublease Agreement.pdf"
  url = url.replace(" ", "%20")

  # Télécharger le fichier PDF en mémoire
  response = requests.get(url)

  # Charger le PDF depuis la mémoire
  pdf_file = BytesIO(response.content)

  document_text = get_llm_text(pdf_file)
  print(document_text[:50000])
  ```

  ```typescript TypeScript
  import { PDFParse } from "pdf-parse";

  async function getLlmText(pdfData: Uint8Array): Promise<string> {
    const parser = new PDFParse({ data: pdfData });
    const result = await parser.getText();
    await parser.destroy();
    let text = result.pages.map((page) => page.text).join("\n");

    // Supprimer les numéros de page
    text = text.replace(/\n\s*\d+\s*\n/g, "\n");

    // Supprimer les espaces superflus
    text = text.replace(/\s+/g, " ");

    return text;
  }

  // Télécharger l'exemple de contrat de sous-location depuis le cookbook de résumé
  const response = await fetch(
    "https://raw.githubusercontent.com/anthropics/claude-cookbooks/main/capabilities/summarization/data/Sample%20Sublease%20Agreement.pdf"
  );
  const pdfData = new Uint8Array(await response.arrayBuffer());

  const documentText = await getLlmText(pdfData);
  console.log(documentText.slice(0, 50000));
  ```

  ```csharp C#
  using System.Text.RegularExpressions;
  using UglyToad.PdfPig;
  using UglyToad.PdfPig.DocumentLayoutAnalysis.TextExtractor;

  string GetLlmText(byte[] pdfData)
  {
      using var document = PdfDocument.Open(pdfData);
      var text = string.Join("\n", document.GetPages().Select(page => ContentOrderTextExtractor.GetText(page)));

      // Supprimer les numéros de page
      text = Regex.Replace(text, @"\n\s*\d+\s*\n", "\n");

      // Supprimer les espaces superflus
      text = Regex.Replace(text, @"\s+", " ");

      return text;
  }

  // Télécharger l'exemple de contrat de sous-location depuis le cookbook de résumé
  using var httpClient = new HttpClient();
  var pdfData = await httpClient.GetByteArrayAsync(
      "https://raw.githubusercontent.com/anthropics/claude-cookbooks/main/capabilities/summarization/data/Sample%20Sublease%20Agreement.pdf"
  );

  var documentText = GetLlmText(pdfData);
  Console.WriteLine(documentText[..Math.Min(50000, documentText.Length)]);
  ```

  ```go Go
  import (
  	"bytes"
  	"io"
  	"net/http"
  	"regexp"

  	"github.com/ledongthuc/pdf"
  )

  // Le texte de l'exemple de contrat de sous-location
  var documentText string

  func getLLMText(pdfData []byte) (string, error) {
  	reader, err := pdf.NewReader(bytes.NewReader(pdfData), int64(len(pdfData)))
  	if err != nil {
  		return "", err
  	}

  	var pages []string
  	for pageIndex := 1; pageIndex <= reader.NumPage(); pageIndex++ {
  		pageText, err := reader.Page(pageIndex).GetPlainText(nil)
  		if err != nil {
  			return "", err
  		}
  		pages = append(pages, pageText)
  	}
  	text := strings.Join(pages, "\n")

  	// Supprimer les numéros de page
  	text = regexp.MustCompile(`\n\s*\d+\s*\n`).ReplaceAllString(text, "\n")

  	// Supprimer les espaces superflus
  	text = regexp.MustCompile(`\s+`).ReplaceAllString(text, " ")

  	return text, nil
  }

  // extractDocumentText télécharge l'exemple de contrat de sous-location et en extrait le texte.
  func extractDocumentText() {
  	// Télécharger l'exemple de contrat de sous-location depuis le cookbook de résumé
  	response, err := http.Get("https://raw.githubusercontent.com/anthropics/claude-cookbooks/main/capabilities/summarization/data/Sample%20Sublease%20Agreement.pdf")
  	if err != nil {
  		log.Fatal(err)
  	}
  	defer response.Body.Close()

  	pdfData, err := io.ReadAll(response.Body)
  	if err != nil {
  		log.Fatal(err)
  	}

  	documentText, err = getLLMText(pdfData)
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(documentText[:min(50000, len(documentText))])
  }
  ```

  ```java Java
  import java.io.IOException;
  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;
  import org.apache.pdfbox.Loader;
  import org.apache.pdfbox.pdmodel.PDDocument;
  import org.apache.pdfbox.text.PDFTextStripper;

  // Le texte de l'exemple de contrat de sous-location.
  String documentText;

  String getLlmText(byte[] pdfData) throws IOException {
      try (PDDocument document = Loader.loadPDF(pdfData)) {
          String text = new PDFTextStripper().getText(document);

          // Supprimer les numéros de page.
          text = text.replaceAll("\\n\\s*\\d+\\s*\\n", "\n");

          // Supprimer les espaces superflus.
          return text.replaceAll("\\s+", " ");
      }
  }

  void extractDocumentText() throws IOException, InterruptedException {
      // Télécharger l'exemple de contrat de sous-location depuis le cookbook de résumé.
      HttpRequest request = HttpRequest.newBuilder(URI.create(
                      "https://raw.githubusercontent.com/anthropics/claude-cookbooks/main/capabilities/summarization/data/Sample%20Sublease%20Agreement.pdf"))
              .build();
      byte[] pdfData;
      try (HttpClient httpClient = HttpClient.newHttpClient()) {
          pdfData = httpClient.send(request, HttpResponse.BodyHandlers.ofByteArray()).body();
      }

      documentText = getLlmText(pdfData);
      IO.println(documentText.substring(0, Math.min(50000, documentText.length())));
  }
  ```

  ```php PHP
  use Smalot\PdfParser\Parser;

  $getLlmText = function (string $pdfData): string {
      $document = (new Parser())->parseContent($pdfData);
      $text = implode("\n", array_map(fn ($page) => $page->getText(), $document->getPages()));

      // Supprimer les numéros de page
      $text = preg_replace('/\n\s*\d+\s*\n/', "\n", $text);

      // Supprimer les espaces superflus
      return preg_replace('/\s+/', ' ', $text);
  };

  // Télécharger l'exemple de contrat de sous-location depuis le cookbook de résumé
  $pdfData = file_get_contents(
      'https://raw.githubusercontent.com/anthropics/claude-cookbooks/main/capabilities/summarization/data/Sample%20Sublease%20Agreement.pdf'
  );

  $documentText = $getLlmText($pdfData);
  echo substr($documentText, 0, 50000) . "\n";
  ```

  ```ruby Ruby
  require "net/http"
  require "pdf-reader"
  require "stringio"

  def get_llm_text(pdf_data)
    reader = PDF::Reader.new(StringIO.new(pdf_data))
    text = reader.pages.map(&:text).join("\n")

    # Supprimer les numéros de page
    text = text.gsub(/\n\s*\d+\s*\n/, "\n")

    # Supprimer les espaces superflus
    text.gsub(/\s+/, " ")
  end

  # Télécharger l'exemple de contrat de sous-location depuis le cookbook de résumé
  pdf_data = Net::HTTP.get(
    URI("https://raw.githubusercontent.com/anthropics/claude-cookbooks/main/capabilities/summarization/data/Sample%20Sublease%20Agreement.pdf")
  )

  document_text = get_llm_text(pdf_data)
  puts document_text[0, 50_000]
  ```
</CodeGroup>

Dans cet exemple, vous téléchargez d'abord le PDF d'un exemple de contrat de sous-location utilisé dans le [cookbook de synthèse](https://platform.claude.com/cookbook/capabilities-summarization-guide). Ce contrat provient d'un contrat de sous-location accessible au public sur le [site sec.gov](https://www.sec.gov/Archives/edgar/data/1045425/000119312507044370/dex1032.htm).

L'exemple utilise la bibliothèque `pypdf` (typescript: `pdf-parse`; csharp: `PdfPig`; go: `github.com/ledongthuc/pdf`; java: `org.apache.pdfbox:pdfbox`; php: `smalot/pdfparser`; ruby: `pdf-reader`) pour extraire le contenu du PDF et le convertir en texte. Les données textuelles sont ensuite nettoyées en supprimant les numéros de page et les espaces superflus.

### Construire un prompt solide

Claude peut s'adapter à divers styles de synthèse. Vous pouvez modifier les détails du prompt pour amener Claude à être plus ou moins verbeux, à inclure plus ou moins de terminologie technique, ou à fournir un résumé de plus haut ou de plus bas niveau du contexte en question.

Voici un exemple de création d'un prompt garantissant que les résumés générés suivent une structure cohérente lors de l'analyse de contrats de sous-location :

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Ce flux de travail nécessite plus de logique qu'une seule commande shell. Utilisez le SDK Claude pour l'exécuter.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Ce flux de travail nécessite plus de logique qu'une seule commande shell. Utilisez le SDK Claude pour l'exécuter.
  </CodeGroupItem>

  ```python Python
  # Initialiser le client Anthropic
  client = anthropic.Anthropic()


  def summarize_document(
      text, details_to_extract, model="claude-opus-5-5", max_tokens=16000
  ):
      # Formater les détails à extraire pour les placer dans le contexte du prompt
      details_to_extract_str = "\n".join(details_to_extract)

      # Demander au modèle de résumer le contrat de sous-location
      prompt = f"""Summarize the following sublease agreement. Focus on these key aspects:

      {details_to_extract_str}

      Provide the summary in bullet points nested within the XML header for each section. For example:

      <parties involved>
      - Sublessor: [Name]
      // Add more details as needed
      </parties involved>

      If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.

      Sublease agreement text:
      {text}
      """

      response = client.messages.create(
          model=model,
          max_tokens=max_tokens,
          system="You are a legal analyst specializing in real estate law, known for highly accurate and detailed summaries of sublease agreements.",
          messages=[
              {"role": "user", "content": prompt},
          ],
      )

      return next(block.text for block in response.content if block.type == "text")


  sublease_summary = summarize_document(document_text, details_to_extract)
  print(sublease_summary)
  ```

  ```typescript TypeScript
  // Initialiser le client Anthropic
  const client = new Anthropic();

  async function summarizeDocument(
    text: string,
    detailsToExtract: string[],
    model: Anthropic.Model = "claude-opus-5-5",
    maxTokens = 16000
  ): Promise<string> {
    // Formater les détails à extraire pour les placer dans le contexte du prompt
    const detailsToExtractStr = detailsToExtract.join("\n");

    // Demander au modèle de résumer le contrat de sous-location
    const prompt = `Summarize the following sublease agreement. Focus on these key aspects:

      ${detailsToExtractStr}

      Provide the summary in bullet points nested within the XML header for each section. For example:

      <parties involved>
      - Sublessor: [Name]
      // Add more details as needed
      </parties involved>

      If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.

      Sublease agreement text:
      ${text}
      `;

    const response = await client.messages.create({
      model,
      max_tokens: maxTokens,
      system:
        "You are a legal analyst specializing in real estate law, known for highly accurate and detailed summaries of sublease agreements.",
      messages: [{ role: "user", content: prompt }]
    });

    const textBlock = response.content.find((block) => block.type === "text");
    if (!textBlock) {
      throw new Error("Expected a text block in the response");
    }
    return textBlock.text;
  }

  const subleaseSummary = await summarizeDocument(documentText, detailsToExtract);
  console.log(subleaseSummary);
  ```

  ```csharp C#
  // Initialiser le client Anthropic
  var client = new AnthropicClient();

  async Task<string> SummarizeDocument(
      string text,
      IReadOnlyList<string> detailsToExtract,
      Model model = Model.ClaudeOpus5_5,
      long maxTokens = 16000
  )
  {
      // Formater les détails à extraire pour les placer dans le contexte du prompt
      var detailsToExtractStr = string.Join("\n", detailsToExtract);

      // Demander au modèle de résumer le contrat de sous-location
      var prompt = $"""
          Summarize the following sublease agreement. Focus on these key aspects:

              {detailsToExtractStr}

              Provide the summary in bullet points nested within the XML header for each section. For example:

              <parties involved>
              - Sublessor: [Name]
              // Add more details as needed
              </parties involved>

              If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.

              Sublease agreement text:
              {text}
          """;

      var response = await client.Messages.Create(
          new()
          {
              Model = model,
              MaxTokens = maxTokens,
              System = "You are a legal analyst specializing in real estate law, known for highly accurate and detailed summaries of sublease agreements.",
              Messages = [new() { Role = Role.User, Content = prompt }],
          }
      );

      foreach (var block in response.Content)
      {
          if (block.TryPickText(out var textBlock))
          {
              return textBlock.Text;
          }
      }
      throw new InvalidOperationException("Expected a text block in the response.");
  }

  var subleaseSummary = await SummarizeDocument(documentText, detailsToExtract);
  Console.WriteLine(subleaseSummary);
  ```

  ```go Go
  // Initialiser le client Anthropic
  var client = anthropic.NewClient()

  func summarizeDocument(text string, detailsToExtract []string, model anthropic.Model, maxTokens int64) string {
  	// Formater les détails à extraire pour les placer dans le contexte du prompt
  	detailsToExtractStr := strings.Join(detailsToExtract, "\n")

  	// Demander au modèle de résumer le contrat de sous-location
  	prompt := fmt.Sprintf(`Summarize the following sublease agreement. Focus on these key aspects:

      %s

      Provide the summary in bullet points nested within the XML header for each section. For example:

      <parties involved>
      - Sublessor: [Name]
      // Add more details as needed
      </parties involved>

      If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.

      Sublease agreement text:
      %s
      `, detailsToExtractStr, text)

  	response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  		Model:     model,
  		MaxTokens: maxTokens,
  		System: []anthropic.TextBlockParam{
  			{Text: "You are a legal analyst specializing in real estate law, known for highly accurate and detailed summaries of sublease agreements."},
  		},
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock(prompt)),
  		},
  	})
  	if err != nil {
  		log.Fatal(err)
  	}

  	for _, block := range response.Content {
  		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  			return textBlock.Text
  		}
  	}
  	panic("expected a text block in the response")
  }

  // printSubleaseSummary résume le contrat de sous-location et affiche le résumé.
  func printSubleaseSummary() {
  	subleaseSummary := summarizeDocument(documentText, detailsToExtract, anthropic.ModelClaudeOpus5_5, 16000)
  	fmt.Println(subleaseSummary)
  }
  ```

  ```java Java
  // Initialiser le client Anthropic.
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  String summarizeDocument(String text, List<String> detailsToExtract, Model model, long maxTokens) {
      // Formater les détails à extraire pour les placer dans le contexte du prompt.
      String detailsToExtractStr = String.join("\n", detailsToExtract);

      // Demander au modèle de résumer le contrat de sous-location.
      String prompt = """
              Summarize the following sublease agreement. Focus on these key aspects:

                  %s

                  Provide the summary in bullet points nested within the XML header for each section. For example:

                  <parties involved>
                  - Sublessor: [Name]
                  // Add more details as needed
                  </parties involved>

                  If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.

                  Sublease agreement text:
                  %s
              """
              .formatted(detailsToExtractStr, text);

      Message response = client.messages().create(MessageCreateParams.builder()
              .model(model)
              .maxTokens(maxTokens)
              .system("You are a legal analyst specializing in real estate law, known for highly accurate and detailed summaries of sublease agreements.")
              .addUserMessage(prompt)
              .build());

      return response.content().stream()
              .flatMap(block -> block.text().stream())
              .findFirst()
              .orElseThrow()
              .text();
  }

  void printSubleaseSummary() {
      String subleaseSummary = summarizeDocument(
              documentText, detailsToExtract, Model.CLAUDE_OPUS_5_5, 16000);
      IO.println(subleaseSummary);
  }
  ```

  ```php PHP
  // Initialiser le client Anthropic
  $client = new Client();

  $summarizeDocument = function (
      string $text,
      array $detailsToExtract,
      Model $model = Model::CLAUDE_OPUS_5_5,
      int $maxTokens = 16000,
  ) use ($client): string {
      // Formater les détails à extraire pour les placer dans le contexte du prompt
      $detailsToExtractStr = implode("\n", $detailsToExtract);

      // Demander au modèle de résumer le contrat de sous-location
      $prompt = <<<PROMPT
          Summarize the following sublease agreement. Focus on these key aspects:

              {$detailsToExtractStr}

              Provide the summary in bullet points nested within the XML header for each section. For example:

              <parties involved>
              - Sublessor: [Name]
              // Add more details as needed
              </parties involved>

              If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.

              Sublease agreement text:
              {$text}
          PROMPT;

      $response = $client->messages->create(
          model: $model,
          maxTokens: $maxTokens,
          system: 'You are a legal analyst specializing in real estate law, known for highly accurate and detailed summaries of sublease agreements.',
          messages: [['role' => 'user', 'content' => $prompt]],
      );

      $textBlock = array_find($response->content, fn ($block) => $block instanceof \Anthropic\Messages\TextBlock)
          ?? throw new \RuntimeException('Expected a text block in the response.');

      return $textBlock->text;
  };

  $subleaseSummary = $summarizeDocument($documentText, $detailsToExtract);
  echo $subleaseSummary . "\n";
  ```

  ```ruby Ruby
  # Initialiser le client Anthropic
  CLIENT = Anthropic::Client.new

  def summarize_document(text, details_to_extract, model: Anthropic::Model::CLAUDE_OPUS_5_5, max_tokens: 16_000)
    # Formater les détails à extraire pour les placer dans le contexte du prompt
    details_to_extract_str = details_to_extract.join("\n")

    # Demander au modèle de résumer le contrat de sous-location
    prompt = <<~PROMPT
      Summarize the following sublease agreement. Focus on these key aspects:

          #{details_to_extract_str}

          Provide the summary in bullet points nested within the XML header for each section. For example:

          <parties involved>
          - Sublessor: [Name]
          // Add more details as needed
          </parties involved>

          If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.

          Sublease agreement text:
          #{text}
    PROMPT

    response = CLIENT.messages.create(
      model:,
      max_tokens:,
      system_: "You are a legal analyst specializing in real estate law, known for highly accurate and detailed summaries of sublease agreements.",
      messages: [{role: :user, content: prompt}]
    )

    response.content.find { |block| block.is_a?(Anthropic::Models::TextBlock) }.text
  end

  sublease_summary = summarize_document(document_text, details_to_extract)
  puts sublease_summary
  ```
</CodeGroup>

Ce code implémente une fonction `summarize_document` (typescript, go, java: `summarizeDocument`; php: `$summarizeDocument`; csharp: `SummarizeDocument`) qui utilise Claude pour résumer le contenu d'un contrat de sous-location. La fonction accepte en entrée une chaîne de texte et une liste de détails à extraire. Dans cet exemple, le code appelle la fonction avec les variables `document_text` (typescript, go, java, csharp: `documentText`; php: `$documentText`) et `details_to_extract` (typescript, go, java, csharp: `detailsToExtract`; php: `$detailsToExtract`) qui ont été définies dans les extraits de code précédents.

Au sein de la fonction, un prompt est généré pour Claude, comprenant le document à résumer, les détails à extraire et des instructions spécifiques pour résumer le document. Le prompt demande à Claude de répondre avec un résumé de chaque détail à extraire, imbriqué dans des en-têtes XML.

Comme le code produit chaque section du résumé à l'intérieur de balises, chaque section peut facilement être extraite lors d'une étape de post-traitement. Cette approche permet d'obtenir des résumés structurés adaptables à votre cas d'usage, de sorte que chaque résumé suive le même modèle.

### Évaluer votre prompt

Le prompting nécessite souvent des tests et une optimisation pour être prêt pour la production. Pour déterminer la maturité de votre solution, évaluez la qualité de vos résumés à l'aide d'un processus systématique combinant des méthodes quantitatives et qualitatives. La création d'une [évaluation empirique solide](https://platform.claude.com/docs/fr/test-and-evaluate/develop-tests#build-evaluations) basée sur vos critères de réussite définis vous permet d'optimiser vos prompts. Voici quelques métriques que vous pourriez inclure dans votre évaluation empirique :

<AccordionGroup>
  <Accordion title="Scores ROUGE">
    Cette métrique mesure le chevauchement entre le résumé généré et un résumé de référence créé par un expert. Elle se concentre principalement sur le rappel et est utile pour évaluer la couverture du contenu.
  </Accordion>

  <Accordion title="Scores BLEU">
    Bien qu'initialement développée pour la traduction automatique, cette métrique peut être adaptée aux tâches de synthèse. Les scores BLEU mesurent la précision des correspondances de n-grammes entre le résumé généré et les résumés de référence. Un score plus élevé indique que le résumé généré contient des expressions et une terminologie similaires à celles du résumé de référence. 
  </Accordion>

  <Accordion title="Similarité d'embeddings contextuels">
    Cette métrique consiste à créer des représentations vectorielles, ou « embeddings » (plongements), du résumé généré et du résumé de référence. La similarité entre ces embeddings est ensuite calculée, souvent à l'aide de la similarité cosinus. Des scores de similarité plus élevés indiquent que le résumé généré capture le sens sémantique et le contexte du résumé de référence, même si la formulation exacte diffère.
  </Accordion>

  <Accordion title="Notation basée sur un LLM">
    Cette méthode consiste à utiliser un LLM tel que Claude pour évaluer la qualité des résumés générés par rapport à une grille de notation. La grille peut être adaptée à vos besoins spécifiques, en évaluant des facteurs clés tels que l'exactitude, l'exhaustivité et la cohérence. Pour des conseils d'implémentation, consultez 

    [Conseils pour la notation basée sur un LLM](https://platform.claude.com/docs/fr/test-and-evaluate/develop-tests#tips-for-llm-based-grading)

    .
  </Accordion>

  <Accordion title="Évaluation humaine">
    En plus de créer les résumés de référence, les experts juridiques peuvent également évaluer la qualité des résumés générés. Bien que cela soit coûteux et chronophage à grande échelle, cette évaluation est souvent réalisée sur quelques résumés à titre de contrôle de validation avant le déploiement en production.
  </Accordion>
</AccordionGroup>

### Déployer votre prompt

Voici quelques considérations supplémentaires à garder à l'esprit lorsque vous déployez votre solution en production.

1. **Garantir l'absence de responsabilité :** comprenez les implications juridiques des erreurs dans les résumés, qui pourraient engager la responsabilité juridique de votre organisation ou de vos clients. Fournissez des avertissements ou des mentions légales précisant que les résumés sont générés par une IA et doivent être examinés par des professionnels du droit.

2. **Gérer divers types de documents :** ce guide explique comment extraire du texte à partir de PDF. Dans le monde réel, les documents peuvent se présenter sous divers formats (tels que des PDF, des documents Word et des fichiers texte). Assurez-vous que votre pipeline d'extraction de données peut convertir tous les formats de fichiers que vous prévoyez de recevoir.

3. **Paralléliser les appels API vers Claude :** les documents longs comportant un grand nombre de tokens peuvent nécessiter jusqu'à une minute pour que Claude génère un résumé. Pour les grandes collections de documents, vous pourriez vouloir envoyer les appels API à Claude en parallèle afin que les résumés puissent être réalisés dans un délai raisonnable. Reportez-vous aux [limites de débit](https://platform.claude.com/docs/fr/api/rate-limits#rate-limits) d'Anthropic pour déterminer le nombre maximal d'appels API pouvant être effectués en parallèle.

***

## Améliorer les performances

Dans des scénarios complexes, il peut être utile d'envisager des stratégies supplémentaires pour améliorer les performances au-delà des [techniques de « prompt engineering » (ingénierie de prompt)](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/overview) standard. Voici quelques stratégies avancées :

### Effectuer une méta-synthèse pour résumer de longs documents

La synthèse juridique implique souvent de traiter de longs documents ou de nombreux documents connexes à la fois, au point de dépasser la « context window » (fenêtre de contexte) de Claude. Vous pouvez utiliser une méthode de découpage appelée « meta-summarization » (méta-synthèse) pour gérer ce cas d'usage. Cette technique consiste à décomposer les documents en morceaux plus petits et gérables, puis à traiter chaque morceau séparément. Vous pouvez ensuite combiner les résumés de chaque morceau pour créer un méta-résumé de l'ensemble du document.

Voici un exemple de réalisation d'une méta-synthèse :

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Ce flux de travail nécessite plus de logique qu'une seule commande shell. Utilisez le SDK Claude pour l'exécuter.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Ce flux de travail nécessite plus de logique qu'une seule commande shell. Utilisez le SDK Claude pour l'exécuter.
  </CodeGroupItem>

  ```python Python
  def chunk_text(text, chunk_size=20000):
      return [text[i : i + chunk_size] for i in range(0, len(text), chunk_size)]


  def summarize_long_document(
      text, details_to_extract, model="claude-opus-5-5", max_tokens=16000
  ):
      # Formater les détails à extraire pour les placer dans le contexte du prompt
      details_to_extract_str = "\n".join(details_to_extract)

      # Parcourir les segments et résumer chacun d'eux
      chunk_summaries = [
          summarize_document(
              chunk, details_to_extract, model=model, max_tokens=max_tokens
          )
          for chunk in chunk_text(text)
      ]

      final_summary_prompt = f"""

      You are looking at the chunked summaries of multiple documents that are all related.
      Combine the following summaries of the document from different truthful sources into a coherent overall summary:

      <chunked_summaries>
      {"".join(chunk_summaries)}
      </chunked_summaries>

      Focus on these key aspects:
      {details_to_extract_str}

      Provide the summary in bullet points nested within the XML header for each section. For example:

      <parties involved>
      - Sublessor: [Name]
      // Add more details as needed
      </parties involved>

      If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.
      """

      response = client.messages.create(
          model=model,
          max_tokens=max_tokens,
          system="You are a legal expert that summarizes notes on one document.",
          messages=[
              {"role": "user", "content": final_summary_prompt},
          ],
      )

      return next(block.text for block in response.content if block.type == "text")


  long_summary = summarize_long_document(document_text, details_to_extract)
  print(long_summary)
  ```

  ```typescript TypeScript
  function chunkText(text: string, chunkSize = 20000): string[] {
    return Array.from({ length: Math.ceil(text.length / chunkSize) }, (_, index) =>
      text.slice(index * chunkSize, (index + 1) * chunkSize)
    );
  }

  async function summarizeLongDocument(
    text: string,
    detailsToExtract: string[],
    model: Anthropic.Model = "claude-opus-5-5",
    maxTokens = 16000
  ): Promise<string> {
    // Formater les détails à extraire pour les placer dans le contexte du prompt
    const detailsToExtractStr = detailsToExtract.join("\n");

    // Parcourir les segments et résumer chacun d'eux
    const chunkSummaries: string[] = [];
    for (const chunk of chunkText(text)) {
      chunkSummaries.push(await summarizeDocument(chunk, detailsToExtract, model, maxTokens));
    }

    const finalSummaryPrompt = `

      You are looking at the chunked summaries of multiple documents that are all related.
      Combine the following summaries of the document from different truthful sources into a coherent overall summary:

      <chunked_summaries>
      ${chunkSummaries.join("")}
      </chunked_summaries>

      Focus on these key aspects:
      ${detailsToExtractStr}

      Provide the summary in bullet points nested within the XML header for each section. For example:

      <parties involved>
      - Sublessor: [Name]
      // Add more details as needed
      </parties involved>

      If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.
      `;

    const response = await client.messages.create({
      model,
      max_tokens: maxTokens,
      system: "You are a legal expert that summarizes notes on one document.",
      messages: [{ role: "user", content: finalSummaryPrompt }]
    });

    const textBlock = response.content.find((block) => block.type === "text");
    if (!textBlock) {
      throw new Error("Expected a text block in the response");
    }
    return textBlock.text;
  }

  const longSummary = await summarizeLongDocument(documentText, detailsToExtract);
  console.log(longSummary);
  ```

  ```csharp C#
  IEnumerable<string> ChunkText(string text, int chunkSize = 20000) =>
      text.Chunk(chunkSize).Select(chars => new string(chars));

  async Task<string> SummarizeLongDocument(
      string text,
      IReadOnlyList<string> detailsToExtract,
      Model model = Model.ClaudeOpus5_5,
      long maxTokens = 16000
  )
  {
      // Formater les détails à extraire pour les placer dans le contexte du prompt
      var detailsToExtractStr = string.Join("\n", detailsToExtract);

      // Parcourir les segments et résumer chacun d'eux
      List<string> chunkSummaries = [];
      foreach (var chunk in ChunkText(text))
      {
          chunkSummaries.Add(await SummarizeDocument(chunk, detailsToExtract, model, maxTokens));
      }

      var finalSummaryPrompt = $"""

              You are looking at the chunked summaries of multiple documents that are all related.
              Combine the following summaries of the document from different truthful sources into a coherent overall summary:

              <chunked_summaries>
              {string.Concat(chunkSummaries)}
              </chunked_summaries>

              Focus on these key aspects:
              {detailsToExtractStr}

              Provide the summary in bullet points nested within the XML header for each section. For example:

              <parties involved>
              - Sublessor: [Name]
              // Add more details as needed
              </parties involved>

              If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.
          """;

      var response = await client.Messages.Create(
          new()
          {
              Model = model,
              MaxTokens = maxTokens,
              System = "You are a legal expert that summarizes notes on one document.",
              Messages = [new() { Role = Role.User, Content = finalSummaryPrompt }],
          }
      );

      foreach (var block in response.Content)
      {
          if (block.TryPickText(out var textBlock))
          {
              return textBlock.Text;
          }
      }
      throw new InvalidOperationException("Expected a text block in the response.");
  }

  var longSummary = await SummarizeLongDocument(documentText, detailsToExtract);
  Console.WriteLine(longSummary);
  ```

  ```go Go
  func chunkText(text string, chunkSize int) []string {
  	var chunks []string
  	for chunk := range slices.Chunk([]rune(text), chunkSize) {
  		chunks = append(chunks, string(chunk))
  	}
  	return chunks
  }

  func summarizeLongDocument(text string, detailsToExtract []string, model anthropic.Model, maxTokens int64) string {
  	// Formater les détails à extraire pour les placer dans le contexte du prompt
  	detailsToExtractStr := strings.Join(detailsToExtract, "\n")

  	// Parcourir les segments et résumer chacun d'eux
  	var chunkSummaries []string
  	for _, chunk := range chunkText(text, 20000) {
  		chunkSummaries = append(chunkSummaries, summarizeDocument(chunk, detailsToExtract, model, maxTokens))
  	}

  	finalSummaryPrompt := fmt.Sprintf(`

      You are looking at the chunked summaries of multiple documents that are all related.
      Combine the following summaries of the document from different truthful sources into a coherent overall summary:

      <chunked_summaries>
      %s
      </chunked_summaries>

      Focus on these key aspects:
      %s

      Provide the summary in bullet points nested within the XML header for each section. For example:

      <parties involved>
      - Sublessor: [Name]
      // Add more details as needed
      </parties involved>

      If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.
      `, strings.Join(chunkSummaries, ""), detailsToExtractStr)

  	response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  		Model:     model,
  		MaxTokens: maxTokens,
  		System: []anthropic.TextBlockParam{
  			{Text: "You are a legal expert that summarizes notes on one document."},
  		},
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock(finalSummaryPrompt)),
  		},
  	})
  	if err != nil {
  		log.Fatal(err)
  	}

  	for _, block := range response.Content {
  		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  			return textBlock.Text
  		}
  	}
  	panic("expected a text block in the response")
  }

  // printLongSummary résume le contrat de sous-location segment par segment et affiche le résumé combiné.
  func printLongSummary() {
  	longSummary := summarizeLongDocument(documentText, detailsToExtract, anthropic.ModelClaudeOpus5_5, 16000)
  	fmt.Println(longSummary)
  }
  ```

  ```java Java
  List<String> chunkText(String text, int chunkSize) {
      return IntStream.iterate(0, start -> start < text.length(), start -> start + chunkSize)
              .mapToObj(start -> text.substring(start, Math.min(start + chunkSize, text.length())))
              .toList();
  }

  String summarizeLongDocument(String text, List<String> detailsToExtract, Model model, long maxTokens) {
      // Formater les détails à extraire pour les placer dans le contexte du prompt.
      String detailsToExtractStr = String.join("\n", detailsToExtract);

      // Parcourir les segments et résumer chacun d'eux.
      String chunkSummaries = chunkText(text, 20000).stream()
              .map(chunk -> summarizeDocument(chunk, detailsToExtract, model, maxTokens))
              .collect(Collectors.joining());

      String finalSummaryPrompt = """

                  You are looking at the chunked summaries of multiple documents that are all related.
                  Combine the following summaries of the document from different truthful sources into a coherent overall summary:

                  <chunked_summaries>
                  %s
                  </chunked_summaries>

                  Focus on these key aspects:
                  %s

                  Provide the summary in bullet points nested within the XML header for each section. For example:

                  <parties involved>
                  - Sublessor: [Name]
                  // Add more details as needed
                  </parties involved>

                  If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.
              """
              .formatted(chunkSummaries, detailsToExtractStr);

      Message response = client.messages().create(MessageCreateParams.builder()
              .model(model)
              .maxTokens(maxTokens)
              .system("You are a legal expert that summarizes notes on one document.")
              .addUserMessage(finalSummaryPrompt)
              .build());

      return response.content().stream()
              .flatMap(block -> block.text().stream())
              .findFirst()
              .orElseThrow()
              .text();
  }

  void printLongSummary() {
      String longSummary = summarizeLongDocument(
              documentText, detailsToExtract, Model.CLAUDE_OPUS_5_5, 16000);
      IO.println(longSummary);
  }
  ```

  ```php PHP
  $chunkText = fn (string $text, int $chunkSize = 20000): array => mb_str_split($text, $chunkSize);

  $summarizeLongDocument = function (
      string $text,
      array $detailsToExtract,
      Model $model = Model::CLAUDE_OPUS_5_5,
      int $maxTokens = 16000,
  ) use ($client, $chunkText, $summarizeDocument): string {
      // Formater les détails à extraire pour les placer dans le contexte du prompt
      $detailsToExtractStr = implode("\n", $detailsToExtract);

      // Parcourir les segments et résumer chacun d'eux
      $chunkSummaries = array_map(
          fn (string $chunk) => $summarizeDocument($chunk, $detailsToExtract, $model, $maxTokens),
          $chunkText($text),
      );
      $chunkSummariesStr = implode('', $chunkSummaries);

      $finalSummaryPrompt = <<<PROMPT

              You are looking at the chunked summaries of multiple documents that are all related.
              Combine the following summaries of the document from different truthful sources into a coherent overall summary:

              <chunked_summaries>
              {$chunkSummariesStr}
              </chunked_summaries>

              Focus on these key aspects:
              {$detailsToExtractStr}

              Provide the summary in bullet points nested within the XML header for each section. For example:

              <parties involved>
              - Sublessor: [Name]
              // Add more details as needed
              </parties involved>

              If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.
          PROMPT;

      $response = $client->messages->create(
          model: $model,
          maxTokens: $maxTokens,
          system: 'You are a legal expert that summarizes notes on one document.',
          messages: [['role' => 'user', 'content' => $finalSummaryPrompt]],
      );

      $textBlock = array_find($response->content, fn ($block) => $block instanceof \Anthropic\Messages\TextBlock)
          ?? throw new \RuntimeException('Expected a text block in the response.');

      return $textBlock->text;
  };

  $longSummary = $summarizeLongDocument($documentText, $detailsToExtract);
  echo $longSummary . "\n";
  ```

  ```ruby Ruby
  def chunk_text(text, chunk_size: 20_000)
    text.chars.each_slice(chunk_size).map(&:join)
  end

  def summarize_long_document(text, details_to_extract, model: Anthropic::Model::CLAUDE_OPUS_5_5, max_tokens: 16_000)
    # Formater les détails à extraire pour les placer dans le contexte du prompt
    details_to_extract_str = details_to_extract.join("\n")

    # Parcourir les segments et résumer chacun d'eux
    chunk_summaries = chunk_text(text).map do |chunk|
      summarize_document(chunk, details_to_extract, model:, max_tokens:)
    end

    final_summary_prompt = <<~PROMPT

          You are looking at the chunked summaries of multiple documents that are all related.
          Combine the following summaries of the document from different truthful sources into a coherent overall summary:

          <chunked_summaries>
          #{chunk_summaries.join}
          </chunked_summaries>

          Focus on these key aspects:
          #{details_to_extract_str}

          Provide the summary in bullet points nested within the XML header for each section. For example:

          <parties involved>
          - Sublessor: [Name]
          // Add more details as needed
          </parties involved>

          If any information is not explicitly stated in the document, note it as "Not specified". Do not preamble.
    PROMPT

    response = CLIENT.messages.create(
      model:,
      max_tokens:,
      system_: "You are a legal expert that summarizes notes on one document.",
      messages: [{role: :user, content: final_summary_prompt}]
    )

    response.content.find { |block| block.is_a?(Anthropic::Models::TextBlock) }.text
  end

  long_summary = summarize_long_document(document_text, details_to_extract)
  puts long_summary
  ```
</CodeGroup>

La fonction `summarize_long_document` (typescript, go, java: `summarizeLongDocument`; php: `$summarizeLongDocument`; csharp: `SummarizeLongDocument`) s'appuie sur la fonction `summarize_document` (typescript, go, java: `summarizeDocument`; php: `$summarizeDocument`; csharp: `SummarizeDocument`) précédente en divisant le document en morceaux plus petits et en résumant chaque morceau individuellement.

Le code y parvient en appliquant la fonction `summarize_document` (typescript, go, java: `summarizeDocument`; php: `$summarizeDocument`; csharp: `SummarizeDocument`) à chaque morceau de 20 000 caractères du document original. Les résumés individuels sont ensuite combinés, et un résumé final est créé à partir de ces résumés de morceaux.

Notez que la fonction `summarize_long_document` (typescript, go, java: `summarizeLongDocument`; php: `$summarizeLongDocument`; csharp: `SummarizeLongDocument`) n'est pas strictement nécessaire pour le PDF d'exemple, car l'ensemble du document tient dans la fenêtre de contexte de Claude. Cependant, elle devient essentielle pour les documents dépassant la fenêtre de contexte de Claude ou lors de la synthèse conjointe de plusieurs documents connexes. Quoi qu'il en soit, cette technique de méta-synthèse capture souvent dans le résumé final des détails importants supplémentaires qui avaient été omis par l'approche précédente à résumé unique.

### Utiliser des documents indexés par résumé pour explorer une grande collection de documents

La recherche dans une collection de documents avec un LLM implique généralement la « retrieval-augmented generation » (génération augmentée par récupération), ou RAG. Cependant, dans des scénarios impliquant de grands documents ou lorsque la récupération précise d'informations est cruciale, une approche RAG basique peut être insuffisante. Les « summary indexed documents » (documents indexés par résumé) constituent une approche RAG avancée qui offre un moyen plus efficace de classer les documents pour la récupération, en utilisant moins de contexte que les méthodes RAG traditionnelles. Dans cette approche, vous utilisez d'abord Claude pour générer un résumé concis de chaque document de votre corpus, puis vous utilisez Claude pour classer la pertinence de chaque résumé par rapport à la requête posée. Pour plus de détails sur cette approche, y compris un exemple basé sur du code, consultez la section sur les documents indexés par résumé dans le [cookbook de synthèse](https://platform.claude.com/cookbook/capabilities-summarization-guide).

### Effectuer un fine-tuning de Claude pour apprendre de votre jeu de données

Une autre technique avancée pour améliorer la capacité de Claude à générer des résumés est le « fine-tuning » (ajustement fin). Le fine-tuning consiste à entraîner Claude sur un jeu de données personnalisé qui correspond spécifiquement à vos besoins de synthèse juridique, garantissant que Claude s'adapte à votre cas d'usage. Voici un aperçu de la manière d'effectuer un fine-tuning :

1. **Identifier les erreurs :** commencez par collecter les cas où les résumés de Claude sont insuffisants — cela peut inclure l'omission de détails juridiques critiques, une mauvaise compréhension du contexte ou l'utilisation d'une terminologie juridique inappropriée.

2. **Constituer un jeu de données :** une fois ces problèmes identifiés, compilez un jeu de données de ces exemples problématiques. Ce jeu de données doit inclure les documents juridiques originaux accompagnés de vos résumés corrigés, garantissant que Claude apprenne le comportement souhaité.

3. **Effectuer le fine-tuning :** le fine-tuning consiste à réentraîner le modèle sur votre jeu de données constitué afin d'ajuster ses poids et ses paramètres. Ce réentraînement aide Claude à mieux s'adapter aux exigences spécifiques de votre domaine juridique, améliorant sa capacité à résumer des documents selon vos normes.

4. **Amélioration itérative :** le fine-tuning n'est pas un processus ponctuel. À mesure que Claude continue de générer des résumés, vous pouvez ajouter de manière itérative de nouveaux exemples où il a sous-performé, affinant davantage ses capacités. Au fil du temps, cette boucle de rétroaction continue aboutira à un modèle hautement spécialisé pour vos tâches de synthèse juridique.

<Tip>
  Le fine-tuning n'est actuellement disponible que via Amazon Bedrock. Des détails supplémentaires sont disponibles dans le 

  [blog de lancement AWS](https://aws.amazon.com/blogs/machine-learning/fine-tune-anthropics-claude-3-haiku-in-amazon-bedrock-to-boost-model-accuracy-and-quality/)

  .
</Tip>

<CardGroup cols={2}>
  <Card title="Cookbook de synthèse" icon="link" href="https://platform.claude.com/cookbook/capabilities-summarization-guide">
    Consultez un exemple de code entièrement implémenté montrant comment utiliser Claude pour résumer des contrats.
  </Card>

  <Card title="Cookbook sur les citations" icon="link" href="https://platform.claude.com/cookbook/misc-using-citations">
    Explorez la recette du cookbook sur les citations pour obtenir des conseils sur la manière de garantir l'exactitude et l'explicabilité des informations.
  </Card>
</CardGroup>