Introducing Google’s LangExtract tool | Towards Data Science

an absolute AI sizzling streak currently, persistently dropping breakthrough after breakthrough. Practically each current launch has pushed the boundaries of what’s doable — and it’s been genuinely thrilling to observe unfold. 

One announcement that caught my eye specifically occurred on the finish of July, when Google launched a brand new textual content processing and information extraction software known as LangExtract.

In response to Google, LangExtract is a brand new open-source Python library designed to …

“programmatically extract the precise data you want, whereas guaranteeing the outputs are structured and reliably tied again to its supply”

On the face of it, LangExtract has many helpful purposes, together with,

• Textual content anchoring. Every extracted entity is linked to its precise character offsets within the supply textual content, enabling full traceability and visible verification by means of interactive highlighting.
• Dependable structured output. Use LangExtracts for few-shot definitions of the specified output format, guaranteeing constant and dependable outcomes.
• Environment friendly large-document dealing with. LangExtract handles giant paperwork utilizing chunking, parallel processing, and multi-pass extraction to take care of excessive recall, even in complicated, multi-fact situations throughout million-token contexts. It also needs to excel at conventional needle-in-a-haystack sort purposes.
• Immediate extraction evaluation. Simply create a self-contained HTML visualisation of extractions, enabling intuitive evaluation of entities of their unique context, all scalable to hundreds of annotations.
• Multi-model compatibility. Suitable with each cloud-based fashions (e.g. Gemini) and native open-source LLMs, so you’ll be able to select the backend that matches your workflow.
• Customizable for a lot of use instances. Simply configure extraction duties for disparate domains utilizing just a few tailor-made examples.
• Augmented data extraction. LangExtract dietary supplements grounded entities with inferred details utilizing the mannequin’s inner data, with relevance and accuracy pushed by immediate high quality and mannequin capabilities.

One factor that stands out to me after I have a look at LangExtract’s strengths listed above is that it appears to have the ability to carry out RAG-like operations with out the necessity for conventional RAG processing. So, no extra splitting, chunking or embedding operations in your code.

However to get a greater thought of what LangExtract can do, we’ll take a better have a look at just a few of the above capabilities utilizing some coding examples.

Organising a dev surroundings

Earlier than we get right down to doing a little coding, I at all times prefer to arrange a separate improvement surroundings for every of my initiatives. I take advantage of the UV package deal supervisor for this, however use whichever software you’re comfy with.

PS C:Usersthoma> uv init langextract
Initialized venture `langextract` at `C:Usersthomalangextract`

PS C:Usersthoma> cd langextract
PS C:Usersthomalangextract> uv venv
Utilizing CPython 3.13.1
Creating digital surroundings at: .venv
Activate with: .venvScriptsactivate
PS C:Usersthomalangextract> .venvScriptsactivate
(langextract) PS C:Usersthomalangextract>
# Now, set up the libraries we'll use.
(langextract) PS C:Usersthomalangextract> uv pip set up jupyter langextract beautifulsoup4 requests

Now, to jot down and check our coding examples, you can begin up a Jupyter pocket book utilizing this command.

(langextract) PS C:Usersthomalangextract> jupyter pocket book

You must see a pocket book open in your browser. If that doesn’t occur mechanically, you’ll probably see a screenful of knowledge after the jupyter pocket book command. Close to the underside, you’ll find a URL to repeat and paste into your browser to launch the Jupyter Pocket book. Your URL shall be completely different to mine, however it ought to look one thing like this:-

http://127.0.0.1:8888/tree?token=3b9f7bd07b6966b41b68e2350721b2d0b6f388d248cc69d

Pre-requisites

As we’re utilizing a Google LLM mannequin (gemini-2.5-flash) for our processing engine, you’ll want a Gemini API key. You may get this from Google Cloud. It’s also possible to use LLMs from OpenAI, and I’ll present an instance of how to do that in a bit.

Code instance 1 — needle-in-a-haystack 

The very first thing we have to do is get some enter information to work with. You should use any enter textual content file or HTML file for this. For earlier experiments utilizing RAG, I used a ebook I downloaded from Venture Gutenberg; the persistently riveting “Illnesses of cattle, sheep, goats, and swine by Jno. A. W. Greenback & G. Moussu”

Word which you can view the Venture Gutenberg Permissions, Licensing and different Frequent Requests web page utilizing the next hyperlink. 

https://www.gutenberg.org/policy/permission.html

