GraphRAG in Motion: From Business Contracts to a Dynamic Q&A Agent | by Ed Sandoval | Nov, 2024

However first, for these of us not acquainted with business regulation, let’s begin with a quick intro to the contract assessment drawback.

Business contract assessment is a labor-intensive course of involving paralegals and junior attorneys meticulously figuring out crucial data in a contract.

“Contract assessment is the method of totally studying a contract to grasp the rights and obligations of a person or firm signing it and assess the related influence”.
Hendrycks, Burns et al, NeurIPS 2021, in CUAD an Professional-Annotated NLP Dataset for Authorized Contract Overview

The primary stage of contract assessment entails reviewing a whole bunch of pages of contracts to seek out the related clauses or obligations. Contract reviewers should determine whether or not related clauses exist, what they are saying in the event that they do exist, and hold monitor of the place they’re described.

For instance, They need to decide whether or not the contract is a 3-year contract or a 1-year contract. They need to decide the tip date of a contract. They need to decide whether or not a clause is, say, an Anti-assignment or an Exclusivity clause…”
Hendrycks, Burns et al, NeurIPS 2021, in CUAD an Professional-Annotated NLP Dataset for Authorized Contract Overview

It’s a activity that calls for thoroughness however usually suffers from inefficiencies however it’s appropriate for a Giant Language Mannequin!

As soon as the primary stage is accomplished, senior regulation practitioners can begin to study contracts for weaknesses and dangers. That is an space the place a Q&A agent powered by an LLM and grounded by data saved in Information Graph is an ideal Copilot for a authorized knowledgeable.

The rest of this weblog will describe every of the steps on this course of. Alongside the way in which, I’ll use code snippets as an instance the primary concepts.

The 4 steps are:

1. Extracting Related Info from Contracts (LLM + Contract)
2. Storing data extracted right into a Information Graph (Neo4j)
3. Creating easy KG Knowledge Retrieval Features (Python)
4. Constructing a Q&A Agent dealing with advanced questions (Semantic Kernel, LLM, Neo4j)

The CUAD (Contract Understanding Atticus Dataset) is a CC BY 4.0 licensed and publicly accessible dataset of over 13,000 expert-labeled clauses throughout 510 authorized contracts, designed to assist construct AI fashions for contract assessment. It covers a variety of necessary authorized clauses, resembling confidentiality, termination, and indemnity, that are crucial for contract evaluation.

We’ll use three contracts from this dataset to showcase how our method to successfully extract and analyze key authorized data, constructing a information graph and leveraging it for exact, advanced query answering.

The three contracts mixed comprise a complete of 95 pages.

It’s comparatively easy to immediate an LLM to extract exact data from contracts and generate a JSON output, representing the related data from the contract.

In business assessment, a immediate will be drafted to to find every of the crucial parts talked about above — events, dates, clauses — and summarize them neatly in a machine-readable (JSON) file.

Extraction Immediate (simplified)

Reply the next questions utilizing data completely on this contract
[Contract.pdf]

1) What sort of contract is that this?
2) Who’re the events and their roles? The place are they integrated? Identify state and nation (use ISO 3166 Nation title)
3) What’s the Settlement Date?
4) What’s the Efficient date?

For every of the next varieties of contract clauses, extract two items of knowledge:
a) A Sure/No that signifies in the event you suppose the clause is discovered on this contract
b) An inventory of excerpts that signifies this clause sort exists.

Contract Clause varieties: Aggressive Restriction Exception, Non-Compete Clause, Exclusivity, No-Solicit Of Prospects, No-Solicit Of Staff, Non-Disparagement, Termination For Comfort, Rofr/Rofo/Rofn, Change Of Management, Anti-Task, Uncapped Legal responsibility, Cap On Legal responsibility

Present your remaining reply in a JSON doc.

Please notice that the above part exhibits a simplified model of the extraction immediate. A full model will be seen right here. You can find that the the final a part of the immediate specifies the specified format of the JSON doc. That is helpful in making certain a constant JSON schema output.

This activity is comparatively easy in Python. The important()perform beneath is designed to course of a set of PDF contract recordsdata by extracting related authorized data (extraction_prompt), utilizing OpenAI gpt-4o and saving the leads to JSON format.

def important():
pdf_files = [filename for filename in os.listdir('./data/input/') if filename.endswith('.pdf')]
for pdf_filename in pdf_files:
print('Processing ' + pdf_filename + '...')    
# Extract content material from PDF utilizing the assistant
complete_response = process_pdf('./knowledge/enter/' + pdf_filename)
# Log the entire response to debug
save_json_string_to_file(complete_response, './knowledge/debug/complete_response_' + pdf_filename + '.json')

The “process_pdf” perform makes use of “OpenAI gpt-4o” to carry out information extraction from the contract with an “extraction immediate”.

