LangExtract: una guida con esempi pratici

Estrarre dati strutturati da documenti testuali crea grossi problemi ai team data. Le espressioni regolari si rompono quando i formati cambiano, il codice di parsing personalizzato manca il contesto che gli umani colgono facilmente e queste soluzioni richiedono continue correzioni man mano che le fonti dati evolvono.

LangExtract risolve il problema usando modelli di AI che leggono il testo come farebbe un essere umano e tengono traccia esatta dell'origine di ogni informazione. Tu gli dici in modo semplice quali dati ti servono con pochi esempi, e lui fa il lavoro difficile di capire ed estrarre quelle informazioni.

In questo tutorial ti spiegherò passo dopo passo come configurare LangExtract per il riconoscimento di entità nominate, estrarre relazioni tra entità, lavorare con diversi provider di modelli AI e confrontare l'approccio di LangExtract con le librerie NLP tradizionali. Imparerai anche a definire i task di estrazione, fornire esempi di training e processare i risultati strutturati per i tuoi workflow di analisi.

Che cos'è LangExtract?

LangExtract è una libreria Python che trasforma testo disordinato in dati organizzati usando modelli di AI. I vecchi strumenti di elaborazione del testo si confondono con il contesto: potrebbero vedere “Apple” e pensare al frutto quando stai leggendo dell'azienda tech, o trovare “$500” e chiamarlo un prezzo quando in realtà è un ID dipendente. Il pattern matching di base può individuare indirizzi email, ma non può dire se “[email protected]” è un dipendente attuale o solo qualcuno citato in una vecchia email.

Per risolvere questi problemi di contesto e accuratezza, LangExtract ti offre:

• Tracciamento della fonte — Mostra esattamente da dove proviene ciascun dato nel testo originale
• Modelli di AI multipli — Funziona con OpenAI, Anthropic, Google e modelli locali tramite Ollama
• Suddivisione intelligente — Spezza i documenti grandi in parti e lavora su più sezioni in parallelo
• Tentativi multipli — Esegue lo stesso task più volte per catturare informazioni mancate
• Report visuali — Crea pagine HTML dove puoi cliccare sui dati per vedere da dove provengono

Fonte: GitHub

Questi strumenti lavorano insieme per cambiare il modo in cui estrai informazioni dal testo. Invece di scrivere regole complesse e fragili, dici all'AI cosa vuoi con esempi semplici. L'AI legge il testo come farebbe un umano e tiene traccia dell'origine di tutto. Così puoi estrarre informazioni e relazioni complesse che, con il vecchio approccio, richiederebbero centinaia di righe di codice.

Quando dovresti usare LangExtract?

LangExtract dà il meglio quando devi estrarre informazioni personalizzate che gli strumenti NLP tradizionali gestiscono male. Se lavori con testi specifici di dominio dove il riconoscimento di entità standard non basta, LangExtract ti consente di definire esattamente ciò che conta per il tuo business senza scrivere regole complesse o riaddestrare modelli. È particolarmente utile quando devi capire contesto e relazioni tra pezzi di informazione diversi, non solo trovare singole entità.

LangExtract è una buona scelta quando hai:

• Entità specifiche di dominio — Termini di settore, nomi di prodotti o categorie personalizzate che i modelli pre-addestrati non riconoscono
• Relazioni complesse — Informazioni che devono essere raggruppate, ad esempio collegare persone con i loro ruoli e contatti
• Estrazione dipendente dal contesto — Dove lo stesso testo può significare cose diverse a seconda del contesto circostante
• Necessità di verifica della fonte — Requisiti per tracciare esattamente l'origine di ogni dato estratto
• Tipi di documenti misti — Formati diversi come email, PDF e report che richiedono approcci flessibili
• Competenze ML limitate — Team che vogliono un'estrazione potente senza conoscenze approfondite di machine learning

