LangExtract: Transform text into structured data with AI



Table of contents

What is LangExtract?

Key features of LangExtract

Precise source grounding: Every piece of extracted data is mapped to its exact position in the original text. This means you can always trace back and highlight the original context of an extraction. For example, if LangExtract pulls a patient’s name and diagnosis from a medical report, it will also give you the character offset or span in the document where that information came from. This grounding builds trust in the output, as you can verify each fact against the source.
Reliable structured outputs: LangExtract outputs follow a consistent schema that you define through examples. You provide a few example outputs (a technique known as few-shot prompting), and the model is guided to produce data in that exact format. Under the hood, LangExtract even leverages features like controlled generation (available in models like Gemini) to enforce JSON schemas or structured output formats. The result is that you get well-structured data (lists, dictionaries, classes) rather than free-form text, every time. This consistency makes post-processing and integration with databases or analysis tools much easier.
Optimized for long documents: Working with long texts (think research papers or entire books) can trip up normal LLM pipelines, but LangExtract is optimized for these cases. It uses smart text chunking, parallel processing, and multi-pass extraction strategies to handle very large documents. In practice, LangExtract will break a long text into manageable chunks, extract relevant info from each, then merge results and even perform additional passes to catch things that a single pass might miss. This “needle-in-a-haystack” approach ensures high recall even in million-character contexts.
Interactive visualization: To help you review and refine extraction results, LangExtract can generate an interactive HTML report of the findings. This self-contained visualization highlights each extracted entity in the context of the original text. You can scroll through your document and see, for instance, every medication name highlighted with its parsed dosage. This makes validation and debugging of the extraction much more intuitive. (We’ll see in the tutorial how to create this and how W&B Weave can further enhance visualization.)
Flexible LLM support: LangExtract isn’t tied to a single AI model. You can use it with cloud-based LLMs like Google’s Gemini (for the best quality and support for controlled output) or switch to local models via the built-in Ollama integration if you need to run without an internet connection or keep data on-premises. This flexibility lets you balance performance, cost, and privacy. Whether you have access to a state-of-the-art model or prefer a smaller open-source model, LangExtract can work with it by adjusting the model_id and relevant settings.
Adaptable to any domain: You can apply LangExtract to virtually any domain or language. There’s no training required — just describe what you need and provide a handful of examples. LangExtract will utilize the LLM’s understanding (and general world knowledge) to interpret context-specific terms. For instance, in finance, it could extract “ticker symbols and prices” from news articles, while in medicine, it could extract “symptoms and vital signs” from clinical notes. Because the approach relies on prompting, switching domains is as simple as changing your instructions and examples. (LangExtract also supports many languages out of the box, so you aren’t limited to English texts.)
Leverages world knowledge when needed: Through clever prompt design, LangExtract allows you to control how much the LLM should rely on outside knowledge versus sticking strictly to the text. You can instruct the model to only use evidence in the text (for high precision) or to infer a bit of implied information (leveraging the model’s training knowledge) if that’s useful. For example, you might extract a drug name from a note and let the model add a standard dosage form from its knowledge. LangExtract leaves this choice to you via prompt instructions and examples, ensuring the output meets your needs for completeness vs. verifiability.

How does LangExtract ensure precise source grounding and reliable structured outputs?



Precise source grounding

Reliable structured outputs

Putting it together

Why use LangExtract?

Applying LangExtract to specialized domains

Applying LangExtract to the medical domain

Applying LangExtract to the financial domain

No fine-tuning needed

Integration with large language models like Gemini

Using Gemini through LangExtract

Flexible backend support

Step-by-step tutorial using W&B Weave

Install LangExtract and set up our environment (including W&B for logging results).
Define a custom extraction task with a prompt and examples.
Run LangExtract to extract data from sample text.
Visualize the results, both using LangExtract’s built-in HTML generator and by logging the data to Weights & Biases for interactive analysis with Weave.
Explore some advanced options and next steps.

Step 1: Installation and setup

!pip install langextract wandb weave pandas

Defaulting to user installation because normal site-packages is not writeable
Collecting langextract...
Collecting wandb...
Collecting weave...
...
Successfully installed langextract-1.0.8 wandb-0.15.5 weave-0.20.1 pandas-2.1.0 ...