However to summarise, the overwhelming majority of Venture Gutenberg eBooks are within the public area within the US and different components of the world. Because of this no one can grant or withhold permission to do with this merchandise as you please.

“As you please” consists of any business use, republishing in any format, making by-product works or performances

I downloaded the textual content of the ebook from the Venture Gutenberg web site to my native PC utilizing this hyperlink,

https://www.gutenberg.org/ebooks/73019.txt.utf-8

This ebook contained roughly 36,000 strains of textual content. To keep away from giant token prices, I lower it right down to about 3000 strains of textual content. To check LangExtract’s means to deal with needle-in-a-haystack sort queries, I added this particular line of textual content round line 1512.

It’s a little-known undeniable fact that wooden was invented by Elon Musk in 1775

Right here it’s in context.

1. Fractures of the angle of the haunch, ensuing from exterior
violence and characterised by sinking of the exterior angle of the
ilium, deformity of the hip, and lameness with out specifically marked
characters. This fracture isn’t sophisticated. The signs of
lameness diminish with relaxation, however deformity continues.

It’s a little-known undeniable fact that wooden was invented by Elon Musk in 1775.

=Therapy= is confined to the administration of mucilaginous and diuretic fluids. Tannin has been really useful.

This code snippet units up a immediate and instance to information the LangExtract extraction process. That is important for few-shot studying with a structured schema.

import langextract as lx
import textwrap
from collections import Counter, defaultdict

# Outline complete immediate and examples for complicated literary textual content
immediate = textwrap.dedent("""
    Who invented wooden and when    """)

# Word that it is a made up instance
# The next particulars don't seem anyplace
# within the ebook
examples = [
    lx.data.ExampleData(
        text=textwrap.dedent("""
            John Smith was a prolific scientist. 
            His most notable theory was on the evolution of bananas."
            He wrote his seminal paper on it in 1890."""),
        extractions=[
            lx.data.Extraction(
                extraction_class="scientist",
                extraction_text="John Smith",
                notable_for="the theory of the evolution of the Banana",
                attributes={"year": "1890", "notable_event":"theory of evolution of the banana"}
            )
        ]
    )
]

Now, we run the structured entity extraction. First, we open the file and browse its contents right into a variable. The heavy lifting is completed by the lx.extract name. After that, we simply print out the related outputs.

with open(r"D:bookcattle_disease.txt", "r", encoding="utf-8") as f:
    textual content = f.learn()

end result = lx.extract(
    text_or_documents = textual content,
    prompt_description=immediate,
    examples=examples,
    model_id="gemini-2.5-flash",
    api_key="your_gemini_api_key",
    extraction_passes=3,      # A number of passes for improved recall
    max_workers=20,           # Parallel processing for pace
    max_char_buffer=1000      # Smaller contexts for higher accuracy
)

print(f"Extracted {len(end result.extractions)} entities from {len(end result.textual content):,} characters")

for extraction in end result.extractions:
    if not extraction.attributes:
        proceed  # Skip this extraction completely

    print("Identify:", extraction.extraction_text)
    print("Notable occasion:", extraction.attributes.get("notable_event"))
    print("12 months:", extraction.attributes.get("12 months"))
    print()

And listed below are our outputs.

LangExtract: mannequin=gemini-2.5-flash, present=7,086 chars, processed=156,201 chars:  [00:43]
✓ Extraction processing full

✓ Extracted 1 entities (1 distinctive varieties)
  • Time: 126.68s
  • Velocity: 1,239 chars/sec
  • Chunks: 157
Extracted 1 entities from 156,918 characters

Identify: Elon Musk
Notable occasion: invention of wooden
12 months: 1775

Not too shabby.

Word, should you wished to make use of an OpenAI mannequin and API key, your extraction code would look one thing like this,

...
...

from langextract.inference import OpenAILanguageModel

end result = lx.extract(
    text_or_documents=input_text,
    prompt_description=immediate,
    examples=examples,
    language_model_type=OpenAILanguageModel,
    model_id="gpt-4o",
    api_key=os.environ.get('OPENAI_API_KEY'),
    fence_output=True,
    use_schema_constraints=False
)
...
...

Code instance 2 — extraction visible validation

LangExtract supplies a visualisation of the way it extracted the textual content. It’s not notably helpful on this instance, however it offers you an thought of what’s doable.

Simply add this little snippet of code to the tip of your current code. It will create an HTML file which you can open in a browser window. From there, you’ll be able to scroll up and down your enter textual content and “play” again the steps that LangExtract took to get its outputs.