Dovresti considerare altri strumenti se lavori su task NLP consolidati come il riconoscimento base di entità per categorie comuni, se ti serve un'elaborazione estremamente veloce di pattern semplici o se hai vincoli rigidi per evitare chiamate a API esterne. Le librerie tradizionali come spaCy eccellono nei task NLP standard con volumi elevati, mentre LangExtract brilla quando ti serve un'estrazione intelligente e personalizzata con una complessità di setup minima.

Configurazione di LangExtract

Prima di iniziare a estrarre dati, devi installare LangExtract e configurare l'accesso ai modelli di AI. La libreria supporta più metodi di installazione e funziona con diversi provider di AI.

Installazione

Installa LangExtract con pip o uv. Per l'integrazione con OpenAI, usa il pacchetto extras:

# Using pip
pip install langextract[openai]

# Using uv
uv add langextract[openai]Offerto da

L'extra [openai] include il client Python di OpenAI. Per altri provider, puoi installare il pacchetto base e aggiungere le librerie specifiche del provider secondo necessità.

Configurazione delle chiavi API

LangExtract funziona con diversi provider di AI. Imposta le chiavi API come variabili d'ambiente:

# OpenAI (get your key from https://platform.openai.com/api-keys)
export OPENAI_API_KEY="your-openai-key-here"

# Anthropic (get your key from https://console.anthropic.com/settings/keys) 
export ANTHROPIC_API_KEY="your-anthropic-key-here"

# Google AI (get your key from https://aistudio.google.com/app/apikey)
export GOOGLE_API_KEY="your-google-key-here"Offerto da

Hai bisogno delle chiavi solo per i provider che intendi usare. Per i modelli locali tramite Ollama, non servono chiavi API — ti basta installare e avviare Ollama sulla tua macchina.

Test rapido

Verifica la configurazione con un semplice test:

import langextract as lx
import textwrap

# 1. Define the prompt and extraction rules
prompt = textwrap.dedent(
   """\
   Extract characters, emotions, and relationships in order of appearance.
   Use exact text for extractions. Do not paraphrase or overlap entities.
   Provide meaningful attributes for each entity to add context."""
)

# 2. Provide a high-quality example to guide the model
examples = [
   lx.data.ExampleData(
       text="ROMEO. But soft! What light through yonder window breaks? It is the east, and Juliet is the sun.",
       extractions=[
           lx.data.Extraction(
               extraction_class="character",
               extraction_text="ROMEO",
               attributes={"emotional_state": "wonder"},
           ),
       ],
   )
]

# The input text to be processed
input_text = "Lady Juliet gazed longingly at the stars, her heart aching for Romeo"

# Run the extraction
result = lx.extract(
   text_or_documents=input_text,
   prompt_description=prompt,
   examples=examples,
   model_id="gpt-4o-mini",
)

print("Extraction successful!")Offerto da

Eseguire il Named Entity Recognition (NER) in LangExtract

Il Named Entity Recognition (NER) individua e classifica pezzi specifici di informazione nel testo, come trovare tutti i nomi di aziende, persone e luoghi menzionati in un report aziendale.

Gli strumenti NER tradizionali lavorano con categorie predefinite come “PERSON” o “ORGANIZATION”, ma spesso perdono entità dipendenti dal contesto che contano per il tuo business. LangExtract ti permette di definire tipi di entità personalizzati e insegnare all'AI a riconoscere pattern specifici del tuo dominio.

Vediamo come estrarre entità da email di supporto clienti. Invece di categorie generiche, identificheremo entità specifiche del supporto come tipi di reclamo, nomi di prodotto e tempi di risoluzione che aiutano a dare priorità ai ticket.

Definire il task di estrazione

Il primo passo è descrivere cosa vuoi estrarre usando un prompt chiaro. Questo prompt funge da istruzioni per un analista umano: più sei specifico, migliori saranno i risultati:

import langextract as lx
import textwrap

# Define what we want to extract from support emails
prompt = textwrap.dedent("""
   Extract customer support entities from email text.
   Focus on actionable information that helps prioritize and route tickets.
   Use exact text from the email - don't paraphrase or summarize.
   Include helpful attributes that add context for support agents.
""")Offerto da