def process_pdf(pdf_filename):
# Create OpenAI message thread
thread = shopper.beta.threads.create()
# Add PDF file to the thread
file = shopper.recordsdata.create(file=open(pdf_filename, "rb"), objective="assistants")
# Create message with contract as attachment and extraction_prompt
shopper.beta.threads.messages.create(thread_id=thread.id,function="person",
attachments=[
Attachment(
file_id=file.id, tools=[AttachmentToolFileSearch(type="file_search")])
],
content material=extraction_prompt,
)
# Run the message thread
run = shopper.beta.threads.runs.create_and_poll(
thread_id=thread.id, assistant_id=pdf_assistant.id, timeout=1000)
# Retrieve messages
messages_cursor = shopper.beta.threads.messages.record(thread_id=thread.id)
messages = [message for message in messages_cursor]
# Return final message in Thread 
return messages[0].content material[0].textual content.worth

For every contract, the message returned by “process_pdf” seems like

{
"settlement": {
"agreement_name": "Advertising and marketing Affiliate Settlement",
"agreement_type": "Advertising and marketing Affiliate Settlement",
"effective_date": "Could 8, 2014",
"expiration_date": "December 31, 2014",
"renewal_term": "1 12 months",
"Notice_period_to_Terminate_Renewal": "30 days",
"events": [
{
"role": "Company",
"name": "Birch First Global Investments Inc.",
"incorporation_country": "United States Virgin Islands",
"incorporation_state": "N/A"
},
{
"role": "Marketing Affiliate",
"name": "Mount Knowledge Holdings Inc.",
"incorporation_country": "United States",
"incorporation_state": "Nevada"
}
],
"governing_law": {
"nation": "United States",
"state": "Nevada",
"most_favored_country": "United States"
},
"clauses": [
{
"clause_type": "Competitive Restriction Exception",
"exists": false,
"excerpts": []
},
{
"clause_type": "Exclusivity",
"exists": true,
"excerpts": [
"Company hereby grants to MA the right to advertise, market and sell to corporate users, government agencies and educational facilities for their own internal purposes only, not for remarketing or redistribution."
]
},
{
"clause_type": "Non-Disparagement",
"exists": true,
"excerpts": [
"MA agrees to conduct business in a manner that reflects favorably at all times on the Technology sold and the good name, goodwill and reputation of Company."
]
},
{
"clause_type": "Termination For Comfort",
"exists": true,
"excerpts": [
"This Agreement may be terminated by either party at the expiration of its term or any renewal term upon thirty (30) days written notice to the other party."
]
},
{
"clause_type": "Anti-Task",
"exists": true,
"excerpts": [
"MA may not assign, sell, lease or otherwise transfer in whole or in part any of the rights granted pursuant to this Agreement without prior written approval of Company."
]
},
{
"clause_type": "Worth Restrictions",
"exists": true,
"excerpts": [
"Company reserves the right to change its prices and/or fees, from time to time, in its sole and absolute discretion."
]
},
{
"clause_type": "Minimal Dedication",
"exists": true,
"excerpts": [
"MA commits to purchase a minimum of 100 Units in aggregate within the Territory within the first six months of term of this Agreement."
]
},
{
"clause_type": "IP Possession Task",
"exists": true,
"excerpts": [
"Title to the Technology and all copyrights in Technology shall remain with Company and/or its Affiliates."
]
},
{
"clause_type": "License grant",
"exists": true,
"excerpts": [
"Company hereby grants to MA the right to advertise, market and sell the Technology listed in Schedule A of this Agreement."
]
},
{
"clause_type": "Non-Transferable License",
"exists": true,
"excerpts": [
"MA acknowledges that MA and its Clients receive no title to the Technology contained on the Technology."
]
},
{
"clause_type": "Cap On Legal responsibility",
"exists": true,
"excerpts": [
"In no event shall Company be liable to MA, its Clients, or any third party for any tort or contract damages or indirect, special, general, incidental or consequential damages."
]
},
{
"clause_type": "Guarantee Length",
"exists": true,
"excerpts": [
"Company's sole and exclusive liability for the warranty provided shall be to correct the Technology to operate in substantial accordance with its then current specifications."
]
}
]
}
}

With every contract now as a JSON file, the subsequent step is to create a Information Graph in Neo4J.

At this level is beneficial to spend a while designing the information mannequin. It is advisable take into account some key questions:

• What do nodes and relationships on this graph symbolize?
• What are the primary properties for every node and relationship?,
• Ought to there be any properties listed?
• Which properties want vector embeddings to allow semantic similarity search on them?

In our case, an acceptable design (schema) contains the primary entities: Agreements (contracts), their clauses, the organizations who’re events to the settlement and the relationships amongst them.

A visible illustration of the schema is proven beneath.

Node properties:
Settlement {agreement_type: STRING, contract_id: INTEGER,
effective_date: STRING, expiration_date: STRING,
renewal_term: STRING, title: STRING}
ContractClause {title: STRING, sort: STRING}
ClauseType {title: STRING}
Nation {title: STRING}
Excerpt {textual content: STRING}
Group {title: STRING}
Relationship properties:
IS_PARTY_TO {function: STRING}
GOVERNED_BY_LAW {state: STRING}
HAS_CLAUSE {sort: STRING}
INCORPORATED_IN {state: STRING}

Solely the “Excerpts” — the brief textual content items recognized by the LLM in Step 1 — require textual content embeddings. This method dramatically reduces the variety of vectors and the scale of the vector index wanted to symbolize every contract, making the method extra environment friendly and scalable.

A simplified model of a python script loading every JSON right into a Information Graph with the above schema seems like

