LangExtract: een gids met praktische voorbeelden

Gestructureerde data uit tekstdocumenten halen levert grote problemen op voor datateams. Reguliere expressies breken wanneer formaten veranderen, aangepaste parseercode mist context die mensen wél oppikken, en deze oplossingen vragen om voortdurend onderhoud naarmate je databronnen veranderen.

LangExtract lost dit op met AI-modellen die tekst kunnen lezen zoals mensen dat doen en precies bijhouden waar informatie vandaan komt. Jij vertelt in eenvoudige bewoordingen met een paar voorbeelden welke data je wilt, en het doet het zware werk van begrijpen en extraheren.

In deze tutorial leg ik stap voor stap uit hoe je LangExtract instelt voor named entity recognition, relaties tussen entiteiten extraheert, met verschillende AI-modelproviders werkt en de aanpak van LangExtract vergelijkt met traditionele NLP-bibliotheken. Je leert ook hoe je extractietaken definieert, trainingsvoorbeelden aanlevert en de gestructureerde resultaten verwerkt voor je analysetrajecten.

Wat is LangExtract?

LangExtract is een Python-bibliotheek die rommelige tekst omzet in geordende data met AI-modellen. Oude tekstverwerkingstools raken in de war door context — ze zien bijvoorbeeld “Apple” en denken aan een vrucht terwijl jij over het techbedrijf leest, of vinden “$500” en noemen het een prijs terwijl het eigenlijk een personeels-ID is. Eenvoudige patroonherkenning kan e-mailadressen spotten, maar kan niet bepalen of “[email protected]” een huidige medewerker is of alleen iemand die in een oude e-mail genoemd wordt.

Om deze context- en nauwkeurigheidsproblemen te verhelpen, biedt LangExtract je:

• Brontracering — Laat precies zien waar elk datapunt in de oorspronkelijke tekst vandaan komt
• Meerdere AI-modellen — Werkt met OpenAI, Anthropic, Google en lokale modellen via Ollama
• Slim chunking — Knipt grote documenten in stukken en werkt aan meerdere delen tegelijk
• Meerdere pogingen — Voert dezelfde taak meerdere keren uit om gemiste informatie op te vangen
• Visuele rapporten — Maakt HTML-pagina’s waarop je op data kunt klikken om de bron te zien

Bron: GitHub

Deze tools werken samen en veranderen de manier waarop je informatie uit tekst haalt. In plaats van complexe regels te schrijven die snel breken, vertel je de AI met eenvoudige voorbeelden wat je wilt. De AI leest de tekst zoals een mens en houdt bij waar alles vandaan komt. Zo kun je complexe informatie en relaties boven water halen die je op de oude manier honderden regels code zouden kosten.

Wanneer moet je LangExtract gebruiken?

LangExtract werkt het best wanneer je aangepaste informatie moet extraheren die traditionele NLP-tools niet goed aankunnen. Werk je met domeinspecifieke tekst waar standaard named entity recognition tekortschiet, dan laat LangExtract je precies definiëren wat belangrijk is voor jouw bedrijf, zonder complexe regels te schrijven of modellen te hertrainen. Het is vooral nuttig wanneer je context en relaties tussen stukken informatie moet begrijpen, niet alleen losse entiteiten vinden.

LangExtract is een goede keuze wanneer je beschikt over:

• Domeinspecifieke entiteiten — Vaktermen, productnamen of aangepaste categorieën die voorgetrainde modellen niet herkennen
• Complexe relaties — Informatie die bij elkaar hoort, zoals mensen koppelen aan hun rol en contactgegevens
• Contextafhankelijke extractie — Waar dezelfde tekst iets anders kan betekenen afhankelijk van de omgeving
• Behoefte aan bronverificatie — Vereisten om precies te traceren waar elk geëxtraheerd datapunt vandaan komt
• Gemengde documenttypen — Verschillende formaten zoals e-mails, pdf’s en rapporten die flexibele verwerking vragen
• Beperkte ML-expertise — Teams die krachtige extractie willen zonder diepgaande machinelearningkennis

Overweeg andere tools als je werkt met goed ingeburgerde NLP-taken zoals basale named entity recognition voor gangbare categorieën, extreem snelle verwerking van simpele patronen nodig hebt of strikte eisen hebt om externe API-calls te vermijden. Traditionele bibliotheken zoals spaCy blinken uit in standaard NLP-taken met hoog volume, terwijl LangExtract juist schijnt wanneer je slimme, aangepaste extractie wilt met minimale setupcomplexiteit.

LangExtract instellen