import langextract as lx
import wandb

export LANGEXTRACT_API_KEY="YOUR-GEMINI-API-KEY"

wandb login

Step 2: Define your extraction task

Characters (people mentioned),
Emotions (explicit expressions of feeling),
Relationships (descriptions of relationships or comparisons).

# 1. Define the prompt with instructions for the extraction
prompt = """Extract characters, emotions, and relationships in order of appearance.
Use exact text from the document for each extraction (no paraphrasing and no overlapping text).
Provide useful attributes for each entity: for example, an emotion should have a "feeling" attribute describing it, 
and a relationship should have a "type" attribute (such as family, friendship, metaphor, etc.)."""

# 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"}
            ),
            lx.data.Extraction(
                extraction_class="emotion",
                extraction_text="But soft!",
                attributes={"feeling": "gentle awe"}
            ),
            lx.data.Extraction(
                extraction_class="relationship",
                extraction_text="Juliet is the sun",
                attributes={"type": "metaphor"}
            )
        ]
    )
]

The prompt clearly explains what to extract and sets some ground rules (like using exact text and adding attributes). This helps the LLM focus and not do unwanted things (like summarizing instead).
The example is a snippet from Romeo and Juliet. In that snippet, we manually identified:
"ROMEO" as a character, with an attribute indicating his emotional state is wonder (since he’s marveling at Juliet’s beauty).
"But soft!" as an expression of emotion, with an attribute gentle awe (this is an interpretation of that phrase).
"Juliet is the sun" as a relationship extraction, labeling it a metaphor type relationship (Juliet being compared to the sun).
We used lx.data.ExampleData and lx.data.Extraction to construct these examples in the exact format LangExtract expects.

Step 3: Run the extraction

# Define the input text to analyze
input_text = "Lady Juliet gazed longingly at the stars, her heart aching for Romeo."

# Run the extraction using LangExtract
result = lx.extract(
    text_or_documents=input_text,
    prompt_description=prompt,
    examples=examples,
    model_id="gemini-2.5-flash"   # using the default recommended Gemini model
)

# Print out the structured results
for ext in result.extractions:
    print(f"{ext.extraction_class.upper()}: {ext.extraction_text} -> {ext.attributes}")

We call lx.extract(...) with our input_text, the prompt_description and examples we prepared, and specify the model_id. Here, "gemini-2.5-flash" is used, which is a fast variant of Google’s Gemini LLM that works well for many tasks. (Ensure that your LANGEXTRACT_API_KEY is set for authentication, as described in Step 1.)
The function will return an object (let’s call it an annotated document result) that contains the original text and a list of extractions (result.extractions). We then loop through each extraction and print the class, the exact text that was extracted, and the attributes.

CHARACTER: Lady Juliet -> {'emotional_state': 'longing'}
EMOTION: longingly -> {'feeling': 'yearning'}
RELATIONSHIP: her heart aching for Romeo -> {'type': 'romantic love'}

Lady Juliet as a character, with the attribute indicating her emotional state is “longing”.
“longingly” (from the phrase "gazed longingly at the stars") as an emotion, with a feeling of “yearning”.
“her heart aching for Romeo” as a relationship, with the type labeled as “romantic love”.

Step 4: Visualize and review results

4a. Generate an interactive HTML report (LangExtract visualization)

# Save the extraction results to a JSONL file (each line could represent a document's results)
lx.io.save_annotated_documents([result], output_name="extraction_results.jsonl")

# Generate an interactive HTML visualization from the JSONL file
html_content = lx.visualize("extraction_results.jsonl")

# Write the HTML content to a file
with open("visualization.html", "w") as f:
    f.write(html_content)

print("Interactive visualization saved as visualization.html")

save_annotated_documents takes a list of results (we only have one in [result]) and writes them to a file. The output is extraction_results.jsonl which is a JSONL (JSON Lines) file. If you open it, you’ll see a JSON representation of result including the text and all extraction entries.
lx.visualize reads that JSONL and creates an HTML string containing the interactive visualization. We then save that string to visualization.html.
The print is just to confirm we saved the file.