NEO4J_URI=os.getenv('NEO4J_URI', 'bolt://localhost:7687')
NEO4J_USER=os.getenv('NEO4J_USERNAME', 'neo4j')
NEO4J_PASSWORD=os.getenv('NEO4J_PASSWORD')
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
JSON_CONTRACT_FOLDER = './knowledge/output/'
driver = GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD))
contract_id = 1
json_contracts = [filename for filename in os.listdir(JSON_CONTRACT_FOLDER) if filename.endswith('.json')]
for json_contract in json_contracts:
with open(JSON_CONTRACT_FOLDER + json_contract,'r') as file:
json_string = file.learn()
json_data = json.hundreds(json_string)
settlement = json_data['agreement']
settlement['contract_id'] = contract_id
driver.execute_query(CREATE_GRAPH_STATEMENT,  knowledge=json_data)
contract_id+=1
create_full_text_indices(driver)
driver.execute_query(CREATE_VECTOR_INDEX_STATEMENT)
print ("Producing Embeddings for Contract Excerpts...")
driver.execute_query(EMBEDDINGS_STATEMENT, token = OPENAI_API_KEY)

Right here the “CREATE_GRAPH_STATEMENT” is the one “advanced” piece. It’s a CYPHER assertion that maps the Contract (JSON) into the nodes and relationships within the Information Graph.

The total Cypher assertion is beneath

CREATE_GRAPH_STATEMENT = """
WITH $knowledge AS knowledge
WITH knowledge.settlement as a
MERGE (settlement:Settlement {contract_id: a.contract_id})
ON CREATE SET 
settlement.contract_id  = a.contract_id,
settlement.title = a.agreement_name,
settlement.effective_date = a.effective_date,
settlement.expiration_date = a.expiration_date,
settlement.agreement_type = a.agreement_type,
settlement.renewal_term = a.renewal_term,
settlement.most_favored_country = a.governing_law.most_favored_country
//settlement.Notice_period_to_Terminate_Renewal = a.Notice_period_to_Terminate_Renewal
MERGE (gl_country:Nation {title: a.governing_law.nation})
MERGE (settlement)-[gbl:GOVERNED_BY_LAW]->(gl_country)
SET gbl.state = a.governing_law.state
FOREACH (social gathering IN a.events |
// todo correct world id for the social gathering
MERGE (p:Group {title: social gathering.title})
MERGE (p)-[ipt:IS_PARTY_TO]->(settlement)
SET ipt.function = social gathering.function
MERGE (country_of_incorporation:Nation {title: social gathering.incorporation_country})
MERGE (p)-[incorporated:INCORPORATED_IN]->(country_of_incorporation)
SET integrated.state = social gathering.incorporation_state
)
WITH a, settlement, [clause IN a.clauses WHERE clause.exists = true] AS valid_clauses
FOREACH (clause IN valid_clauses |
CREATE (cl:ContractClause {sort: clause.clause_type})
MERGE (settlement)-[clt:HAS_CLAUSE]->(cl)
SET clt.sort = clause.clause_type
// ON CREATE SET c.excerpts = clause.excerpts
FOREACH (excerpt IN clause.excerpts |
MERGE (cl)-[:HAS_EXCERPT]->(e:Excerpt {textual content: excerpt})
)
//hyperlink clauses to a Clause Sort label
MERGE (clType:ClauseType{title: clause.clause_type})
MERGE (cl)-[:HAS_TYPE]->(clType)
)"""

Right here’s a breakdown of what the assertion does:

Knowledge Binding

WITH $knowledge AS knowledge
WITH knowledge.settlement as a

• $knowledge is the enter knowledge being handed into the question in JSON format. It incorporates details about an settlement (contract).
• The second line assigns knowledge.settlement to the alias a, so the contract particulars will be referenced within the subsequent question.

Upsert the Settlement Node

MERGE (settlement:Settlement {contract_id: a.contract_id})
ON CREATE SET 
settlement.title = a.agreement_name,
settlement.effective_date = a.effective_date,
settlement.expiration_date = a.expiration_date,
settlement.agreement_type = a.agreement_type,
settlement.renewal_term = a.renewal_term,
settlement.most_favored_country = a.governing_law.most_favored_country

• MERGE makes an attempt to seek out an present Settlement node with the required contract_id. If no such node exists, it creates one.
• The ON CREATE SET clause units varied properties on the newly created Settlement node, resembling contract_id, agreement_name, effective_date, and different agreement-related fields from the JSON enter.

Create Governing Regulation Relationship

MERGE (gl_country:Nation {title: a.governing_law.nation})
MERGE (settlement)-[gbl:GOVERNED_BY_LAW]->(gl_country)
SET gbl.state = a.governing_law.state

• This creates or merges a Nation node for the governing regulation nation related to the settlement.
• Then, it creates or merges a relationship GOVERNED_BY_LAW between the Settlement and Nation.
• It additionally units the state property of the GOVERNED_BY_LAW relationship

Create Get together and Incorporation Relationships

FOREACH (social gathering IN a.events |
MERGE (p:Group {title: social gathering.title})
MERGE (p)-[ipt:IS_PARTY_TO]->(settlement)
SET ipt.function = social gathering.function
MERGE (country_of_incorporation:Nation {title: social gathering.incorporation_country})
MERGE (p)-[incorporated:INCORPORATED_IN]->(country_of_incorporation)
SET integrated.state = social gathering.incorporation_state
)

