The LLM Graph Transformer operates in two distinct modes, every designed to generate graphs from paperwork utilizing an LLM in several eventualities.
- Device-Primarily based Mode (Default): When the LLM helps structured output or operate calling, this mode leverages the LLM’s built-in
with_structured_outputto make use of instruments. The instrument specification defines the output format, making certain that entities and relationships are extracted in a structured, predefined method. That is depicted on the left facet of the picture, the place code for the Node and Relationship courses is proven. - Immediate-Primarily based Mode (Fallback): In conditions the place the LLM doesn’t assist instruments or operate calls, the LLM Graph Transformer falls again to a purely prompt-driven method. This mode makes use of few-shot prompting to outline the output format, guiding the LLM to extract entities and relationships in a text-based method. The outcomes are then parsed via a customized operate, which converts the LLM’s output right into a JSON format. This JSON is used to populate nodes and relationships, simply as within the tool-based mode, however right here the LLM is guided completely by prompting relatively than structured instruments. That is proven on the appropriate facet of the picture, the place an instance immediate and ensuing JSON output are supplied.
These two modes be sure that the LLM Graph Transformer is adaptable to completely different LLMs, permitting it to construct graphs both straight utilizing instruments or by parsing output from a text-based immediate.
Word that you should use prompt-based extraction even with fashions that assist instruments/capabilities by setting the attribute ignore_tools_usage=True.
Device-based extraction
We initially selected a tool-based method for extraction because it minimized the necessity for in depth immediate engineering and customized parsing capabilities. In LangChain, the with_structured_output methodology permits you to extract data utilizing instruments or capabilities, with output outlined both via a JSON construction or a Pydantic object. Personally, I discover Pydantic objects clearer, so we opted for that.
We begin by defining a Node class.
class Node(BaseNode):
id: str = Area(..., description="Identify or human-readable distinctive identifier")
label: str = Area(..., description=f"Out there choices are {enum_values}")
properties: Elective[List[Property]]
Every node has an id, a label, and optionally available properties. For brevity, I haven’t included full descriptions right here. Describing ids as human-readable distinctive identifier is vital since some LLMs have a tendency to grasp ID properties in additional conventional approach like random strings or incremental integers. As an alternative we wish the title of entities for use as id property. We additionally restrict the obtainable label varieties by merely itemizing them within the labeldescription. Moreover, LLMs like OpenAI’s, assist an enum parameter, which we additionally use.
Subsequent, we check out the Relationship class
class Relationship(BaseRelationship):
source_node_id: str
source_node_label: str = Area(..., description=f"Out there choices are {enum_values}")
target_node_id: str
target_node_label: str = Area(..., description=f"Out there choices are {enum_values}")
kind: str = Area(..., description=f"Out there choices are {enum_values}")
properties: Elective[List[Property]]
That is the second iteration of the Relationship class. Initially, we used a nested Node object for the supply and goal nodes, however we rapidly discovered that nested objects lowered the accuracy and high quality of the extraction course of. So, we determined to flatten the supply and goal nodes into separate fields—for instance, source_node_id and source_node_label, together with target_node_id and target_node_label. Moreover, we outline the allowed values within the descriptions for node labels and relationship varieties to make sure the LLMs adhere to the desired graph schema.
The tool-based extraction method allows us to outline properties for each nodes and relationships. Under is the category we used to outline them.
class Property(BaseModel):
"""A single property consisting of key and worth"""
key: str = Area(..., description=f"Out there choices are {enum_values}")
worth: str
Every Property is outlined as a key-value pair. Whereas this method is versatile, it has its limitations. As an illustration, we will not present a novel description for every property, nor can we specify sure properties as necessary whereas others optionally available, so all properties are outlined as optionally available. Moreover, properties aren’t outlined individually for every node or relationship kind however are as an alternative shared throughout all of them.
We’ve additionally carried out a detailed system immediate to assist information the extraction. In my expertise, although, the operate and argument descriptions are likely to have a larger influence than the system message.
Sadly, in the intervening time, there isn’t a easy option to customise operate or argument descriptions in LLM Graph Transformer.
Immediate-based extraction
Since just a few industrial LLMs and LLaMA 3 assist native instruments, we carried out a fallback for fashions with out instrument assist. You can too set ignore_tool_usage=True to modify to a prompt-based method even when utilizing a mannequin that helps instruments.
Many of the immediate engineering and examples for the prompt-based method had been contributed by Geraldus Wilsen.
With the prompt-based method, we’ve got to outline the output construction straight within the immediate. You’ll find the entire immediate right here. On this weblog put up, we’ll simply do a high-level overview. We begin by defining the system immediate.
You're a top-tier algorithm designed for extracting data in structured codecs to construct a data graph. Your process is to determine the entities and relations specified within the consumer immediate from a given textual content and produce the output in JSON format. This output must be an inventory of JSON objects, with every object containing the next keys:- **"head"**: The textual content of the extracted entity, which should match one of many varieties specified within the consumer immediate.
- **"head_type"**: The kind of the extracted head entity, chosen from the desired listing of varieties.
- **"relation"**: The kind of relation between the "head" and the "tail," chosen from the listing of allowed relations.
- **"tail"**: The textual content of the entity representing the tail of the relation.
- **"tail_type"**: The kind of the tail entity, additionally chosen from the supplied listing of varieties.
Extract as many entities and relationships as attainable.
**Entity Consistency**: Guarantee consistency in entity illustration. If an entity, like "John Doe," seems a number of occasions within the textual content below completely different names or pronouns (e.g., "Joe," "he"), use essentially the most full identifier constantly. This consistency is important for making a coherent and simply comprehensible data graph.
**Essential Notes**:
- Don't add any further explanations or textual content.
Within the prompt-based method, a key distinction is that we ask the LLM to extract solely relationships, not particular person nodes. This implies we received’t have any remoted nodes, in contrast to with the tool-based method. Moreover, as a result of fashions missing native instrument assist sometimes carry out worse, we don’t permit extraction any properties — whether or not for nodes or relationships, to maintain the extraction output less complicated.
Subsequent, we add a few few-shot examples to the mannequin.
examples = [
{
"text": (
"Adam is a software engineer in Microsoft since 2009, "
"and last year he got an award as the Best Talent"
),
"head": "Adam",
"head_type": "Person",
"relation": "WORKS_FOR",
"tail": "Microsoft",
"tail_type": "Company",
},
{
"text": (
"Adam is a software engineer in Microsoft since 2009, "
"and last year he got an award as the Best Talent"
),
"head": "Adam",
"head_type": "Person",
"relation": "HAS_AWARD",
"tail": "Best Talent",
"tail_type": "Award",
},
...
]
On this method, there’s at present no assist for including customized few-shot examples or further directions. The one option to customise is by modifying the whole immediate via the immediateattribute. Increasing customization choices is one thing we’re actively contemplating.
Subsequent, we’ll check out defining the graph schema.
When utilizing the LLM Graph Transformer for data extraction, defining a graph schema is important for guiding the mannequin to construct significant and structured data representations. A well-defined graph schema specifies the forms of nodes and relationships to be extracted, together with any attributes related to every. This schema serves as a blueprint, making certain that the LLM constantly extracts related data in a approach that aligns with the specified data graph construction.
On this weblog put up, we’ll use the opening paragraph of Marie Curie’s Wikipedia web page for testing with an added sentence on the finish about Robin Williams.
from langchain_core.paperwork import Doctextual content = """
Marie Curie, 7 November 1867 – 4 July 1934, was a Polish and naturalised-French physicist and chemist who carried out pioneering analysis on radioactivity.
She was the primary girl to win a Nobel Prize, the primary individual to win a Nobel Prize twice, and the one individual to win a Nobel Prize in two scientific fields.
Her husband, Pierre Curie, was a co-winner of her first Nobel Prize, making them the first-ever married couple to win the Nobel Prize and launching the Curie household legacy of 5 Nobel Prizes.
She was, in 1906, the primary girl to change into a professor on the College of Paris.
Additionally, Robin Williams.
"""
paperwork = [Document(page_content=text)]
We’ll even be utilizing GPT-4o in all examples.
from langchain_openai import ChatOpenAI
import getpass
import osos.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI api key")
llm = ChatOpenAI(mannequin='gpt-4o')
To start out, let’s study how the extraction course of works with out defining any graph schema.
from langchain_experimental.graph_transformers import LLMGraphTransformerno_schema = LLMGraphTransformer(llm=llm)
Now we are able to course of the paperwork utilizing the aconvert_to_graph_documents operate, which is asynchronous. Utilizing async with LLM extraction is really helpful, because it permits for parallel processing of a number of paperwork. This method can considerably cut back wait occasions and enhance throughput, particularly when coping with a number of paperwork.
knowledge = await no_schema.aconvert_to_graph_documents(paperwork)
The response from the LLM Graph Transformer will likely be a graph doc, which has the next construction:
[
GraphDocument(
nodes=[
Node(id="Marie Curie", type="Person", properties={}),
Node(id="Pierre Curie", type="Person", properties={}),
Node(id="Nobel Prize", type="Award", properties={}),
Node(id="University Of Paris", type="Organization", properties={}),
Node(id="Robin Williams", type="Person", properties={}),
],
relationships=[
Relationship(
source=Node(id="Marie Curie", type="Person", properties={}),
target=Node(id="Nobel Prize", type="Award", properties={}),
type="WON",
properties={},
),
Relationship(
source=Node(id="Marie Curie", type="Person", properties={}),
target=Node(id="Nobel Prize", type="Award", properties={}),
type="WON",
properties={},
),
Relationship(
source=Node(id="Marie Curie", type="Person", properties={}),
target=Node(
id="University Of Paris", type="Organization", properties={}
),
type="PROFESSOR",
properties={},
),
Relationship(
source=Node(id="Pierre Curie", type="Person", properties={}),
target=Node(id="Nobel Prize", type="Award", properties={}),
type="WON",
properties={},
),
],
supply=Doc(
metadata={"id": "de3c93515e135ac0e47ca82a4f9b82d8"},
page_content="nMarie Curie, 7 November 1867 – 4 July 1934, was a Polish and naturalised-French physicist and chemist who carried out pioneering analysis on radioactivity.nShe was the primary girl to win a Nobel Prize, the primary individual to win a Nobel Prize twice, and the one individual to win a Nobel Prize in two scientific fields.nHer husband, Pierre Curie, was a co-winner of her first Nobel Prize, making them the first-ever married couple to win the Nobel Prize and launching the Curie household legacy of 5 Nobel Prizes.nShe was, in 1906, the primary girl to change into a professor on the College of Paris.nAlso, Robin Williams!n",
),
)
]
The graph doc describes extracted nodes and relationships . Moreover, the supply doc of the extraction is added below the supply key.
We will use the Neo4j Browser to visualise the outputs, offering a clearer and extra intuitive understanding of the info.