---
title: Sintesi di documenti legali
url: https://platform.claude.com/docs/it/about-claude/use-case-guides/legal-summarization
description: Questa guida illustra come sfruttare le avanzate capacità di elaborazione del linguaggio naturale di Claude per sintetizzare in modo efficiente documenti legali, estraendo le informazioni chiave e accelerando la ricerca giuridica. Con Claude puoi semplificare la revisione dei contratti, la preparazione dei contenziosi e il lavoro normativo, risparmiando tempo e garantendo accuratezza nei tuoi processi legali.
---

> Visita il [cookbook sulla sintesi](https://platform.claude.com/cookbook/capabilities-summarization-guide) per vedere un esempio di implementazione della sintesi di documenti legali con Claude.

## Prima di sviluppare con Claude

### Decidi se usare Claude per la sintesi di documenti legali

Ecco alcuni indicatori chiave che suggeriscono di impiegare un "large language model" (grande modello linguistico), o LLM, come Claude per sintetizzare documenti legali:

<AccordionGroup>
  <Accordion title="Vuoi esaminare un elevato volume di documenti in modo efficiente ed economico">
    La revisione di documenti su larga scala può richiedere molto tempo ed essere costosa se eseguita manualmente. Claude può elaborare e sintetizzare rapidamente grandi quantità di documenti legali, riducendo significativamente i tempi e i costi associati alla revisione documentale. Questa capacità è particolarmente preziosa per attività come la due diligence, l'analisi dei contratti o la discovery nei contenziosi, dove l'efficienza è fondamentale.
  </Accordion>

  <Accordion title="Hai bisogno dell'estrazione automatizzata dei metadati chiave">
    Claude può estrarre e categorizzare in modo efficiente metadati importanti dai documenti legali, come le parti coinvolte, le date, i termini contrattuali o clausole specifiche. Questa estrazione automatizzata può aiutare a organizzare le informazioni, rendendo più semplice cercare, analizzare e gestire grandi insiemi di documenti. È particolarmente utile per la gestione dei contratti, le verifiche di conformità o la creazione di database consultabili di informazioni legali. 
  </Accordion>

  <Accordion title="Vuoi generare sintesi chiare, concise e standardizzate">
    Claude può generare sintesi strutturate che seguono formati predeterminati, rendendo più facile per i professionisti legali cogliere rapidamente i punti chiave di vari documenti. Queste sintesi standardizzate possono migliorare la leggibilità, facilitare il confronto tra documenti e migliorare la comprensione complessiva, soprattutto quando si ha a che fare con un linguaggio giuridico complesso o con gergo tecnico.
  </Accordion>

  <Accordion title="Hai bisogno di citazioni precise per le tue sintesi">
    Quando si creano sintesi legali, l'attribuzione e la citazione corrette sono fondamentali per garantire credibilità e conformità agli standard legali. È possibile istruire Claude affinché includa citazioni accurate per tutti i punti giuridici a cui fa riferimento, rendendo più semplice per i professionisti legali rivedere e verificare le informazioni sintetizzate.
  </Accordion>

  <Accordion title="Vuoi semplificare e accelerare il tuo processo di ricerca giuridica">
    Claude può assistere nella ricerca giuridica analizzando rapidamente grandi volumi di giurisprudenza, leggi e commenti giuridici. Può identificare precedenti rilevanti, estrarre principi giuridici chiave e sintetizzare argomentazioni legali complesse. Questa capacità può accelerare significativamente il processo di ricerca, consentendo ai professionisti legali di concentrarsi su analisi di livello superiore e sullo sviluppo della strategia.
  </Accordion>
</AccordionGroup>

### Determina i dettagli che vuoi che la sintesi estragga

Non esiste un'unica sintesi corretta per un dato documento. Senza indicazioni chiare, può essere difficile per Claude determinare quali dettagli includere. Per ottenere risultati ottimali, identifica le informazioni specifiche che vuoi includere nella sintesi.

Ad esempio, quando sintetizzi un contratto di sublocazione, potresti voler estrarre i seguenti punti chiave:

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

### Stabilisci i criteri di successo

Valutare la qualità delle sintesi è un compito notoriamente impegnativo. A differenza di molte altre attività di elaborazione del linguaggio naturale, la valutazione delle sintesi spesso manca di metriche nette e oggettive. Il processo può essere altamente soggettivo, con lettori diversi che attribuiscono valore ad aspetti diversi di una sintesi. Ecco alcuni criteri che potresti voler considerare nel valutare quanto bene Claude esegue la sintesi di documenti legali.

<AccordionGroup>
  <Accordion title="Correttezza fattuale">
    La sintesi deve rappresentare accuratamente i fatti, i concetti giuridici e i punti chiave del documento.
  </Accordion>

  <Accordion title="Precisione giuridica">
    La terminologia e i riferimenti a leggi, giurisprudenza o regolamenti devono essere corretti e allineati agli standard legali.
  </Accordion>

  <Accordion title="Concisione">
     La sintesi deve condensare il documento legale nei suoi punti essenziali senza perdere dettagli importanti.
  </Accordion>

  <Accordion title="Coerenza">
    Se si sintetizzano più documenti, l'LLM deve mantenere una struttura e un approccio coerenti per ciascuna sintesi.
  </Accordion>

  <Accordion title="Leggibilità">
    Il testo deve essere chiaro e facile da comprendere. Se il pubblico non è composto da esperti legali, la sintesi non deve includere gergo giuridico che potrebbe confondere i lettori.
  </Accordion>

  <Accordion title="Imparzialità ed equità">
    La sintesi deve presentare una rappresentazione imparziale ed equa delle argomentazioni e delle posizioni legali.
  </Accordion>
</AccordionGroup>

Consulta la guida su come [stabilire i criteri di successo](https://platform.claude.com/docs/it/test-and-evaluate/develop-tests) per maggiori informazioni.

***

## Come sintetizzare documenti legali con Claude

### Seleziona il modello Claude giusto

L'accuratezza del modello è estremamente importante quando si sintetizzano documenti legali. Claude Opus 5.5 è una scelta eccellente per casi d'uso come questo, in cui è richiesta un'elevata accuratezza. Se la dimensione e la quantità dei tuoi documenti sono tali che i costi iniziano a diventare un problema, puoi anche provare a usare un modello più piccolo come Claude Haiku 5.5.

Per aiutarti a stimare questi costi, ecco un confronto del costo per sintetizzare 1.000 contratti di sublocazione usando i modelli Opus e Haiku:

* **Dimensione del contenuto**

  * Numero di contratti: 1.000
  * Caratteri per contratto: 300.000
  * Caratteri totali: 300M

* **Token stimati**

  * Token di input: 108M, circa 108.000 per contratto (circa 1 token ogni 2,8 caratteri, il rapporto che entrambi i modelli hanno mostrato sul contratto di esempio di questa guida)
  * Token di output per sintesi, inclusi eventuali token di "thinking" (ragionamento), che vengono fatturati come output: circa 6.200 su Claude Opus 5.5 e 3.100 su Claude Haiku 5.5
  * Token di output totali: 6,2M su Claude Opus 5.5 e 3,1M su Claude Haiku 5.5

* **Costo stimato di Claude Opus 5.5**

  * Costo dei token di input: 108 MTok \* $4,00/MTok = $432,00 USD
  * Costo dei token di output: 6,2 MTok \* $20,00/MTok = $124,00 USD
  * Costo totale: $432,00 + $124,00 = $556,00 USD

* **Costo stimato di Claude Haiku 5.5**, ai suoi prezzi per prompt superiori a 100.000 token

  * Costo dei token di input: 108 MTok \* $0,50/MTok = $54,00 USD
  * Costo dei token di output: 3,1 MTok \* $2,50/MTok = $7,75 USD
  * Costo totale: $54,00 + $7,75 = $61,75 USD

<Tip>
  I costi effettivi possono differire da queste stime. I conteggi dei token derivano dall'esecuzione dell'esempio nella sezione 

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

   sul contratto di esempio di questa guida, circa 105.000 token di input, e la lunghezza dell'output varia in base al documento e da un'esecuzione all'altra. Ogni contratto qui è un singolo prompt di circa 108.000 token, oltre la soglia di 100.000 token dei 

  [prezzi per prompt lunghi](https://platform.claude.com/docs/it/about-claude/pricing#long-context-pricing)

   di Claude Haiku 5.5. Un documento il cui prompt resta pari o inferiore a 100.000 token paga invece $0,10/MTok per l'input e $0,50/MTok per l'output. Per vedere quali prezzi si applicano, conta i token dei tuoi documenti con il 

  [conteggio dei token](https://platform.claude.com/docs/it/build-with-claude/token-counting)

   e 

  `model`

   impostato su 

  `claude-haiku-5-5`

  .
</Tip>

### Trasforma i documenti in un formato che Claude possa elaborare

Prima di iniziare a sintetizzare i documenti, devi preparare i tuoi dati. Ciò comporta l'estrazione del testo dai PDF, la pulizia del testo e la verifica che sia pronto per essere elaborato da Claude.

Ecco una dimostrazione di questo processo su un PDF di esempio:

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Estrai il testo dal PDF nel codice.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Estrai il testo dal PDF nel codice.
  </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])

      # Rimuovi i numeri di pagina
      text = re.sub(r"\n\s*\d+\s*\n", "\n", text)

      # Rimuovi gli spazi bianchi in eccesso
      text = re.sub(r"\s+", " ", text)

      return text


  # Crea l'URL completo dal repository GitHub
  url = "https://raw.githubusercontent.com/anthropics/claude-cookbooks/main/capabilities/summarization/data/Sample Sublease Agreement.pdf"
  url = url.replace(" ", "%20")

  # Scarica il file PDF in memoria
  response = requests.get(url)

  # Carica il PDF dalla memoria
  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");

    // Rimuovi i numeri di pagina
    text = text.replace(/\n\s*\d+\s*\n/g, "\n");

    // Rimuovi gli spazi bianchi in eccesso
    text = text.replace(/\s+/g, " ");

    return text;
  }

  // Scarica il contratto di sublocazione di esempio dal cookbook sul riassunto
  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)));

      // Rimuovi i numeri di pagina
      text = Regex.Replace(text, @"\n\s*\d+\s*\n", "\n");

      // Rimuovi gli spazi bianchi in eccesso
      text = Regex.Replace(text, @"\s+", " ");

      return text;
  }

  // Scarica il contratto di sublocazione di esempio dal cookbook sul riassunto
  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"
  )

  // Il testo del contratto di sublocazione di esempio
  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")

  	// Rimuovi i numeri di pagina
  	text = regexp.MustCompile(`\n\s*\d+\s*\n`).ReplaceAllString(text, "\n")

  	// Rimuovi gli spazi bianchi in eccesso
  	text = regexp.MustCompile(`\s+`).ReplaceAllString(text, " ")

  	return text, nil
  }

  // extractDocumentText scarica il contratto di sublocazione di esempio e ne estrae il testo.
  func extractDocumentText() {
  	// Scarica il contratto di sublocazione di esempio dal cookbook sul riassunto
  	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;

  // Il testo del contratto di sublocazione di esempio
  String documentText;

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

          // Rimuovi i numeri di pagina
          text = text.replaceAll("\\n\\s*\\d+\\s*\\n", "\n");

          // Rimuovi gli spazi bianchi in eccesso
          return text.replaceAll("\\s+", " ");
      }
  }

  void extractDocumentText() throws IOException, InterruptedException {
      // Scarica il contratto di sublocazione di esempio dal cookbook sul riassunto
      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()));

      // Rimuovi i numeri di pagina
      $text = preg_replace('/\n\s*\d+\s*\n/', "\n", $text);

      // Rimuovi gli spazi bianchi in eccesso
      return preg_replace('/\s+/', ' ', $text);
  };

  // Scarica il contratto di sublocazione di esempio dal cookbook sul riassunto
  $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")

    # Rimuovi i numeri di pagina
    text = text.gsub(/\n\s*\d+\s*\n/, "\n")

    # Rimuovi gli spazi bianchi in eccesso
    text.gsub(/\s+/, " ")
  end

  # Scarica il contratto di sublocazione di esempio dal cookbook sul riassunto
  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>