For every social gathering within the contract (a.events), it:

• Upserts (Merge) an Group node for the social gathering.
• Creates an IS_PARTY_TO relationship between the Group and the Settlement, setting the function of the social gathering (e.g., purchaser, vendor).
• Merges a Nation node for the nation by which the group is integrated.
• Creates an INCORPORATED_IN relationship between the group and the incorporation nation, and units the state the place the group is integrated

Create Contract Clauses and Excerpts

WITH a, settlement, [clause IN a.clauses WHERE clause.exists = true] AS valid_clauses
FOREACH (clause IN valid_clauses |
CREATE (cl:ContractClause {sort: clause.clause_type})
MERGE (settlement)-[clt:HAS_CLAUSE]->(cl)
SET clt.sort = clause.clause_type
FOREACH (excerpt IN clause.excerpts |
MERGE (cl)-[:HAS_EXCERPT]->(e:Excerpt {textual content: excerpt})
)
MERGE (clType:ClauseType{title: clause.clause_type})
MERGE (cl)-[:HAS_TYPE]->(clType)
)

• This half first filters the record of clauses (a.clauses) to incorporate solely these the place clause.exists = true (i.e., clauses with excerpts recognized by the LLM in Step 1)
• For every clause:
• It creates a ContractClause node with a title and sort comparable to the clause sort.
• A HAS_CLAUSE relationship is established between the Settlement and the ContractClause.
• For every excerpt related to the clause, it creates an Excerpt node and hyperlinks it to the ContractClause utilizing a HAS_EXCERPT relationship.
• Lastly, a ClauseType node is created (or merged) for the kind of the clause, and the ContractClause is linked to the ClauseType utilizing a HAS_TYPE relationship.

As soon as the import script runs, a single contract will be visualized in Neo4J as a Information Graph

The three contracts within the information graph required solely a small graph (below 100 nodes and fewer than 200 relationships). Most significantly, solely 40–50 vector embeddings for the Excerpts are wanted. This information graph with a small variety of vectors can now be used to energy a fairly highly effective Q&A agent.

With the contracts now structured in a Information Graph, the subsequent step entails making a small set of graph knowledge retrieval features. These features function the core constructing blocks, permitting us to develop a Q&A agent in step 4.

Let’s outline a couple of primary knowledge retrieval features:

1. Retrieve primary particulars a few contract (given a contract ID)
2. Discover contracts involving a selected group (given a partial group title)
3. Discover contracts that DO NOT comprise a selected clause sort
4. Discover contracts comprise a selected sort of clause
5. Discover contracts based mostly on the semantic similarity with the textual content (Excerpt) in a clause (e.g., contracts mentioning using “prohibited objects”)
6. Run a pure language question in opposition to all contracts within the database. For instance, an aggregation question that counts “what number of contracts meet sure circumstances”.

In step 4, we are going to construct a Q&A utilizing the Microsoft Semantic Kernel library. This library simplifies the agent constructing course of. It permits builders to outline the features and instruments that an Agent could have at its disposal to reply a query.

As a way to simplify the mixing between Neo4J and the Semantic Kernel library, let’s outline a ContractPlugin that defines the “signature” of every our knowledge retrieval features. Observe the @kernel_function decorator for every of the features and in addition the kind data and outline offered for every perform.

Semantic Kernel makes use of the idea of a “Plugin” class to encapsulate a gaggle of features accessible to an Agent. It can use the adorned features, sort data and documentation to tell the LLM perform calling capabilities about features accessible.

from typing import Record, Elective, Annotated
from AgreementSchema import Settlement, ClauseType
from semantic_kernel.features import kernel_function
from ContractService import  ContractSearchService
class ContractPlugin:
def __init__(self, contract_search_service: ContractSearchService ):
self.contract_search_service = contract_search_service
@kernel_function
async def get_contract(self, contract_id: int) -> Annotated[Agreement, "A contract"]:
"""Will get particulars a few contract with the given id."""
return await self.contract_search_service.get_contract(contract_id)
@kernel_function
async def get_contracts(self, organization_name: str) -> Annotated[List[Agreement], "An inventory of contracts"]:
"""Will get primary particulars about all contracts the place one of many events has a reputation much like the given group title."""
return await self.contract_search_service.get_contracts(organization_name)
@kernel_function
async def get_contracts_without_clause(self, clause_type: ClauseType) -> Annotated[List[Agreement], "An inventory of contracts"]:
"""Will get primary particulars from contracts with out a clause of the given sort."""
return await self.contract_search_service.get_contracts_without_clause(clause_type=clause_type)
@kernel_function
async def get_contracts_with_clause_type(self, clause_type: ClauseType) -> Annotated[List[Agreement], "An inventory of contracts"]:
"""Will get primary particulars from contracts with a clause of the given sort."""
return await self.contract_search_service.get_contracts_with_clause_type(clause_type=clause_type)
@kernel_function
async def get_contracts_similar_text(self, clause_text: str) -> Annotated[List[Agreement], "An inventory of contracts with related textual content in certainly one of their clauses"]:
"""Will get primary particulars from contracts having semantically related textual content in certainly one of their clauses to the to the 'clause_text' offered."""
return await self.contract_search_service.get_contracts_similar_text(clause_text=clause_text)
@kernel_function
async def answer_aggregation_question(self, user_question: str) -> Annotated[str, "An answer to user_question"]:
"""Reply obtained by turning user_question right into a CYPHER question"""
return await self.contract_search_service.answer_aggregation_question(user_question=user_question)