La funzione textwrap.dedent() rimuove l'indentazione extra dalle stringhe multi-linea, rendendo i prompt più leggibili nel codice e mantenendoli puliti quando vengono inviati all'AI. Senza questa funzione, l'AI vedrebbe tutti gli spazi in più dovuti all'indentazione del codice.

Questo prompt dice all'AI di cercare informazioni specifiche del supporto, usare citazioni esatte dal testo e aggiungere contesto tramite attributi. La chiave è essere specifici sul tuo dominio (supporto clienti) e su ciò che rende utile l'informazione (aiuta a dare priorità e instradare i ticket).

Fornire esempi di estrazione

Gli esempi insegnano all'AI esattamente cosa vuoi e come formattare i risultati. Ogni esempio mostra un pezzo di testo e le entità esatte che vuoi estrarre:

# Create examples that show the AI what to extract
examples = [
   lx.data.ExampleData(
       text="My laptop screen keeps flickering. I bought it 3 months ago and need this fixed urgently for my presentation tomorrow.",
       extractions=[
           lx.data.Extraction(
               extraction_class="product",
               extraction_text="laptop",
               attributes={"issue": "screen flickering", "urgency": "high"}
           ),
           lx.data.Extraction(
               extraction_class="timeline",
               extraction_text="3 months ago",
               attributes={"context": "purchase_date"}
           ),
           lx.data.Extraction(
               extraction_class="urgency_indicator",
               extraction_text="urgently for my presentation tomorrow",
               attributes={"priority": "high", "deadline": "tomorrow"}
           )
       ]
   )
]Offerto da

Ogni oggetto ExampleData contiene un campione di testo e una lista di oggetti Extraction. Gli oggetti Extraction specificano tre cose:

• extraction_class: Il tipo di entità (come "product" o "timeline")
• extraction_text: Le parole esatte del testo originale
• attributes: Contesto extra che aiuta a capire meglio l'entità

Gli attributi sono ciò che distingue LangExtract dal NER tradizionale. Invece di trovare solo “laptop”, possiamo catturare che ha un problema di “sfarfallio dello schermo” e contrassegnarlo come alta urgenza.

Eseguire l'estrazione

Ora puoi eseguire l'estrazione su nuovo testo usando il tuo prompt e gli esempi. LangExtract applicherà quanto appreso per trovare entità simili:

# Sample support email to analyze
support_email = """
Subject: WiFi adapter not working after Windows update

Hi support team,

My USB WiFi adapter stopped working completely after yesterday's Windows update.
I've tried restarting my computer multiple times but no luck. This is blocking me
from working from home today. I have an important client call at 2 PM and really
need internet access. The adapter worked perfectly before the update.

Thanks,
Mike Chen
"""

# Run the extraction
result = lx.extract(
   text_or_documents=support_email,
   prompt_description=prompt,
   examples=examples,
   model_id="gpt-4o-mini"
)

print("Extraction completed successfully!")Offerto da

Output:

INFO:absl:Finalizing annotation for document ID doc_435b1cd5.
INFO:absl:Document annotation completed.
✓ Extracted 4 entities (3 unique types)
 • Time: 3.34s
 • Speed: 123 chars/sec
 • Chunks: 1
Extraction completed successfully!Offerto da

La funzione lx.extract() prende il tuo testo, applica le istruzioni del prompt e usa gli esempi per guidare l'estrazione. Restituisce un oggetto risultato con tutte le entità trovate, insieme alle loro posizioni esatte nel testo originale.

Puoi sperimentare modelli diversi cambiando il parametro model_id. Modelli come "claude-3-haiku" o "gpt-4o" possono dare risultati diversi a seconda della complessità del testo e dei requisiti.

Lavorare con i dati estratti in LangExtract

Una volta completata l'estrazione, LangExtract restituisce un oggetto risultato con tutte le entità trovate, con posizioni esatte e attributi. Il vero valore sta in come puoi accedere, analizzare e condividere questi dati strutturati.

Accedere alle entità estratte