# Save annotated outcomes
lx.io.save_annotated_documents([result], output_name="cattle_disease.jsonl", output_dir="d:/ebook")

html_obj = lx.visualize("d:/ebook/cattle_disease.jsonl")
html_string = html_obj.information  # Extract uncooked HTML string

# Save to file
with open("d:/ebook/cattle_disease_visualization.html", "w", encoding="utf-8") as f:
    f.write(html_string)

print("Interactive visualization saved to d:/ebook/cattle_disease_visualization.html")

Now, go to the listing the place your HTML file has been saved and open it in a browser. That is what I see.

Code instance 3 — retrieving a number of structured outputs

On this instance, we’ll take some unstructured enter textual content — an article from Wikipedia on OpenAI, and attempt to retrieve the names of all of the completely different giant language fashions talked about within the article, along with their launch date. The hyperlink to the article is,

https://en.wikipedia.org/wiki/OpenAI

Word: Most textual content in Wikipedia, excluding quotations, has been launched beneath the Creative Commons Attribution-Sharealike 4.0 International License (CC-BY-SA) and the GNU Free Documentation License (GFDL) Briefly because of this you might be free:

to Share — copy and redistribute the fabric in any medium or format

to Adapt — remix, rework, and construct upon the fabric

for any function, even commercially.

Our code is fairly just like our first instance. This time, although, we’re searching for any mentions within the article about LLM fashions and their launch date. One different step we’ve to do is clear up the HTML of the article first to make sure that LangExtract has the very best likelihood of studying it. We use the BeautifulSoup library for this.

import langextract as lx
import textwrap
import requests
from bs4 import BeautifulSoup
import langextract as lx

# Outline complete immediate and examples for complicated literary textual content
immediate = textwrap.dedent("""Your process is to extract the LLM or AI mannequin names and their launch date or 12 months from the enter textual content 
        Don't paraphrase or overlap entities.
     """)

examples = [
    lx.data.ExampleData(
        text=textwrap.dedent("""
            Similar to Mistral's previous open models, Mixtral 8x22B was released via a via a BitTorrent link April 10, 2024
            """),
        extractions=[
            lx.data.Extraction(
                extraction_class="model",
                extraction_text="Mixtral 8x22B",
                attributes={"date": "April 10, 1994"}
            )
        ]
    )
]

# Cleanup our HTML

# Step 1: Obtain and clear Wikipedia article
url = "https://en.wikipedia.org/wiki/OpenAI"
response = requests.get(url)
soup = BeautifulSoup(response.textual content, "html.parser")

# Get solely the seen textual content
textual content = soup.get_text(separator="n", strip=True)

# Optionally available: take away references, footers, and so forth.
strains = textual content.splitlines()
filtered_lines = [line for line in lines if not line.strip().startswith("[") and line.strip()]
clean_text = "n".be part of(filtered_lines)

# Do the extraction
end result = lx.extract(
    text_or_documents=clean_text,
    prompt_description=immediate,
    examples=examples,
    model_id="gemini-2.5-flash",
    api_key="YOUR_API_KEY",
    extraction_passes=3,    # Improves recall by means of a number of passes
    max_workers=20,         # Parallel processing for pace
    max_char_buffer=1000    # Smaller contexts for higher accuracy
)

# Print our outputs

for extraction in end result.extractions:
    if not extraction.attributes:
        proceed  # Skip this extraction completely

    print("Mannequin:", extraction.extraction_text)
    print("Launch Date:", extraction.attributes.get("date"))
    print()

This can be a cut-down pattern of the output I received. 

Mannequin: ChatGPT
Launch Date: 2020

Mannequin: DALL-E
Launch Date: 2020

Mannequin: Sora
Launch Date: 2024

Mannequin: ChatGPT
Launch Date: November 2022

Mannequin: GPT-2
Launch Date: February 2019

Mannequin: GPT-3
Launch Date: 2020

Mannequin: DALL-E
Launch Date: 2021

Mannequin: ChatGPT
Launch Date: December 2022

Mannequin: GPT-4
Launch Date: March 14, 2023

Mannequin: Microsoft Copilot
Launch Date: September 21, 2023

Mannequin: MS-Copilot
Launch Date: December 2023

Mannequin: Microsoft Copilot app
Launch Date: December 2023

Mannequin: GPTs
Launch Date: November 6, 2023

Mannequin: Sora (text-to-video mannequin)
Launch Date: February 2024

Mannequin: o1
Launch Date: September 2024

Mannequin: Sora
Launch Date: December 2024