I might suggest exploring the “ContractService” class that incorporates the implementations of every of the above features. Every perform workouts a a unique knowledge retrieval approach.

Let’s stroll via the implementation of a few of these features as they showcase totally different GraphRAG knowledge retrieval methods / patterns

Get Contract (from contract ID) — A Cypher-based retrieval perform

The get_contract(self, contract_id: int), is an asynchronous technique designed to retrieve particulars a few particular contract (Settlement) from a Neo4J database utilizing a Cypher question. The perform returns an Settlement object populated with details about the settlement, clauses, events, and their relationships.

Right here’s the implementation of this perform

async def get_contract(self, contract_id: int) -> Settlement:
GET_CONTRACT_BY_ID_QUERY = """
MATCH (a:Settlement {contract_id: $contract_id})-[:HAS_CLAUSE]->(clause:ContractClause)
WITH a, accumulate(clause) as clauses
MATCH (nation:Nation)-[i:INCORPORATED_IN]-(p:Group)-[r:IS_PARTY_TO]-(a)
WITH a, clauses, accumulate(p) as events, accumulate(nation) as international locations, accumulate(r) as roles, accumulate(i) as states
RETURN a as settlement, clauses, events, international locations, roles, states
"""
agreement_node = {}
data, _, _  = self._driver.execute_query(GET_CONTRACT_BY_ID_QUERY,{'contract_id':contract_id})
if (len(data)==1):
agreement_node =    data[0].get('settlement')
party_list =        data[0].get('events')
role_list =         data[0].get('roles')
country_list =      data[0].get('international locations')
state_list =        data[0].get('states')
clause_list =       data[0].get('clauses')
return await self._get_agreement(
agreement_node, format="lengthy",
party_list=party_list, role_list=role_list,
country_list=country_list,state_list=state_list,
clause_list=clause_list
)

A very powerful element is the The Cypher question in GET_CONTRACT_BY_ID_QUERY This question is executed utilizing contract_id equipped as enter parameter. The output is the matching Settlement, its clauses and events concerned (every social gathering has a job and nation/state of incorporation)

The info is then handed to an utility perform _get_agreementwhich merely maps the information to an “Settlement”. The settlement is a TypedDict outlined as

class Settlement(TypedDict):  
contract_id: int
agreement_name: str
agreement_type: str
effective_date: str
expiration_date: str
renewal_term: str
notice_period_to_terminate_Renewal: str
events: Record[Party]
clauses: Record[ContractClause]

Get Contracts WITHOUT a Clause sort — One other Cypher retrieval perform

This perform illustrate a robust characteristic of a information graph, which is to check for the absence of a relationship.

The get_contracts_without_clause() perform retrieves all contracts (Agreements) from the Neo4J database that don’t comprise a selected sort of clause. The perform takes a ClauseType as enter and returns an inventory of Settlement objects that match the situation.

This kind of knowledge retrieval data can’t be simply applied with vector search. The total implementation follows

async def get_contracts_without_clause(self, clause_type: ClauseType) -> Record[Agreement]:
GET_CONTRACT_WITHOUT_CLAUSE_TYPE_QUERY = """
MATCH (a:Settlement)
OPTIONAL MATCH (a)-[:HAS_CLAUSE]->(cc:ContractClause {sort: $clause_type})
WITH a,cc
WHERE cc is NULL
WITH a
MATCH (nation:Nation)-[i:INCORPORATED_IN]-(p:Group)-[r:IS_PARTY_TO]-(a)
RETURN a as settlement, accumulate(p) as events, accumulate(r) as roles, accumulate(nation) as international locations, accumulate(i) as states
"""
#run the Cypher question
data, _ , _ = self._driver.execute_query(GET_CONTRACT_WITHOUT_CLAUSE_TYPE_QUERY,{'clause_type':clause_type.worth})
all_agreements = []
for row in data:
agreement_node =  row['agreement']
party_list =  row['parties']
role_list =  row['roles']
country_list = row['countries']
state_list = row['states']
settlement : Settlement = await self._get_agreement(
format="brief",
agreement_node=agreement_node,
party_list=party_list,
role_list=role_list,
country_list=country_list,
state_list=state_list
)
all_agreements.append(settlement)
return all_agreements

As soon as once more, the format is much like the earlier perform. A Cypher question,GET_CONTRACTS_WITHOUT_CLAUSE_TYPE_QUERY , defines the nodes and relationship patterns to be matched. It performs an non-obligatory match to filters out contracts that do comprise a clause sort, and collects associated knowledge in regards to the settlement, such because the concerned events and their particulars.

The perform then constructs and returns an inventory of Settlement objects, which encapsulate all of the related data for every matching settlement.

Get Contract with Semantically Related Textual content — A Vector-Search + Graph knowledge retrieval perform