L'oggetto risultato memorizza tutte le entità trovate nella proprietà extractions. Ogni estrazione contiene il testo dell'entità, il suo tipo, la posizione nel documento originale e gli eventuali attributi:

# Look at all extracted entities
for extraction in result.extractions:
   print(f"Type: {extraction.extraction_class}")
   print(f"Text: '{extraction.extraction_text}'")
   print(f"Location: chars {extraction.char_interval.start_pos}-{extraction.char_interval.end_pos}")
   print(f"Attributes: {extraction.attributes}")
   print("---")Offerto da

Output:

Type: product
Text: 'USB WiFi adapter'
Location: chars 78-94
Attributes: {'issue': 'not working after Windows update', 'previous_status': 'worked perfectly before the update'}
---
Type: timeline
Text: 'yesterday'
Location: chars 128-137
Attributes: {'context': 'Windows update'}
---
Type: urgency_indicator
Text: 'blocking me from working from home today'
Location: chars 227-268
Attributes: {'priority': 'high', 'context': 'work from home'}
---
Type: urgency_indicator
Text: 'important client call at 2 PM'
Location: chars 280-309
Attributes: {'priority': 'high', 'deadline': '2 PM today'}
---Offerto da

Ogni oggetto di estrazione traccia esattamente da dove proviene l'informazione usando char_interval, che mostra le posizioni iniziale e finale nel testo originale. Questo tracciamento della fonte ti permette di verificare i risultati e capire il contesto.

Analizzare i pattern delle entità

Puoi raggruppare e contare le entità per capire i pattern nei tuoi dati:

from collections import Counter

# Count different entity types
entity_types = Counter(e.extraction_class for e in result.extractions)
print("Entity breakdown:")
for entity_type, count in entity_types.items():
   percentage = (count / len(result.extractions)) * 100
   print(f"  {entity_type}: {count} entities ({percentage:.1f}%)")

# Find high-priority support tickets
urgent_entities = [
   e for e in result.extractions
   if e.extraction_class == "urgency_indicator"
   and e.attributes.get("priority") == "high"
]
print(f"\nFound {len(urgent_entities)} high-priority indicators")Offerto da

Output:

Entity breakdown:
 product: 1 entities (25.0%)
 timeline: 1 entities (25.0%)
 urgency_indicator: 2 entities (50.0%)

Found 2 high-priority indicatorsOfferto da

Questa analisi ti aiuta a individuare rapidamente pattern come quali tipi di prodotto generano più ticket di supporto o quanti sono i casi urgenti che stai ricevendo.

Salvare i risultati dell'estrazione

LangExtract salva i risultati in formato JSONL (JSON Lines), dove ogni riga contiene i dati di estrazione di un documento. Questo formato funziona bene con gli strumenti di data processing e rende semplice combinare risultati da più estrazioni:

# Save results to a JSONL file
lx.io.save_annotated_documents(
   [result],
   output_name="support_ticket_extractions.jsonl",
   output_dir="."
)Offerto da

JSONL memorizza ciascun documento su una riga separata come oggetto JSON completo. A differenza dei file JSON tradizionali che contengono un unico grande array, i file JSONL possono essere processati riga per riga, risultando perfetti per dataset di grandi dimensioni. Puoi aprire questi file in qualsiasi editor di testo o caricarli in strumenti di analisi dati come pandas.

Creare visualizzazioni HTML interattive

La visualizzazione HTML è dove LangExtract spicca davvero. Crea un report interattivo che evidenzia le entità estratte nel testo originale e ti consente di esplorare i risultati cliccandoci sopra:

# Generate interactive HTML visualization
html_content = lx.visualize("support_ticket_extractions.jsonl")

# Save the HTML file
with open("support_analysis.html", "w") as f:
   if hasattr(html_content, "data"):
       f.write(html_content.data)  # For Jupyter notebooks
   else:
       f.write(html_content)  # For regular Python scripts

print("HTML visualization saved as 'support_analysis.html'")Offerto da

Output:

HTML visualization saved as 'support_analysis.html'Offerto da