Interactive visualization saved as visualization.html

4b. Log results to W&B and explore with Weave

A table of extractions: each row will be one extraction with columns for class, text, and attributes.
A summary metric (for example, the total number of extractions) just as an example of logging metadata.

wandb.init(project="langextract-tutorial", name="Extraction-run-demo", resume="allow")

import pandas as pd

# Convert extraction results into a list of dicts for tabular logging
data = []
for ext in result.extractions:
    data.append({
        "Class": ext.extraction_class,
        "Extracted Text": ext.extraction_text,
        "Attributes": str(ext.attributes)   # convert attributes dict to string for display
    })

df = pd.DataFrame(data)

# Create a W&B Table from the DataFrame
extraction_table = wandb.Table(dataframe=df)

# Log the table and a count metric to the W&B run
wandb.log({
    "extraction_results": extraction_table,
    "extraction_count": len(result.extractions)
})

wandb.finish()  # end the W&B run

wandb: Tracking run with wandb version 0.15.5
wandb: Run data is saved locally in /your_dir/wandb/run-<id>/
wandb: Run `langextract-tutorial/Extraction-run-demo` started, view it at:
wandb: https://wandb.ai/your-username/langextract-tutorial/runs/<run-id>
wandb: Logged data and finished run (3 extraction_results items, 1 metrics)
wandb: Run page: https://wandb.ai/your-username/langextract-tutorial/runs/<run-id>

A Table named "extraction_results" under the run’s overview or the "media" tab. It should have one row for each extraction we printed earlier. You can sort this table by Class, search within it, or scroll through if you had many results.
The extraction_count metric under the run’s summary (in this case it’s 3). This is not very interesting with one run, but if you processed multiple texts or tried different models, you could compare these counts between runs.

Step 5: Advanced tips and next steps

Using local or alternative models: If you don’t have access to Gemini or want to run entirely offline, LangExtract supports local models through Ollama. After installing and starting an Ollama server with a model (say Llama 2), you can call:

result_local = lx.extract(..., model_id="ollama:llama2")

This tells LangExtract to use your local Llama2 model for inference. Keep in mind that local models may be slower or less accurate than a powerful cloud model, but they remove external dependencies and costs. Make sure the model you specify in model_id is one you’ve loaded in Ollama. Similarly, with some coding, LangExtract could be extended to other providers’ APIs – but the built-in path is optimized for Gemini or Ollama.
Batch processing and long texts: If you have multiple documents or a very long document to process, LangExtract can handle that too. You can pass a list of texts or even a URL (as text_or_documents) to lx.extract, and it will process them in sequence or in parallel depending on length. By default, it does chunking automatically. Advanced parameters like max_workers (for parallel threads) and extraction_passes (for multiple model passes on the text) can be tuned. For example:

result = lx.extract(text_or_documents=long_text, prompt_description=prompt, examples=examples,
                    model_id="gemini-2.5-flash", extraction_passes=2)