Voordat je data kunt extraheren, moet je LangExtract installeren en toegang tot AI-modellen instellen. De bibliotheek ondersteunt meerdere installatiemethoden en werkt met verschillende AI-providers.

Installatie

Installeer LangExtract met pip of uv. Voor OpenAI-integratie gebruik je het extras-pakket:

# Using pip
pip install langextract[openai]

# Using uv
uv add langextract[openai]Mogelijk gemaakt door

De [openai] extra bevat de OpenAI Python-client. Voor andere providers kun je het basispakket installeren en naar behoefte providerspecifieke libraries toevoegen.

API-sleutel instellen

LangExtract werkt met meerdere AI-providers. Stel API-sleutels in als omgevingsvariabelen:

# 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"Mogelijk gemaakt door

Je hebt alleen sleutels nodig voor de providers die je wilt gebruiken. Voor lokale modellen via Ollama zijn geen API-sleutels vereist — installeer en start Ollama gewoon op je machine.

Snelle test

Controleer je setup met een eenvoudige 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!")Mogelijk gemaakt door

Named Entity Recognition (NER) uitvoeren in LangExtract

Named Entity Recognition (NER) vindt en classificeert specifieke stukjes informatie in tekst ,  zoals alle bedrijfsnamen, personen en locaties in een zakelijk rapport.

Traditionele NER-tools werken met vooraf gedefinieerde categorieën zoals “PERSON” of “ORGANIZATION”, maar missen vaak contextspecifieke entiteiten die voor jouw bedrijf belangrijk zijn. Met LangExtract kun je aangepaste entiteitstypen definiëren en de AI leren patronen te herkennen die specifiek zijn voor jouw domein.

Laten we entiteiten extraheren uit e-mails van de klantenservice. In plaats van generieke categorieën identificeren we supportspecifieke entiteiten zoals klachtsoorten, productnamen en oplostermijnen die helpen tickets te prioriteren.

De extractietaak definiëren