The get_contracts_similar_text() perform is designed to seek out agreements (contracts) that comprise clauses with textual content much like a offered clause_text. It makes use of semantic vector search to determine associated Excerpts after which traverses the graph to return details about the corresponding agreements and clauses, the place these excerpts got here from.

This perform leverages a vector index outlined on the “textual content” property of every Excerpt. It makes use of the just lately launched Neo4J GraphRAG bundle to simplify the Cypher code wanted to run semantic search + Graph traversal code.

async def get_contracts_similar_text(self, clause_text: str) -> Record[Agreement]:
#Cypher to traverse from the semantically related excerpts again to the settlement
EXCERPT_TO_AGREEMENT_TRAVERSAL_QUERY="""
MATCH (a:Settlement)-[:HAS_CLAUSE]->(cc:ContractClause)-[:HAS_EXCERPT]-(node) 
RETURN a.title as agreement_name, a.contract_id as contract_id, cc.sort as clause_type, node.textual content as excerpt
"""
#Arrange vector Cypher retriever
retriever = VectorCypherRetriever(
driver= self._driver,  
index_name="excerpt_embedding",
embedder=self._openai_embedder, 
retrieval_query=EXCERPT_TO_AGREEMENT_TRAVERSAL_QUERY,
result_formatter=my_vector_search_excerpt_record_formatter
)
# run vector search question on excerpts and get outcomes containing the related settlement and clause 
retriever_result = retriever.search(query_text=clause_text, top_k=3)
#arrange Record of Agreements (with partial knowledge) to be returned
agreements = []
for merchandise in retriever_result.objects:
//extract data from returned objects and append settlement to outcomes
// full code not proven right here however accessible on the Github repo
return agreements

Let’s go over the primary parts of this knowledge retrieval perform

• The Neo4j GraphRAG VectorCypherRetriever permits a developer to carry out semantic similarity on a vector index. In our case, for every semantically related Excerpt “node” discovered, a further Cypher expression is used to fetch extra nodes within the graph associated to the node.
• The parameters of the VectorCypherRetriever are easy. The index_name is the vector index on which to run semantic similarity. The embedder generates a vector embedding for a chunk of textual content. The driver is simply an occasion of a Neo4j Python driver. The retrieval_query specify the extra nodes and relationships related with ever “Excerpt” node recognized by semantic similarity
• The EXCERPT_TO_AGREEMENT_TRAVERSAL_QUERY
  specifies the extra nodes to be retrieved. On this case, for each Excerpt, we’re retrieving its associated Contract Clause and corresponding Settlement

EXCERPT_TO_AGREEMENT_TRAVERSAL_QUERY="""
MATCH (a:Settlement)-[:HAS_CLAUSE]->(cc:ContractClause)-[:HAS_EXCERPT]-(node) 
RETURN a.title as agreement_name, a.contract_id as contract_id, cc.sort as clause_type, node.textual content as excerpt
"""

Run a Pure Language Question — A Textual content 2Cypher knowledge retrieval perform

The answer_aggregation_question() perform leverages Neo4j GraphRAG bundle “Text2CypherRetriever” to reply a query in pure language. The Text2CypherRetriever makes use of an LLM to show the person query right into a Cypher question and runs it in opposition to the Neo4j database.

The perform leverages OpenAI gpt-4o to generate the required Cypher question. Let’s stroll via the primary parts of this knowledge retrieval perform.

 async def answer_aggregation_question(self, user_question) -> str:
reply = ""
NEO4J_SCHEMA = """
omitted for brevity (see beneath for the complete worth)
"""
# Initialize the retriever
retriever = Text2CypherRetriever(
driver=self._driver,
llm=self._llm,
neo4j_schema=NEO4J_SCHEMA
)
# Generate a Cypher question utilizing the LLM, ship it to the Neo4j database, and return the outcomes
retriever_result = retriever.search(query_text=user_question)
for merchandise in retriever_result.objects:
content material = str(merchandise.content material)
if content material:
reply += content material + 'nn'
return reply

This perform leverages Neo4j GraphRAG bundle “Text2CypherRetriever”. It makes use of an LLM, on this case OpenAI LLM is used to show a person query (pure language) right into a Cypher question that’s executed in opposition to the database. The results of this question is returned.

A key factor to make sure that the LLM generates a question that makes use of the nodes, relationships and properties outlined within the database is to supply the LLM with a textual content description of the schema.

In our case, we used the next illustration of the information mannequin is adequate.

NEO4J_SCHEMA = """
Node properties:
Settlement {agreement_type: STRING, contract_id: INTEGER,effective_date: STRING,renewal_term: STRING, title: STRING}
ContractClause {title: STRING, sort: STRING}
ClauseType {title: STRING}
Nation {title: STRING}
Excerpt {textual content: STRING}
Group {title: STRING}
Relationship properties:
IS_PARTY_TO {function: STRING}
GOVERNED_BY_LAW {state: STRING}
HAS_CLAUSE {sort: STRING}
INCORPORATED_IN {state: STRING}
The relationships:
(:Settlement)-[:HAS_CLAUSE]->(:ContractClause)
(:ContractClause)-[:HAS_EXCERPT]->(:Excerpt)
(:ContractClause)-[:HAS_TYPE]->(:ClauseType)
(:Settlement)-[:GOVERNED_BY_LAW]->(:Nation)
(:Group)-[:IS_PARTY_TO]->(:Settlement)
(:Group)-[:INCORPORATED_IN]->(:Nation)
"""