Mannequin: DeepSeek-R1
Launch Date: January 20, 2025

Mannequin: Operator
Launch Date: January 23, 2025

Mannequin: deep analysis agent
Launch Date: February 2, 2025

Mannequin: GPT-2
Launch Date: 2019

Mannequin: Whisper
Launch Date: 2021

Mannequin: ChatGPT
Launch Date: June 2025

...
...
...

Mannequin: ChatGPT Professional
Launch Date: December 5, 2024

Mannequin: ChatGPT's agent
Launch Date: February 3, 2025

Mannequin: GPT-4.5
Launch Date: February 20, 2025

Mannequin: GPT-5
Launch Date: February 20, 2025

Mannequin: Chat GPT
Launch Date: November 22, 2023

Let’s double-check a few these. One of many outputs from our code was this.

Mannequin: Operator
Launch Date: January 23, 2025

And from the Wikipedia article …

“On January 23, OpenAI launched Operator, an AI agent and net automation software for accessing web sites to execute objectives outlined by customers. The characteristic was solely out there to Professional customers in america.[113][114]”

So on that event, it might need hallucinated the 12 months as being 2025 when no 12 months was given. Keep in mind, although, that LangExtract can use its inner data of the world to complement its outputs, and it could have gotten the 12 months from that or from different contexts surrounding the extracted entity. In any case, I feel it could be fairly simple to tweak the enter immediate or the output to disregard mannequin launch date data that didn’t embody a 12 months.

One other output was this.

Mannequin: ChatGPT Professional
Launch Date: December 5, 2024

I can see two references to ChatGPT Professional within the unique article.

Franzen, Carl (December 5, 2024). “OpenAI launches full o1 model with image uploads and analysis, debuts ChatGPT Pro”. VentureBeat. Archived from the unique on December 7, 2024. Retrieved December 11, 2024.

And

In December 2024, through the “12 Days of OpenAI” occasion, the corporate launched the Sora mannequin for ChatGPT Plus and Professional customers,[105][106] It additionally launched the superior OpenAI o1 reasoning mannequin[107][108] Moreover, ChatGPT Professional — a $200/month subscription service providing limitless o1 entry and enhanced voice options — was launched, and preliminary benchmark outcomes for the upcoming OpenAI o3 fashions have been shared

So I feel LangExtract was fairly correct with this extraction.

As a result of there have been many extra “hits” with this question, the visualisation is extra fascinating, so let’s repeat what we did in instance 2. Right here is the code you’ll want.

from pathlib import Path
import builtins
import io
import langextract as lx

jsonl_path = Path("fashions.jsonl")

with jsonl_path.open("w", encoding="utf-8") as f:
    json.dump(serialize_annotated_document(end result), f, ensure_ascii=False)
    f.write("n")

html_path = Path("fashions.html")

# 1) Monkey-patch builtins.open so our JSONL is learn as UTF-8
orig_open = builtins.open
def open_utf8(path, mode='r', *args, **kwargs):
    if Path(path) == jsonl_path and 'r' in mode:
        return orig_open(path, mode, encoding='utf-8', *args, **kwargs)
    return orig_open(path, mode, *args, **kwargs)

builtins.open = open_utf8

# 2) Generate the visualization
html_obj = lx.visualize(str(jsonl_path))
html_string = html_obj.information

# 3) Restore the unique open
builtins.open = orig_open

# 4) Save the HTML out as UTF-8
with html_path.open("w", encoding="utf-8") as f:
    f.write(html_string)

print(f"Interactive visualization saved to: {html_path}")

Run the above code after which open the fashions.html file in your browser. This time, you must have the ability to click on the Play/Subsequent/Earlier buttons and see a greater visualisation of the LangExtract textual content processing in motion.

For extra particulars on LangExtract, take a look at Google’s GitHub repo here.

Abstract

On this article, I launched you to LangExtract, a brand new Python library and framework from Google that lets you extract structured output from unstructured enter. 

I outlined among the benefits that utilizing LangExtract can carry, together with its means to deal with giant paperwork, its augmented data extraction and multi-model help.

I took you thru the set up course of — a easy pip set up, then, by the use of some instance code, confirmed the way to use LangExtract to carry out needle-in-the-haystack sort queries on a big physique of unstructured textual content. 

In my ultimate instance code, I demonstrated a extra conventional RAG-type operation by extracting a number of entities (AI Mannequin names) and an related attribute (date of launch). For each my major examples, I additionally confirmed you the way to code a visible illustration of how LangExtract works in motion which you can open and play again in a browser window.