La visualizzazione HTML mostra il tuo testo originale con evidenziazioni a colori per ogni tipo di entità. Puoi cliccare sul testo evidenziato per vedere gli attributi estratti, navigare tra le entità con i controlli e verificare che l'AI abbia identificato correttamente le informazioni importanti. Questo rende semplice verificare a campione i risultati e aumentare la fiducia nella pipeline di estrazione.

La visualizzazione include una legenda con ciascun tipo di entità, controlli di navigazione per muoverti tra le entità e informazioni dettagliate sugli attributi per ogni estrazione. Questo approccio interattivo rende molto più facile comprendere e validare i risultati rispetto a guardare dati JSON grezzi.

Estrazione di relazioni in LangExtract

Le entità di supporto clienti che abbiamo estratto funzionano bene singolarmente, ma non raccontano l'intera storia. Quando un cliente dice “il mio MacBook Pro del 2021 ha problemi di batteria”, devi capire che prodotto, anno del modello e problema appartengono insieme a un singolo caso di supporto. Trovare questi pezzi separatamente non aiuta: ti servono le relazioni tra di loro.

L'NLP tradizionale gestisce male questo aspetto perché tratta ogni entità come informazione isolata. Potresti estrarre “MacBook Pro”, “2021” e “problemi di batteria” come entità separate, ma poi servono regole complesse per capire quali dettagli si riferiscono a quali prodotti. Questo approccio crolla rapidamente quando hai a che fare con più prodotti o clienti nello stesso testo.

LangExtract risolve il problema estraendo le relazioni già nel passaggio iniziale invece di provare a collegare le entità dopo. Puoi raggruppare informazioni correlate usando attributi condivisi, mantenendo comunque la tracciabilità esatta della fonte nel testo originale. Vediamo come estrarre informazioni sui dipendenti da documenti HR in cui dobbiamo collegare persone con ruoli, reparti e contatti.

Impostare l'estrazione di relazioni

Per questo esempio, estrarremo informazioni sui dipendenti da annunci aziendali in cui più dettagli su ciascuna persona devono essere collegati:

import langextract as lx
import textwrap

# Define relationship extraction prompt
prompt = textwrap.dedent("""
   Extract employee information from company announcements.
   Group related details about each person using employee_group attributes.
   Connect names, titles, departments, and contact info for each employee.
   Use exact text from the announcement - don't paraphrase.
""")

# Create examples showing how to group related information
examples = [
   lx.data.ExampleData(
       text="Sarah Johnson, our new Marketing Director, will lead the digital campaigns team. You can reach Sarah at [email protected] for any marketing questions.",
       extractions=[
           lx.data.Extraction(
               extraction_class="person",
               extraction_text="Sarah Johnson",
               attributes={"employee_group": "Sarah Johnson"}
           ),
           lx.data.Extraction(
               extraction_class="job_title",
               extraction_text="Marketing Director",
               attributes={"employee_group": "Sarah Johnson"}
           ),
           lx.data.Extraction(
               extraction_class="department",
               extraction_text="digital campaigns team",
               attributes={"employee_group": "Sarah Johnson"}
           ),
           lx.data.Extraction(
               extraction_class="contact",
               extraction_text="[email protected]",
               attributes={"employee_group": "Sarah Johnson", "type": "email"}
           )
       ]
   )
]Offerto da

L'attributo employee_group funge da sistema di collegamento: tutte le entità con lo stesso valore di employee_group appartengono alla stessa persona. Questo ti permette di estrarre informazioni complesse e multipartite mantenendo il collegamento tra i dettagli.

Eseguire l'estrazione delle relazioni

Ora estraiamo da un annuncio aziendale con più dipendenti:

# Sample HR announcement with multiple employees
hr_announcement = """
We're excited to announce two new hires joining our team this month.

Mike Chen joins us as Senior Software Engineer in our Backend Development group. Mike brings 8 years of Python experience and will focus on API architecture. Please welcome Mike - he'll be working from our Seattle office and you can reach him at [email protected].

Additionally, Lisa Rodriguez starts as Product Manager for our Mobile Apps division. Lisa previously worked at TechStart Inc and has extensive experience with user research. Her office phone is 555-0199 and email is [email protected].
"""