Armed with our Information Graph knowledge retrieval features, we’re able to construct an agent grounded by GraphRAG 🙂

Let’s units up a chatbot agent able to answering person queries about contracts utilizing a mix of OpenAI’s gpt-4o mannequin, our knowledge retrieval features and a Neo4j-powered information graph.

We’ll use Microsoft Semantic Kernel, a framework that permits builders to combine LLM perform calling with present APIs and knowledge retrieval features

The framework makes use of an idea known as Plugins to symbolize particular performance that the kernel can carry out. In our case, all of our knowledge retrieval features outlined within the “ContractPlugin” can be utilized by the LLM to reply the query.

The framework makes use of the idea of Reminiscence to maintain all interactions between person and agent, in addition to features executed and knowledge retrieved.

A very simple Terminal-based agent will be applied with a couple of traces of code. The snippet beneath exhibits the primary elements of the agent (imports and surroundings vars eliminated).

logging.basicConfig(stage=logging.INFO)
# Initialize the kernel
kernel = Kernel()
# Add the Contract Search plugin to the kernel
contract_search_neo4j = ContractSearchService(NEO4J_URI,NEO4J_USER,NEO4J_PASSWORD)
kernel.add_plugin(ContractPlugin(contract_search_service=contract_search_neo4j),plugin_name="contract_search")
# Add the OpenAI chat completion service to the Kernel
kernel.add_service(OpenAIChatCompletion(ai_model_id="gpt-4o",api_key=OPENAI_KEY, service_id=service_id))
# Allow automated perform calling
settings: OpenAIChatPromptExecutionSettings = kernel.get_prompt_execution_settings_from_service_id(service_id=service_id)
settings.function_choice_behavior = FunctionChoiceBehavior.Auto(filters={"included_plugins": ["contract_search"]})
# Create a historical past of the dialog
historical past = ChatHistory()
async def basic_agent() :
userInput = None
whereas True:
# Acquire person enter
userInput = enter("Person > ")
# Terminate the loop if the person says "exit"
if userInput == "exit":
break
# Add person enter to the historical past
historical past.add_user_message(userInput)
# 3. Get the response from the AI with automated perform calling
chat_completion : OpenAIChatCompletion = kernel.get_service(sort=ChatCompletionClientBase)
end result = (await chat_completion.get_chat_message_contents(
chat_history=historical past,
settings=settings,
kernel=kernel,
arguments=KernelArguments(),
))[0]
# Print the outcomes
print("Assistant > " + str(end result))
# Add the message from the agent to the chat historical past
historical past.add_message(end result)
if __name__ == "__main__":
asyncio.run(basic_agent())

1. Discover me contracts with Worth Restrictions however no insurance coverage clauses

Assistant > I discovered the next contract that incorporates a Worth Restrictions clause however doesn't comprise an Insurance coverage clause:
- **Identify:** Birch First World Investments Inc. and Mount Information Holdings Inc. MARKETING AFFILIATE AGREEMENT
- **Settlement Sort:** MARKETING AFFILIATE AGREEMENT
- **Events:**
- **MOUNT KNOWLEDGE HOLDINGS INC.** (Advertising and marketing Affiliate), integrated in Nevada, USA
- **BIRCH FIRST GLOBAL INVESTMENTS INC.** (Firm), integrated within the Virgin Islands (VIR)
Would you wish to know extra particulars about this contract?

Right here, The Semantic Agent planner has reviewed the accessible features within the Kernel and decided that answering this query requires invoking two features that, on their very own, gained’t present the entire reply.

First, it executes the “Get Contracts with [Price Restriction] Clauses” perform, adopted by the “Get Contracts WITHOUT [Insurance] Clauses” perform. The planner then combines the outcomes from each features to determine the intersection, in the end arriving on the right reply.

For those who take a look at the debugging data, you’ll be able to verify the sequence of calls carried out by the LLM, together with data on the variety of tokens consumed by the decision. Discover the calls with the two knowledge retrieval features.

2. Sure, please. Present extra particulars

Assistant > Listed here are the detailed details about the contract:
### Contract Particulars:
- **Identify:** Birch First World Investments Inc. and Mount Information Holdings Inc. MARKETING AFFILIATE AGREEMENT
- **Settlement Sort:** MARKETING AFFILIATE AGREEMENT
- **Expiration Date:** December 31, 2014
- **Renewal Time period:** One (1) 12 months
### Events Concerned:
1. **MOUNT KNOWLEDGE HOLDINGS INC.** 
- **Position:** Advertising and marketing Affiliate
- **Incorporation Nation:** USA
- **Incorporation State:** Nevada
2. **BIRCH FIRST GLOBAL INVESTMENTS INC.**
- **Position:** Firm
- **Incorporation Nation:** Virgin Islands (VIR)
### Clauses Included:
- No-Solicit Of Staff
- Third Get together Beneficiary
- Worth Restrictions
- Affiliate License-Licensee
- Affiliate License-Licensor
- Cap On Legal responsibility
- Audit Rights
- Guarantee Length
- Publish-Termination Providers
- Non-Transferable License
- License grant
- IP Possession Task
- Minimal Dedication
- Anti-Task
- Non-Disparagement
### Clauses Not Included:
- Insurance coverage
Is there something particular you wish to know or any explicit clause particulars you have an interest in?