would run two passes to attempt a higher recall of extractions in a very large long_text. Use these only as needed, since extra passes mean more API calls. The good news is LangExtract manages chunking internally, so you typically don’t need to split the text yourself.
W&B Models for custom models: If you decide to train or fine-tune your own model for the extraction task (for instance, fine-tuning a smaller LLM on domain-specific data to possibly improve performance or reduce cost), consider using W&B Models to version and deploy it. You could register your fine-tuned model in the W&B Models registry and use W&B’s inference service to get an endpoint. LangExtract could then be pointed to that endpoint (similar to how we used Gemini). This way, you maintain the benefits of LangExtract’s schema and grounding while plugging in a model tailor-made for your data. W&B will help you keep track of which model version was used for which runs, and you can compare their performance by analyzing the extraction outputs logged to W&B.
Evaluate and refine: Extraction quality can sometimes be subjective. It’s good practice to evaluate how LangExtract is performing on your specific task. You might manually inspect a sample of outputs (using the HTML viz or W&B Weave as we did) and note if the model is missing anything or making mistakes. Then refine your approach:
Add or adjust example prompts to clarify ambiguous cases.
Use a larger model (e.g., gemini-2.5-pro) if the smaller one struggles with nuance.
If the model is extracting too aggressively (false positives), add instructions in the prompt to be more selective or give counter-examples of what not to extract. Because you can iterate quickly without retraining, you can do several prompt tweaks and re-run to zero in on the best prompt for your needs.
Try it on your data (next challenge): Now that you’ve walked through a simple example, try applying LangExtract to a piece of text from your domain. For instance:
If you work in finance, take a paragraph from a financial report or news article and set up LangExtract to pull out key financial metrics or events.
If you’re in healthcare, try a snippet of a clinical note to extract medical conditions, treatments, and patient details.
If you have no domain preference, even try another literature piece or a Wikipedia article and extract some structured info (like people, dates, and events mentioned).
Set up a new prompt and examples for your scenario, then run the extraction. Use the W&B integration to log the results and see them in a table. This will solidify your understanding and uncover any new challenges in prompt design for that text.
Scaling up: Once you’re comfortable with single documents, you can scale out to many documents. You might write a loop to process a folder of text files or a list of URLs. With W&B, you could log each document’s results as a separate run or as part of a single run (maybe as separate table items or artifacts). This would let you monitor progress and review outputs collectively. W&B Weave would allow you to merge results from multiple runs if needed to do a corpus-wide analysis (for example, summarizing how often certain entities appear across 100 documents).
Performance considerations: Keep an eye on the cost and speed if you use a cloud model for many extractions. Each lx.extract call will consume tokens in the LLM and incur latency. Using smaller models, or filtering your text to remove irrelevant sections before feeding to LangExtract, can save time. LangExtract’s chunking helps, but extremely long documents will still take proportionally longer (and possibly multiple API calls). If you plan to extract from thousands of documents, consider asynchronous or batch strategies and use W&B to track the batches. You can even log custom timing metrics (e.g., how long each extraction took) with W&B to identify bottlenecks.

Custom model integration: For those developing their own NLP models, LangExtract’s approach can be a blueprint. If you have a model that you’ve fine-tuned for a specific extraction (say a custom BERT or T5 model), you could still use LangExtract’s data structures and visualization by writing a small wrapper that feeds your model and outputs in LangExtract’s format. Although LangExtract is built with LLMs in mind, its principles of source-grounded, schema-driven extraction apply broadly.
Stay updated: LangExtract is a young project (as of 2025). Keep an eye on its GitHub repo for updates – new features or support for more models may be added. The community might contribute new examples (for medicine, law, etc.) that you can learn from. Likewise, W&B is continuously improving Weave and other LLMOps tools, which could further simplify integration (for example, a future update might let you deploy a LangExtract pipeline and monitor it entirely through W&B).

Conclusion

Precision and trust: LangExtract’s extractions are grounded in the source material, so you can always verify them. This is crucial in domains like medicine and law where provenance is everything.
Consistency: By enforcing structured outputs via examples and schemas, LangExtract produces clean data ready for analysis or storage, saving you from the headache of parsing messy model outputs.
Flexibility: The same approach works across domains (finance, healthcare, literature, you name it) and even across languages. We only scratched the surface with an English literature example, but you could apply LangExtract to Chinese financial documents or Spanish legal texts just as well.
Integration with LLMs and tools: LangExtract lets you leverage cutting-edge LLMs like Google’s Gemini for high-quality results, or use local models for privacy. And with integrations into tools like W&B Weave, you get visibility into the process – you can monitor, visualize, and share the results easily. This makes it not just a development tool, but something you can use in production with confidence (imagine a pipeline where new data comes in, LangExtract structures it, and W&B dashboards show live updates of extracted insights!).

Sources

Google Developers Blog – Introducing LangExtract: A Gemini powered information extraction library (July 30, 2025) – developers.googleblog.com
Google LangExtract GitHub Repository – LangExtract: Extracting structured information from text using LLMs – github.com/google/langextract
LangExtract Documentation and PyPI Description – Project details and usage examples for LangExtract – pypi.org/project/langextract
LangExtract Official Website – Overview of features and getting started – langextract.io
Nateross Blog – Google LangExtract: The Ultimate AI Developer's Guide to Structured Information Extraction (Aug 25, 2025) – n8rs.dev