In questo esempio, scarichi innanzitutto un PDF di un contratto di sublocazione di esempio utilizzato nel [cookbook sulla sintesi](https://platform.claude.com/cookbook/capabilities-summarization-guide). Questo contratto proviene da un contratto di sublocazione disponibile pubblicamente sul [sito sec.gov](https://www.sec.gov/Archives/edgar/data/1045425/000119312507044370/dex1032.htm).

L'esempio usa la libreria `pypdf` (typescript: `pdf-parse`; csharp: `PdfPig`; go: `github.com/ledongthuc/pdf`; java: `org.apache.pdfbox:pdfbox`; php: `smalot/pdfparser`; ruby: `pdf-reader`) per estrarre il contenuto del PDF e convertirlo in testo. I dati testuali vengono poi puliti rimuovendo i numeri di pagina e gli spazi bianchi superflui.

### Costruisci un prompt efficace

Claude può adattarsi a vari stili di sintesi. Puoi modificare i dettagli del prompt per guidare Claude a essere più o meno prolisso, a includere più o meno terminologia tecnica, o a fornire una sintesi di livello più alto o più basso del contesto in questione.

Ecco un esempio di come creare un prompt che garantisca che le sintesi generate seguano una struttura coerente nell'analisi dei contratti di sublocazione:

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il Claude SDK per eseguirlo.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il Claude SDK per eseguirlo.
  </CodeGroupItem>

  ```python Python
  # Inizializza il client Anthropic
  client = anthropic.Anthropic()


  def summarize_document(
      text, details_to_extract, model="claude-opus-5-5", max_tokens=16000
  ):
      # Formatta i dettagli da estrarre da inserire nel contesto del prompt
      details_to_extract_str = "\n".join(details_to_extract)

      # Chiedi al modello di riassumere il contratto di sublocazione
      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
  // Inizializza il client Anthropic
  const client = new Anthropic();

  async function summarizeDocument(
    text: string,
    detailsToExtract: string[],
    model: Anthropic.Model = "claude-opus-5-5",
    maxTokens = 16000
  ): Promise<string> {
    // Formatta i dettagli da estrarre da inserire nel contesto del prompt
    const detailsToExtractStr = detailsToExtract.join("\n");

    // Chiedi al modello di riassumere il contratto di sublocazione
    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#
  // Inizializza il client Anthropic
  var client = new AnthropicClient();

  async Task<string> SummarizeDocument(
      string text,
      IReadOnlyList<string> detailsToExtract,
      Model model = Model.ClaudeOpus5_5,
      long maxTokens = 16000
  )
  {
      // Formatta i dettagli da estrarre da inserire nel contesto del prompt
      var detailsToExtractStr = string.Join("\n", detailsToExtract);

      // Chiedi al modello di riassumere il contratto di sublocazione
      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
  // Inizializza il client Anthropic
  var client = anthropic.NewClient()

  func summarizeDocument(text string, detailsToExtract []string, model anthropic.Model, maxTokens int64) string {
  	// Formatta i dettagli da estrarre da inserire nel contesto del prompt
  	detailsToExtractStr := strings.Join(detailsToExtract, "\n")

  	// Chiedi al modello di riassumere il contratto di sublocazione
  	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 riassume il contratto di sublocazione e stampa il riassunto.
  func printSubleaseSummary() {
  	subleaseSummary := summarizeDocument(documentText, detailsToExtract, anthropic.ModelClaudeOpus5_5, 16000)
  	fmt.Println(subleaseSummary)
  }
  ```

  ```java Java
  // Inizializza il client Anthropic
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  String summarizeDocument(String text, List<String> detailsToExtract, Model model, long maxTokens) {
      // Formatta i dettagli da estrarre da inserire nel contesto del prompt
      String detailsToExtractStr = String.join("\n", detailsToExtract);

      // Chiedi al modello di riassumere il contratto di sublocazione
      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
  // Inizializza il client Anthropic
  $client = new Client();

  $summarizeDocument = function (
      string $text,
      array $detailsToExtract,
      Model $model = Model::CLAUDE_OPUS_5_5,
      int $maxTokens = 16000,
  ) use ($client): string {
      // Formatta i dettagli da estrarre da inserire nel contesto del prompt
      $detailsToExtractStr = implode("\n", $detailsToExtract);

      // Chiedi al modello di riassumere il contratto di sublocazione
      $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
  # Inizializza il client Anthropic
  CLIENT = Anthropic::Client.new

  def summarize_document(text, details_to_extract, model: Anthropic::Model::CLAUDE_OPUS_5_5, max_tokens: 16_000)
    # Formatta i dettagli da estrarre da inserire nel contesto del prompt
    details_to_extract_str = details_to_extract.join("\n")

    # Chiedi al modello di riassumere il contratto di sublocazione
    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>

Questo codice implementa una funzione `summarize_document` (typescript, go, java: `summarizeDocument`; php: `$summarizeDocument`; csharp: `SummarizeDocument`) che usa Claude per sintetizzare il contenuto di un contratto di sublocazione. La funzione accetta come input una stringa di testo e un elenco di dettagli da estrarre. In questo esempio, il codice chiama la funzione con le variabili `document_text` (typescript, go, java, csharp: `documentText`; php: `$documentText`) e `details_to_extract` (typescript, go, java, csharp: `detailsToExtract`; php: `$detailsToExtract`) definite nei frammenti di codice precedenti.

All'interno della funzione viene generato un prompt per Claude, che include il documento da sintetizzare, i dettagli da estrarre e istruzioni specifiche per la sintesi del documento. Il prompt istruisce Claude a rispondere con una sintesi di ciascun dettaglio da estrarre racchiusa all'interno di intestazioni XML.

Poiché il codice restituisce ogni sezione della sintesi all'interno di tag, ogni sezione può essere facilmente estratta in una fase di post-elaborazione. Questo approccio consente sintesi strutturate che possono essere adattate al tuo caso d'uso, in modo che ogni sintesi segua lo stesso schema.

### Valuta il tuo prompt

Il prompting richiede spesso test e ottimizzazione per essere pronto per la produzione. Per determinare la maturità della tua soluzione, valuta la qualità delle tue sintesi usando un processo sistematico che combini metodi quantitativi e qualitativi. Creare una [solida valutazione empirica](https://platform.claude.com/docs/it/test-and-evaluate/develop-tests#build-evaluations) basata sui criteri di successo che hai definito ti consente di ottimizzare i tuoi prompt. Ecco alcune metriche che potresti voler includere nella tua valutazione empirica:

<AccordionGroup>
  <Accordion title="Punteggi ROUGE">
    Misurano la sovrapposizione tra la sintesi generata e una sintesi di riferimento creata da un esperto. Questa metrica si concentra principalmente sul recall ed è utile per valutare la copertura dei contenuti.
  </Accordion>

  <Accordion title="Punteggi BLEU">
    Sebbene originariamente sviluppata per la traduzione automatica, questa metrica può essere adattata alle attività di sintesi. I punteggi BLEU misurano la precisione delle corrispondenze di n-grammi tra la sintesi generata e le sintesi di riferimento. Un punteggio più alto indica che la sintesi generata contiene frasi e terminologia simili a quelle della sintesi di riferimento. 
  </Accordion>

  <Accordion title="Similarità degli embedding contestuali">
    Questa metrica prevede la creazione di rappresentazioni vettoriali (embedding) sia della sintesi generata sia di quella di riferimento. Viene poi calcolata la similarità tra questi embedding, spesso usando la similarità del coseno. Punteggi di similarità più alti indicano che la sintesi generata cattura il significato semantico e il contesto della sintesi di riferimento, anche se la formulazione esatta differisce.
  </Accordion>

  <Accordion title="Valutazione basata su LLM">
    Questo metodo prevede l'uso di un LLM come Claude per valutare la qualità delle sintesi generate rispetto a una griglia di valutazione. La griglia può essere personalizzata in base alle tue esigenze specifiche, valutando fattori chiave come accuratezza, completezza e coerenza. Per indicazioni sull'implementazione, consulta 

    [Suggerimenti per la valutazione basata su LLM](https://platform.claude.com/docs/it/test-and-evaluate/develop-tests#tips-for-llm-based-grading)

    .
  </Accordion>

  <Accordion title="Valutazione umana">
    Oltre a creare le sintesi di riferimento, gli esperti legali possono anche valutare la qualità delle sintesi generate. Sebbene ciò sia costoso e dispendioso in termini di tempo su larga scala, viene spesso fatto su alcune sintesi come controllo di validazione prima del rilascio in produzione.
  </Accordion>
</AccordionGroup>

### Distribuisci il tuo prompt

Ecco alcune considerazioni aggiuntive da tenere presenti quando distribuisci la tua soluzione in produzione.

1. **Assicurati di non incorrere in responsabilità:** Comprendi le implicazioni legali degli errori nelle sintesi, che potrebbero comportare responsabilità legali per la tua organizzazione o i tuoi clienti. Fornisci disclaimer o avvisi legali che chiariscano che le sintesi sono generate dall'IA e devono essere riviste da professionisti legali.

2. **Gestisci tipi di documenti diversi:** Questa guida illustra come estrarre testo dai PDF. Nel mondo reale, i documenti possono presentarsi in una varietà di formati (come PDF, documenti Word e file di testo). Assicurati che la tua pipeline di estrazione dei dati possa convertire tutti i formati di file che prevedi di ricevere.

3. **Parallelizza le chiamate API a Claude:** I documenti lunghi con un gran numero di token possono richiedere fino a un minuto perché Claude generi una sintesi. Per grandi raccolte di documenti, potresti voler inviare le chiamate API a Claude in parallelo, in modo che le sintesi possano essere completate in tempi ragionevoli. Fai riferimento ai [limiti di velocità](https://platform.claude.com/docs/it/api/rate-limits#rate-limits) ("rate limits") di Anthropic per determinare il numero massimo di chiamate API che possono essere eseguite in parallelo.

***

## Migliora le prestazioni

In scenari complessi, può essere utile considerare strategie aggiuntive per migliorare le prestazioni oltre alle [tecniche di prompt engineering](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/overview) standard. Ecco alcune strategie avanzate:

### Esegui la meta-sintesi per sintetizzare documenti lunghi

La sintesi di documenti legali spesso comporta la gestione di documenti lunghi o di molti documenti correlati contemporaneamente, al punto da superare la "context window" (finestra di contesto) di Claude. Puoi usare un metodo di suddivisione in blocchi noto come meta-sintesi per gestire questo caso d'uso. Questa tecnica prevede la scomposizione dei documenti in blocchi più piccoli e gestibili e l'elaborazione separata di ciascun blocco. Puoi poi combinare le sintesi di ciascun blocco per creare una meta-sintesi dell'intero documento.

Ecco un esempio di come eseguire la meta-sintesi:

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il Claude SDK per eseguirlo.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il Claude SDK per eseguirlo.
  </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
  ):
      # Formatta i dettagli da estrarre da inserire nel contesto del prompt
      details_to_extract_str = "\n".join(details_to_extract)

      # Itera sui blocchi e riassumi ciascuno
      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> {
    // Formatta i dettagli da estrarre da inserire nel contesto del prompt
    const detailsToExtractStr = detailsToExtract.join("\n");

    // Itera sui blocchi e riassumi ciascuno
    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
  )
  {
      // Formatta i dettagli da estrarre da inserire nel contesto del prompt
      var detailsToExtractStr = string.Join("\n", detailsToExtract);

      // Itera sui blocchi e riassumi ciascuno
      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 {
  	// Formatta i dettagli da estrarre da inserire nel contesto del prompt
  	detailsToExtractStr := strings.Join(detailsToExtract, "\n")

  	// Itera sui blocchi e riassumi ciascuno
  	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 riassume il contratto di sublocazione blocco per blocco e stampa il riassunto combinato.
  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) {
      // Formatta i dettagli da estrarre da inserire nel contesto del prompt
      String detailsToExtractStr = String.join("\n", detailsToExtract);

      // Itera sui blocchi e riassumi ciascuno
      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 {
      // Formatta i dettagli da estrarre da inserire nel contesto del prompt
      $detailsToExtractStr = implode("\n", $detailsToExtract);

      // Itera sui blocchi e riassumi ciascuno
      $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)
    # Formatta i dettagli da estrarre da inserire nel contesto del prompt
    details_to_extract_str = details_to_extract.join("\n")

    # Itera sui blocchi e riassumi ciascuno
    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 funzione `summarize_long_document` (typescript, go, java: `summarizeLongDocument`; php: `$summarizeLongDocument`; csharp: `SummarizeLongDocument`) si basa sulla precedente funzione `summarize_document` (typescript, go, java: `summarizeDocument`; php: `$summarizeDocument`; csharp: `SummarizeDocument`) suddividendo il documento in blocchi più piccoli e sintetizzando ciascun blocco singolarmente.

Il codice ottiene questo risultato applicando la funzione `summarize_document` (typescript, go, java: `summarizeDocument`; php: `$summarizeDocument`; csharp: `SummarizeDocument`) a ciascun blocco di 20.000 caratteri del documento originale. Le singole sintesi vengono poi combinate e da queste sintesi dei blocchi viene creata una sintesi finale.

Nota che la funzione `summarize_long_document` (typescript, go, java: `summarizeLongDocument`; php: `$summarizeLongDocument`; csharp: `SummarizeLongDocument`) non è strettamente necessaria per il PDF di esempio, poiché l'intero documento rientra nella finestra di contesto di Claude. Tuttavia, diventa essenziale per i documenti che superano la finestra di contesto di Claude o quando si sintetizzano insieme più documenti correlati. In ogni caso, questa tecnica di meta-sintesi spesso cattura nella sintesi finale ulteriori dettagli importanti che erano sfuggiti nel precedente approccio a sintesi singola.

### Usa documenti indicizzati per sintesi per esplorare una grande raccolta di documenti

La ricerca in una raccolta di documenti con un LLM di solito prevede la "retrieval-augmented generation" (generazione aumentata dal recupero), o RAG. Tuttavia, in scenari che coinvolgono documenti di grandi dimensioni o quando il recupero preciso delle informazioni è fondamentale, un approccio RAG di base può essere insufficiente. I documenti indicizzati per sintesi ("summary indexed documents") sono un approccio RAG avanzato che fornisce un modo più efficiente di classificare i documenti per il recupero, usando meno contesto rispetto ai metodi RAG tradizionali. In questo approccio, usi innanzitutto Claude per generare una sintesi concisa di ciascun documento del tuo corpus, e poi usi Claude per classificare la rilevanza di ciascuna sintesi rispetto alla query posta. Per ulteriori dettagli su questo approccio, incluso un esempio basato su codice, consulta la sezione sui documenti indicizzati per sintesi nel [cookbook sulla sintesi](https://platform.claude.com/cookbook/capabilities-summarization-guide).

### Esegui il fine-tuning di Claude per apprendere dal tuo dataset

Un'altra tecnica avanzata per migliorare la capacità di Claude di generare sintesi è il "fine-tuning" (affinamento). Il fine-tuning prevede l'addestramento di Claude su un dataset personalizzato che si allinea specificamente alle tue esigenze di sintesi legale, garantendo che Claude si adatti al tuo caso d'uso. Ecco una panoramica su come eseguire il fine-tuning:

1. **Identifica gli errori:** Inizia raccogliendo i casi in cui le sintesi di Claude risultano carenti: ciò potrebbe includere l'omissione di dettagli legali critici, l'incomprensione del contesto o l'uso di terminologia giuridica inappropriata.

2. **Cura un dataset:** Una volta identificati questi problemi, compila un dataset di questi esempi problematici. Questo dataset deve includere i documenti legali originali insieme alle tue sintesi corrette, garantendo che Claude apprenda il comportamento desiderato.

3. **Esegui il fine-tuning:** Il fine-tuning prevede il riaddestramento del modello sul tuo dataset curato per regolarne i pesi e i parametri. Questo riaddestramento aiuta Claude ad adattarsi meglio ai requisiti specifici del tuo ambito legale, migliorando la sua capacità di sintetizzare documenti secondo i tuoi standard.

4. **Miglioramento iterativo:** Il fine-tuning non è un processo una tantum. Man mano che Claude continua a generare sintesi, puoi aggiungere iterativamente nuovi esempi in cui ha avuto prestazioni insufficienti, affinando ulteriormente le sue capacità. Nel tempo, questo ciclo di feedback continuo porterà a un modello altamente specializzato per le tue attività di sintesi legale.

<Tip>
  Il fine-tuning è attualmente disponibile solo tramite Amazon Bedrock. Ulteriori dettagli sono disponibili nel 

  [blog di lancio di 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 sulla sintesi" icon="link" href="https://platform.claude.com/cookbook/capabilities-summarization-guide">
    Visualizza un esempio basato su codice completamente implementato di come usare Claude per sintetizzare contratti.
  </Card>

  <Card title="Cookbook sulle citazioni" icon="link" href="https://platform.claude.com/cookbook/misc-using-citations">
    Esplora la ricetta del cookbook sulle citazioni per indicazioni su come garantire l'accuratezza e la spiegabilità delle informazioni.
  </Card>
</CardGroup>