# Extract relationships
result = lx.extract(
   text_or_documents=hr_announcement,
   prompt_description=prompt,
   examples=examples,
   model_id="gpt-4o-mini"
)

print(f"Extracted {len(result.extractions)} entities")Offerto da

Output:

✓ Extraction processing complete

INFO:absl:Finalizing annotation for document ID doc_a349ae1d.
INFO:absl:Document annotation completed.
✓ Extracted 10 entities (4 unique types)
 • Time: 8.57s
 • Speed: 67 chars/sec
 • Chunks: 1
Extracted 10 entitiesOfferto da

Lavorare con i gruppi di relazione

Dopo l'estrazione, puoi raggruppare le entità correlate per vedere tutte le informazioni complete per ciascun dipendente. Serve un po' di codice Python per riorganizzare le entità sparse in gruppi logici:

from collections import defaultdict

# Group entities by employee_group
employee_groups = defaultdict(list)
for extraction in result.extractions:
   group_id = extraction.attributes.get("employee_group")
   if group_id:
       employee_groups[group_id].append(extraction)

# Print organized employee information
for employee, details in employee_groups.items():
   print(f"\n=== {employee} ===")
   for detail in details:
       print(f"{detail.extraction_class}: {detail.extraction_text}")
       if detail.attributes.get("type"):
           print(f"  Type: {detail.attributes['type']}")Offerto da

Output:

=== Mike Chen ===
person: Mike Chen
job_title: Senior Software Engineer
department: Backend Development group
contact: [email protected]
 Type: email
contact: Seattle office
 Type: location

=== Lisa Rodriguez ===
person: Lisa Rodriguez
job_title: Product Manager
department: Mobile Apps division
contact: [email protected]
 Type: email
contact: 555-0199
 Type: phoneOfferto da

Ecco cosa fa questo codice, passo dopo passo:

1. defaultdict(list) crea un dizionario in cui ogni nuova voce parte automaticamente come lista vuota
2. extraction.attributes.get("employee_group") recupera in modo sicuro l'ID di gruppo dagli attributi di ciascuna entità, restituendo None se non esiste
3. employee_groups[group_id].append(extraction) aggiunge ogni entità alla lista del suo gruppo
4. I loop annidati poi stampano le informazioni complete di ciascun gruppo, organizzate per dipendente

Il defaultdict è una collezione Python che crea automaticamente le voci mancanti. Quando accedi a employee_groups["Mike Chen"] per la prima volta, crea automaticamente una lista vuota per quel dipendente. Questo ti evita di controllare se ciascun dipendente esiste già nel dizionario.

Questo approccio di raggruppamento ti permette di ricostruire profili completi dei dipendenti dalle informazioni sparse nel testo originale, mantenendo le posizioni esatte della fonte per ogni dato.

Creare visualizzazioni delle relazioni

La visualizzazione HTML diventa ancora più utile con i dati di relazione, perché mostra sia le singole entità sia i loro collegamenti:

# Save the relationship extraction results
lx.io.save_annotated_documents(
   [result],
   output_name="employee_relationships.jsonl",
   output_dir="."
)

# Generate HTML visualization showing relationships
html_content = lx.visualize("employee_relationships.jsonl")
with open("employee_relationships.html", "w") as f:
   if hasattr(html_content, "data"):
       f.write(html_content.data)
   else:
       f.write(html_content)

print("Relationship visualization saved as 'employee_relationships.html'")Offerto da

La visualizzazione delle relazioni evidenzia come i diversi pezzi di informazione si connettano per formare record completi dei dipendenti, facilitando la verifica che l'AI abbia identificato e raggruppato correttamente i dettagli correlati dall'annuncio originale.

Usare LangExtract con diversi provider di modelli