De eerste stap is beschrijven wat je wilt extraheren met een duidelijke prompt. Deze prompt werkt als instructie voor een menselijke analist — hoe specifieker je bent, hoe beter de resultaten:

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.
""")Mogelijk gemaakt door

De functie textwrap.dedent() verwijdert extra inspringing uit meerregelige strings, waardoor je prompts in code leesbaarder zijn terwijl ze schoon blijven wanneer ze naar de AI worden gestuurd. Zonder deze functie zou de AI alle extra spaties van je code-inspringing zien.

Deze prompt vertelt de AI om supportspecifieke informatie te zoeken, exacte citaten uit de tekst te gebruiken en context toe te voegen via attributen. De sleutel is dat je specifiek bent over je domein (klantenservice) en wat informatie nuttig maakt (helpt bij prioriteren en routeren van tickets).

Extractievoorbeelden aanleveren

Voorbeelden leren de AI precies wat je wilt en hoe je resultaten formatteert. Elk voorbeeld laat de AI een stuk tekst en de exacte entiteiten zien die je eruit wilt halen:

# 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"}
           )
       ]
   )
]Mogelijk gemaakt door

Elk ExampleData-object bevat een tekstvoorbeeld en een lijst met Extraction-objecten. De Extraction-objecten specificeren drie dingen:

• extraction_class: Het type entiteit (zoals "product" of "timeline")
• extraction_text: De exacte woorden uit de oorspronkelijke tekst
• attributes: Extra context die helpt de entiteit beter te begrijpen

De attributen onderscheiden LangExtract van traditionele NER. In plaats van alleen “laptop” te vinden, kunnen we vastleggen dat er sprake is van “screen flickering” en het als hoge urgentie markeren.

De extractie uitvoeren

Nu kun je de extractie draaien op nieuwe tekst met je prompt en voorbeelden. LangExtract past wat het geleerd heeft toe om vergelijkbare entiteiten te vinden:

# 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!")Mogelijk gemaakt door

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!Mogelijk gemaakt door

De functie lx.extract() neemt je tekst, past de promptinstructies toe en gebruikt de voorbeelden om de extractie te sturen. De functie retourneert een resultaatobject met alle gevonden entiteiten, inclusief hun exacte locaties in de oorspronkelijke tekst.

Je kunt met verschillende modellen experimenteren door de parameter model_id te wijzigen. Modellen zoals "claude-3-haiku" of "gpt-4o" kunnen andere resultaten geven, afhankelijk van de complexiteit van je tekst en je eisen.

Werken met geëxtraheerde data in LangExtract

Zodra je extractie klaar is, geeft LangExtract een resultaatobject terug met alle gevonden entiteiten, inclusief hun exacte locaties en attributen. De echte kracht zit in hoe je deze gestructureerde data kunt benaderen, analyseren en delen.

Toegang tot geëxtraheerde entiteiten

Het resultaatobject slaat alle gevonden entiteiten op in de eigenschap extractions. Elke extractie bevat de entiteitstekst, het type, de locatie in het oorspronkelijke document en eventuele attributen:

# 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("---")Mogelijk gemaakt door

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'}
---Mogelijk gemaakt door

Elk extractieobject houdt met char_interval precies bij waar de informatie vandaan komt, met begin- en eindposities in de oorspronkelijke tekst. Deze brontracering laat je resultaten verifiëren en context begrijpen.

Entiteitspatronen analyseren

Je kunt entiteiten groeperen en tellen om patronen in je data te begrijpen:

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")Mogelijk gemaakt door

Output:

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

Found 2 high-priority indicatorsMogelijk gemaakt door

Met deze analyse zie je snel patronen, zoals welke producttypes de meeste supporttickets genereren of hoeveel urgente verzoeken je ontvangt.

Extractieresultaten opslaan

LangExtract slaat resultaten op in JSONL-formaat (JSON Lines), waarbij elke regel de extractiedata van één document bevat. Dit formaat werkt goed met dataverwerkingstools en maakt het eenvoudig om resultaten van meerdere extracties te combineren:

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

JSONL slaat elk document op een aparte regel op als een volledig JSON-object. In tegenstelling tot reguliere JSON-bestanden met één grote array, kunnen JSONL-bestanden regel voor regel worden verwerkt, wat ideaal is voor grote datasets. Je kunt deze bestanden in elke teksteditor openen of inlaad in data-analysetools zoals pandas.

Interactieve HTML-visualisaties maken

De HTML-visualisatie is waar LangExtract echt uitblinkt. Het maakt een interactief rapport dat geëxtraheerde entiteiten in de oorspronkelijke tekst markeert en je door de resultaten laat klikken:

# 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'")Mogelijk gemaakt door

Output:

HTML visualization saved as 'support_analysis.html'Mogelijk gemaakt door

De HTML-visualisatie toont je oorspronkelijke tekst met kleurgecodeerde markeringen voor elk entiteitstype. Je kunt op gemarkeerde tekst klikken om de geëxtraheerde attributen te zien, tussen entiteiten navigeren met de bedieningselementen en verifiëren dat de AI belangrijke informatie correct heeft geïdentificeerd. Dit maakt het eenvoudig om steekproefsgewijs te controleren en vertrouwen op te bouwen in je extractiepijplijn.

De visualisatie bevat een legenda met elk entiteitstype, navigatieknoppen om tussen entiteiten te wisselen en gedetailleerde attribuutinformatie per extractie. Deze interactieve aanpak maakt het veel makkelijker om je resultaten te begrijpen en te valideren dan ruwe JSON-data bekijken.

Relatie-extractie in LangExtract

De supportspecifieke entiteiten die we hebben geëxtraheerd werken afzonderlijk goed, maar vertellen niet het hele verhaal. Wanneer een klant zegt “mijn MacBook Pro uit 2021 heeft batterijproblemen”, moet je begrijpen dat product, modeljaar en probleem bij elkaar horen als één supportcase. Losse stukjes vinden helpt niet — je hebt de relaties ertussen nodig.

Traditionele NLP gaat hier slecht mee om, omdat elke entiteit als op zichzelf staande informatie wordt behandeld. Je kunt “MacBook Pro”, “2021” en “batterijproblemen” als aparte entiteiten extraheren, maar hebt dan complexe regels nodig om te bepalen welke details bij welke producten horen. Deze aanpak stort snel in als er meerdere producten of klanten in dezelfde tekst voorkomen.

LangExtract lost dit op door tijdens de eerste pass relaties te extraheren, in plaats van achteraf entiteiten te koppelen. Je kunt gerelateerde informatie groeperen met gedeelde attributen, terwijl je nog steeds precies bijhoudt waar elk onderdeel in de oorspronkelijke tekst staat. Laten we werknemerinformatie extraheren uit HR-documenten waarbij we mensen moeten koppelen aan hun functies, afdelingen en contactgegevens.

Relatie-extractie opzetten

In dit voorbeeld extraheren we werknemerinformatie uit bedrijfsmededelingen waarin meerdere details per persoon aan elkaar gekoppeld moeten worden:

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"}
           )
       ]
   )
]Mogelijk gemaakt door

Het attribuut employee_group werkt als een koppelmechanisme — alle entiteiten met dezelfde waarde voor employee_group horen bij dezelfde persoon. Zo kun je complexe, meerdelige informatie extraheren en toch bijhouden welke details bij elkaar horen.

Relaties extraheren

Laten we nu extraheren uit een bedrijfsmededeling met meerdere medewerkers:

# 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")Mogelijk gemaakt door

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 entitiesMogelijk gemaakt door

Werken met relatiegroepen

Na de extractie kun je de gerelateerde entiteiten groeperen om de volledige informatie per medewerker te zien. Dit vraagt om wat Python-code om de verspreide entiteiten weer in logische groepen te ordenen:

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']}")Mogelijk gemaakt door

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: phoneMogelijk gemaakt door

Dit doet de code stap voor stap:

1. defaultdict(list) maakt een dictionary waarbij elke nieuwe entry automatisch als lege lijst start
2. extraction.attributes.get("employee_group") haalt veilig de groeps-ID op uit de attributen van elke entiteit en geeft None terug als die niet bestaat
3. employee_groups[group_id].append(extraction) voegt elke entiteit toe aan de lijst voor zijn groep
4. De geneste lussen printen vervolgens de complete informatie per groep, georganiseerd per medewerker

De defaultdict is een Python-collectie die ontbrekende entries automatisch aanmaakt. Wanneer je employee_groups["Mike Chen"] voor het eerst benadert, wordt automatisch een lege lijst voor die medewerker gemaakt. Zo hoef je niet te controleren of elke medewerker al bestaat in de dictionary.

Met deze groepering kun je complete medewerkersprofielen herbouwen uit de verspreide informatie in de oorspronkelijke tekst, terwijl je de exacte bronlocaties van elk datapunt behoudt.

Relatievisualisaties maken

De HTML-visualisatie wordt nog waardevoller met relatiedata, omdat die zowel individuele entiteiten als hun verbanden toont:

# 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'")Mogelijk gemaakt door

De relatievisualisatie laat zien hoe verschillende stukjes informatie samenkomen tot complete medewerkersrecords, zodat je eenvoudig kunt verifiëren dat de AI gerelateerde details uit de oorspronkelijke mededeling correct heeft geïdentificeerd en gegroepeerd.

LangExtract gebruiken met verschillende modelproviders

LangExtract werkt met meerdere AI-modelproviders, elk met eigen afwegingen tussen kosten, snelheid en nauwkeurigheid. De Gemini-modellen van Google werken out of the box met ingebouwde schemasupport en zijn daarmee de makkelijkste optie voor de meeste extractietaken. De GPT-modellen van OpenAI leveren vaak hogere nauwkeurigheid, maar vereisen extra configuratie en zijn duurder per extractie.

# 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
)Mogelijk gemaakt door

Voor lokale verwerking of wanneer je API-kosten wilt vermijden, kun je modellen lokaal draaien met Ollama. Lokale modellen werken goed voor eenvoudigere extractietaken en geven je volledige controle over je data, al werken ze doorgaans langzamer en mogelijk minder nauwkeurig dan cloudopties.

# 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
)Mogelijk gemaakt door

Opschalen naar productie

Echte tekst lijkt in de verste verte niet op onze schone voorbeelden. Je krijgt rapporten van 50 pagina’s met rommelige opmaak, klantmails vol typefouten en pdf’s met rare spatiëring. Sommige documenten tellen duizenden woorden verspreid over secties, en de belangrijke informatie kan overal verstopt zitten.

LangExtract gaat met deze rommelige situaties om met drie hoofdtools: meerdere documenten tegelijk verwerken, de extractie meerdere keren proberen en grote documenten in kleinere stukken knippen. In plaats van één document per keer te verwerken, kun je er veel tegelijk aanpakken, wat alles veel sneller maakt.

# 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
)Mogelijk gemaakt door

De instelling max_workers bepaalt hoeveel documenten tegelijk verwerkt worden. Meer workers betekent snellere resultaten, maar kost ook meer geld en kan API-limieten raken. Begin met 10–20 workers en kijk hoe het gaat.

Meerdere extractiepogingen helpen informatie te vinden die de eerste keer gemist wordt. LangExtract voert de extractie meerdere keren uit en combineert de resultaten. Dit levert meer details op, maar kost meer tijd en geld.

Documenten in stukken knippen helpt bij lange teksten. De instelling max_char_buffer verdeelt grote documenten in kleinere stukken die beter werken met AI-modellen. Kleine chunks (1000–2000 tekens) vangen meer details, terwijl grote chunks (3000–5000 tekens) meer context behouden maar mogelijk dingen missen.

# 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
)Mogelijk gemaakt door

Productiewerk betekent omgaan met problemen. Documenten kunnen codec fouten hebben, netwerkverbindingen kunnen falen en API’s kunnen limieten opleggen aan de verwerkingssnelheid. Houd je extractiejobs in de gaten, voeg retry-logica toe voor mislukte documenten en bewaak je uitgaven per AI-provider.

Werk je met verschillende documenttypen, stel dan per type aparte extractieregels in. Juridische contracten vragen om andere prompts dan klantmails. Financiële rapporten hebben andere chunkgroottes nodig dan socialmediaposts. Bouw aparte pipelines per documenttype in plaats van één systeem alles te laten doen.

LangExtract vs. andere NLP-bibliotheken

LangExtract hanteert een andere aanpak dan traditionele NLP-bibliotheken. Waar de meeste bibliotheken vertrouwen op voorgetrainde modellen of regelgebaseerde systemen, gebruikt LangExtract Large Language Models die context en betekenis kunnen begrijpen zoals mensen dat doen. Laten we het vergelijken met drie populaire Python NLP-bibliotheken om te zien wanneer je voor LangExtract kiest.

spaCy

spaCy richt zich op snelheid en productieklare NLP-taken zoals tokenization, part-of-speech tagging en named entity recognition. Het wordt geleverd met voorgetrainde modellen die gangbare entiteiten herkennen zoals personen, organisaties en locaties, maar heeft moeite met domeinspecifieke entiteiten of aangepaste categorieën. spaCy blinkt uit in het snel verwerken van veel tekst, maar je moet modellen hertrainen of complexe regels schrijven om aangepaste informatie te extraheren.

LangExtract haalt deze complexiteit weg door je aangepaste entiteiten te laten definiëren met eenvoudige voorbeelden en prompts, en biedt bovendien exacte bronlocaties die spaCy niet bijhoudt.

NLTK (Natural Language Toolkit)

NLTK (Natural Language Toolkit) is ontworpen voor onderwijs en onderzoek en biedt een breed scala aan NLP-algoritmen en datasets. Het levert bouwstenen voor tekstverwerking, maar vraagt om aanzienlijke programmeerkennis om complete oplossingen te bouwen. NLTK is geschikt om NLP-concepten te leren en te prototypen, maar voor productieklare extractiesystemen moet je meerdere NLTK-componenten combineren en veel code schrijven.

LangExtract biedt out of the box een complete oplossing — je definieert wat je wilt via voorbeelden in plaats van algoritmen te programmeren, en je krijgt interactieve visualisaties zonder extra ontwikkelwerk.

Transformers (Hugging Face)

Transformers (Hugging Face) biedt toegang tot state-of-the-art transformermodellen voor uiteenlopende NLP-taken, waaronder named entity recognition en question answering. Hoewel krachtig, vraagt dit om machinelearningexpertise om modellen voor specifieke domeinen te fine-tunen, en het biedt geen ingebouwde brontracering of relatie-extractie. Je moet modeldeployments regelen, verschillende modelformaten beheren en je eigen visualisatietools bouwen.

LangExtract schermt de complexiteit van werken met verschillende AI-modellen af, regelt brontracering automatisch en levert relatie-extractie via eenvoudige attribuutgroepering in plaats van complexe modelarchitecturen.

Conclusie

LangExtract verandert textextractie van complexe regels schrijven naar gesprekken voeren met AI over je data. Je hebt geleerd hoe je aangepaste entiteiten instelt met eenvoudige prompts en voorbeelden, gerelateerde informatie groepeert via relatie-extractie en interactieve visualisaties maakt die precies tonen waar elk datapunt vandaan komt. De bibliotheek gaat om met productie-uitdagingen zoals parallelle verwerking en documentchunking, waardoor het praktisch inzetbaar is voor echte toepassingen met rommelige, inconsistente tekst.

Of je nu supporttickets verwerkt, juridische documenten analyseert of inzichten uit onderzoeksartikelen haalt, LangExtract biedt een intuïtievere aanpak dan traditionele NLP-bibliotheken. In plaats van tijd te besteden aan modeltraining of regels schrijven, kun je je richten op het definiëren van welke informatie telt voor jouw specifieke usecase. Begin met eenvoudige extracties op je eigen tekstdata en schaal vervolgens op met de productietechnieken uit deze tutorial.