On this case, behind the scenes, the LLM used the “Discover Contract by ID”. You’ll have observed that the output proven to the person didn’t embody the id of the contract. Nonetheless, the Semantic Kernel saved all data returned from the features from earlier calls within the dialog reminiscence!

This highly effective mixture of getting the agent resolve which perform(s) to name, using reminiscence and the automated marshalling of the person queries into perform calls with the suitable parameters clarify the “Magic” behind an agent constructed with Semantic Kernel!

3. Does any contract point out the flexibility to make worth adjustments every so often

Assistant > Sure, there's a contract that mentions 
the flexibility to make worth adjustments every so often. 
Right here is the related excerpt:
1. **Birch First World Investments Inc. and Mount Information Holdings Inc. MARKETING AFFILIATE AGREEMENT**
- **Contract ID:** 1
- **Clause Sort:** Worth Restrictions
- **Excerpt:**
```
Firm reserves the suitable to vary its course of and/or charges, every so often, in its sole and absolute discretion. Within the occasion of a worth and/or charge change for Know-how, Firm shall notify MA in writing ninety (90) days previous to the efficient date of any such change. All different costs and/or charges could also be adjusted with out prior discover to MA.
```
Would you want extra details about this contract or another particulars?

As a way to reply this query, Semantic Kernel is executing the get_contract_similar_text knowledge retrieval perform.

Person > any contract mentions the flexibility to make worth adjustments every so often
INFO:semantic_kernel.connectors.ai.open_ai.companies.open_ai_chat_completion_base:processing 1 software calls in parallel.
INFO:semantic_kernel.kernel:Calling contract_search-get_contracts_similar_text
perform with args: {"clause_text":"worth adjustments every so often"}
Assistant > Sure, there's a contract that mentions the flexibility to make worth adjustments every so often. Right here is the related excerpt:
1. **Birch First World Investments Inc. and Mount Information Holdings Inc. MARKETING AFFILIATE AGREEMENT**
- **Contract ID:** 1
- **Clause Sort:** Worth Restrictions
- **Excerpt:**
```
Firm reserves the suitable to vary its course of and/or charges, every so often, in its sole and absolute discretion. Within the occasion of a worth and/or charge change for Know-how, Firm shall notify MA in writing ninety (90) days previous to the efficient date of any such change. All different costs and/or charges could also be adjusted with out prior discover to MA.
```

As defined earlier, this perform makes use of vector search and a Cypher question to retrieve not simply semantically related excerpts but additionally the associated contract and clauses that features them.

Lastly, let’s ask what number of contracts are there on the database

4. What number of contracts are there within the database?

This questions requires the LLM to make use of the Text2Cypher knowledge retriever

Assistant > There are a complete of three contracts within the database.

The debug data confirms that Semantic Kernel ran the Text2Cypher knowledge retrieval perform with “user_question” = “What number of contracts are there within the database’?

Person >  what number of contracts are there on the database?
INFO:httpx:HTTP Request: POST https://api.openai.com/v1/chat/completions "HTTP/1.1 200 OK"
INFO:semantic_kernel.connectors.ai.open_ai.companies.open_ai_chat_completion_base:processing 1 software calls in parallel.
INFO:semantic_kernel.kernel:Calling contract_search-answer_aggregation_question perform 
with args: {"user_question":"What number of contracts are there within the database?"}
INFO:semantic_kernel.features.kernel_function:Operate accomplished. Length: 0.588805s
INFO:semantic_kernel.connectors.ai.open_ai.companies.open_ai_handler:OpenAI utilization: CompletionUsage(completion_tokens=13, prompt_tokens=3328, total_tokens=3341, completion_tokens_details={'reasoning_tokens': 0})
Assistant > There are a complete of three contracts within the database.

The github repo incorporates a Streamlit app that gives a extra elegant Agent UI. You might be inspired to work together with the agent and make adjustments to the ContractPlugin so your agent’s capability to deal with extra questions!

On this weblog, we explored a Graph Retrieval Augmented Technology (GraphRAG) method to rework labor-intensive duties of business contract assessment right into a extra environment friendly, AI-driven course of.

By specializing in focused data extraction utilizing LLMs and prompts, constructing a structured information graph with Neo4j, implementing easy knowledge retrieval features, and in the end creating a Q&A agent, we created an clever resolution that handles advanced questions successfully.

This method minimizes inefficiencies present in conventional vector search based mostly RAG, focusing as a substitute on extracting solely related data, lowering the necessity for pointless vector embeddings, and simplifying the general course of. We hope this journey from contract ingestion to an interactive Q&A agent conjures up you to leverage GraphRAG in your personal tasks for improved effectivity and smarter AI-driven decision-making.

Begin constructing your personal business contract assessment agent at this time and expertise the facility of GraphRAG firsthand!

For these desperate to take a deeper dive, please take a look at the sources linked beneath:

Except in any other case famous, all photos are by the writer