LangExtract funziona con diversi provider di modelli AI, ognuno con compromessi diversi tra costo, velocità e accuratezza. I modelli Gemini di Google funzionano subito con supporto di schema integrato, rendendoli l'opzione più semplice per la maggior parte dei task di estrazione. I modelli GPT di OpenAI spesso offrono maggiore accuratezza ma richiedono configurazioni aggiuntive e costano di più per estrazione.

# Using Google Gemini (default and recommended)
result_gemini = lx.extract(
   text_or_documents=employee_text,
   prompt_description=prompt,
   examples=examples,
   model_id="gemini-2.5-flash"  # Fast and cost-effective
)

# Using OpenAI GPT models
result_openai = lx.extract(
   text_or_documents=employee_text,
   prompt_description=prompt,
   examples=examples,
   model_id="gpt-4o-mini",
   fence_output=True,              # Required for OpenAI
   use_schema_constraints=False    # OpenAI doesn't support constraints
)Offerto da

Per l'elaborazione locale o quando vuoi evitare i costi delle API, puoi eseguire modelli localmente usando Ollama. I modelli locali funzionano bene per task di estrazione più semplici e ti danno pieno controllo sui dati, anche se in genere sono più lenti e meno accurati rispetto alle opzioni cloud.

# Using local models with Ollama (requires Ollama installed)
result_local = lx.extract(
   text_or_documents=employee_text,
   prompt_description=prompt,
   examples=examples,
   model_id="gemma2:2b",                    # Local Gemma model
   model_url="http://localhost:11434",     # Ollama server
   fence_output=False,                     # Local models don't need fencing
   use_schema_constraints=False            # Disable constraints
)Offerto da

Scalare in produzione

Il testo reale non assomiglia ai nostri esempi puliti. Ti ritrovi con report di 50 pagine con formattazione disordinata, email dei clienti piene di refusi e PDF con spaziature strane. Alcuni documenti hanno migliaia di parole distribuite su sezioni diverse, e le informazioni importanti potrebbero essere nascoste ovunque.

LangExtract gestisce queste situazioni caotiche con tre strumenti principali: elaborare più documenti insieme, tentare l'estrazione più volte e spezzare i documenti grandi in parti più piccole. Invece di processare un documento alla volta, puoi lavorare su molti documenti in parallelo, rendendo tutto molto più veloce.

# Settings for processing lots of real documents
result = lx.extract(
   text_or_documents=document_batch,
   prompt_description=prompt,
   examples=examples,
   model_id="gemini-2.5-flash",
   max_workers=20,           # Work on many documents at once
   extraction_passes=3,      # Try extraction 3 times
   max_char_buffer=1000      # Break big text into small pieces
)Offerto da

L'impostazione max_workers controlla quanti documenti vengono processati contemporaneamente. Più worker significano risultati più veloci, ma anche costi maggiori e possibili limiti API. Parti con 10-20 worker e valuta.

Passaggi multipli di estrazione aiutano a trovare informazioni che potrebbero essere sfuggite al primo tentativo. LangExtract esegue l'estrazione più volte e combina i risultati. Questo cattura più dettagli, ma richiede più tempo e costa di più.

Spezzare i documenti in chunk aiuta con testi lunghi. L'impostazione max_char_buffer taglia i documenti grandi in parti più piccole che funzionano meglio con i modelli di AI. Chunk piccoli (1000-2000 caratteri) catturano più dettagli, mentre chunk grandi (3000-5000 caratteri) mantengono più contesto ma possono perdere qualcosa.

# Different settings for different types of documents

# For important documents that need careful review
detailed_result = lx.extract(
   text_or_documents=legal_documents,
   extraction_passes=5,      # Try 5 times for accuracy
   max_char_buffer=800,      # Small chunks for detail
   max_workers=10           # Fewer workers to avoid limits
)

# For quick processing of simple documents
quick_result = lx.extract(
   text_or_documents=email_batch,
   extraction_passes=1,      # Single pass for speed
   max_char_buffer=3000,     # Bigger chunks for speed
   max_workers=30           # More workers for faster results
)Offerto da

Lavorare in produzione significa gestire problemi. I documenti possono avere errori di encoding, le connessioni di rete possono fallire e le API possono limitare la velocità di elaborazione. Monitora i job di estrazione, aggiungi logiche di retry per i documenti falliti e tieni traccia di quanto spendi con i vari provider di AI.

Quando lavori con tipi di documento diversi, imposta regole di estrazione differenti per ciascuno. I contratti legali richiedono prompt diversi dalle email dei clienti. I report finanziari necessitano chunk di dimensioni diverse rispetto ai post social. Costruisci pipeline separate per ogni tipo di documento invece di cercare di far gestire tutto a un unico sistema.

LangExtract vs. altre librerie NLP

LangExtract adotta un approccio diverso rispetto alle librerie NLP tradizionali. Mentre la maggior parte si basa su modelli pre-addestrati o sistemi a regole, LangExtract usa Large Language Models che comprendono contesto e significato come gli umani. Confrontiamolo con tre popolari librerie NLP in Python per capire quando scegliere LangExtract rispetto ad altre opzioni.

spaCy

spaCy punta su velocità e task NLP production-ready come tokenizzazione, part-of-speech tagging e named entity recognition. Offre modelli pre-addestrati che riconoscono entità comuni come persone, organizzazioni e luoghi, ma fatica con entità specifiche di dominio o categorie personalizzate. spaCy eccelle nell'elaborare grandi volumi di testo rapidamente, ma devi riaddestrare i modelli o scrivere regole complesse per estrarre informazioni personalizzate.

LangExtract elimina questa complessità permettendoti di definire entità personalizzate tramite esempi e prompt semplici, fornendo anche posizioni esatte della fonte che spaCy non traccia.

NLTK (Natural Language Toolkit)

NLTK (Natural Language Toolkit) è pensata per didattica e ricerca, offrendo un'ampia gamma di algoritmi e dataset NLP. Fornisce i mattoncini per l'elaborazione del testo ma richiede notevoli competenze di programmazione per costruire soluzioni complete. NLTK è ottima per imparare i concetti NLP e fare prototipi, ma costruire sistemi di estrazione production-ready richiede combinare più componenti NLTK e scrivere molto codice.

LangExtract offre una soluzione completa out of the box: definisci ciò che vuoi tramite esempi anziché codificare algoritmi, e ottieni visualizzazioni interattive senza sviluppo aggiuntivo.

Transformers (Hugging Face)

Transformers (Hugging Face) offre accesso a modelli transformer all'avanguardia per vari task NLP, incluso named entity recognition e question answering. Pur essendo potenti, richiedono competenze di machine learning per fare fine-tuning su domini specifici e non forniscono tracciamento della fonte o estrazione di relazioni integrati. Devi gestire il deployment dei modelli, i diversi formati e costruire strumenti di visualizzazione tuoi.

LangExtract astrae la complessità del lavoro con modelli diversi, gestisce automaticamente il tracciamento della fonte e fornisce l'estrazione di relazioni tramite semplice raggruppamento di attributi invece di architetture di modelli complesse.

Conclusione

LangExtract trasforma l'estrazione di testo dal writing di regole complesse a conversazioni con l'AI sui tuoi dati. Hai imparato a configurare l'estrazione di entità personalizzate con prompt ed esempi semplici, a raggruppare informazioni correlate tramite l'estrazione di relazioni e a creare visualizzazioni interattive che mostrano esattamente da dove proviene ogni informazione. La libreria gestisce sfide di produzione come l'elaborazione in parallelo e la suddivisione dei documenti, rendendola pratica per applicazioni reali con testo disordinato e incoerente.

Che tu stia processando ticket di supporto clienti, analizzando documenti legali o estraendo insight da articoli scientifici, LangExtract offre un approccio più intuitivo rispetto alle librerie NLP tradizionali. Invece di spendere tempo su training dei modelli o scrittura di regole, puoi concentrarti nel definire quali informazioni contano per il tuo caso d'uso. Inizia con estrazioni semplici sui tuoi dati testuali e poi scala usando le tecniche di produzione trattate in questo tutorial.