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

However first, for these of us not aware of industrial legislation, let’s begin with a short intro to the contract overview drawback.

Industrial contract overview is a labor-intensive course of involving paralegals and junior attorneys meticulously figuring out essential info in a contract.

“Contract overview is the method of completely studying a contract to know 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 Expert-Annotated NLP Dataset for Legal Contract Review

The primary stage of contract overview entails reviewing tons of of pages of contracts to seek out the related clauses or obligations. Contract reviewers should establish whether or not related clauses exist, what they are saying in the event that they do exist, and maintain 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 Expert-Annotated NLP Dataset for Legal Contract Review

It’s a job 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 legislation practitioners can begin to look at contracts for weaknesses and dangers. That is an space the place a Q&A agent powered by an LLM and grounded by info saved in Data 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 example the primary concepts.

The 4 steps are:

1. Extracting Related Info from Contracts (LLM + Contract)
2. Storing info extracted right into a Data Graph (Neo4j)
3. Growing 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 out there dataset of over 13,000 expert-labeled clauses throughout 510 authorized contracts, designed to assist construct AI fashions for contract overview. It covers a variety of necessary authorized clauses, comparable to confidentiality, termination, and indemnity, that are essential for contract evaluation.

We are going to use three contracts from this dataset to showcase how our method to successfully extract and analyze key authorized info, constructing a data 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 info from contracts and generate a JSON output, representing the related info from the contract.

In industrial overview, a immediate might be drafted to to find every of the essential 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 info 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? Title 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 data:
a) A Sure/No that signifies when you assume 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 last reply in a JSON doc.

Please notice that the above part reveals a simplified model of the extraction immediate. A full model might be seen here. You’ll discover 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 job is comparatively easy in Python. The major()operate under is designed to course of a set of PDF contract information by extracting related authorized info (extraction_prompt), utilizing OpenAI gpt-4o and saving the ends in JSON format.

def major():
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('./information/enter/' + pdf_filename)
# Log the entire response to debug
save_json_string_to_file(complete_response, './information/debug/complete_response_' + pdf_filename + '.json')

The “process_pdf” operate makes use of “OpenAI gpt-4o” to carry out data 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.information.create(file=open(pdf_filename, "rb"), goal="assistants")
# Create message with contract as attachment and extraction_prompt
shopper.beta.threads.messages.create(thread_id=thread.id,position="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.checklist(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” appears to be like like

{
"settlement": {
"agreement_name": "Advertising and marketing Affiliate Settlement",
"agreement_type": "Advertising and marketing Affiliate Settlement",
"effective_date": "Might 8, 2014",
"expiration_date": "December 31, 2014",
"renewal_term": "1 yr",
"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 Period",
"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 Data Graph in Neo4J.

At this level is beneficial to spend a while designing the info mannequin. It is advisable to contemplate 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) consists of 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 under.

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 {position: STRING}
GOVERNED_BY_LAW {state: STRING}
HAS_CLAUSE {sort: STRING}
INCORPORATED_IN {state: STRING}

Solely the “Excerpts” — the quick 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 Data Graph with the above schema appears to be like 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 = './information/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,  information=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 Data Graph.

The complete Cypher assertion is under

CREATE_GRAPH_STATEMENT = """
WITH $information AS information
WITH information.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.position = social gathering.position
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 $information AS information
WITH information.settlement as a

• $information is the enter information being handed into the question in JSON format. It accommodates details about an settlement (contract).
• The second line assigns information.settlement to the alias a, so the contract particulars might 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 current Settlement node with the desired contract_id. If no such node exists, it creates one.
• The ON CREATE SET clause units numerous properties on the newly created Settlement node, comparable to contract_id, agreement_name, effective_date, and different agreement-related fields from the JSON enter.

Create Governing Legislation 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 legislation 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.position = social gathering.position
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 position 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 checklist 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 similar 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 might be visualized in Neo4J as a Data Graph

The three contracts within the data 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 Data Graph, the subsequent step entails making a small set of graph information retrieval capabilities. These capabilities function the core constructing blocks, permitting us to develop a Q&A agent in step 4.

Let’s outline just a few primary information retrieval capabilities:

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 specific 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 gadgets”)
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 situations”.

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

With the intention to simplify the mixing between Neo4J and the Semantic Kernel library, let’s outline a ContractPlugin that defines the “signature” of every our information retrieval capabilities. Be aware the @kernel_function decorator for every of the capabilities and likewise the kind info and outline supplied for every operate.

Semantic Kernel makes use of the idea of a “Plugin” class to encapsulate a gaggle of capabilities out there to an Agent. It would use the embellished capabilities, sort info and documentation to tell the LLM operate calling capabilities about capabilities out there.

from typing import Checklist, Non-obligatory, Annotated
from AgreementSchema import Settlement, ClauseType
from semantic_kernel.capabilities 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 just 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 comparable textual content in one in every of their clauses"]:
"""Will get primary particulars from contracts having semantically comparable textual content in one in every of their clauses to the to the 'clause_text' supplied."""
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’d advocate exploring the “ContractService” class that accommodates the implementations of every of the above capabilities. Every operate workouts a a unique information retrieval method.

Let’s stroll via the implementation of a few of these capabilities as they showcase totally different GraphRAG information retrieval strategies / patterns

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

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 operate returns an Settlement object populated with details about the settlement, clauses, events, and their relationships.

Right here’s the implementation of this operate

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, gather(clause) as clauses
MATCH (nation:Nation)-[i:INCORPORATED_IN]-(p:Group)-[r:IS_PARTY_TO]-(a)
WITH a, clauses, gather(p) as events, gather(nation) as nations, gather(r) as roles, gather(i) as states
RETURN a as settlement, clauses, events, nations, 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('nations')
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
)

An important part is the The Cypher question in GET_CONTRACT_BY_ID_QUERY This question is executed utilizing contract_id provided 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 information is then handed to an utility operate _get_agreementwhich merely maps the info 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: Checklist[Party]
clauses: Checklist[ContractClause]

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

This operate illustrate a strong function of a data graph, which is to check for the absence of a relationship.

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

The sort of information retrieval info can’t be simply carried out with vector search. The complete implementation follows

async def get_contracts_without_clause(self, clause_type: ClauseType) -> Checklist[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, gather(p) as events, gather(r) as roles, gather(nation) as nations, gather(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="quick",
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 just like the earlier operate. A Cypher question,GET_CONTRACTS_WITHOUT_CLAUSE_TYPE_QUERY , defines the nodes and relationship patterns to be matched. It performs an non-compulsory match to filters out contracts that do comprise a clause sort, and collects associated information in regards to the settlement, such because the concerned events and their particulars.

The operate then constructs and returns a listing of Settlement objects, which encapsulate all of the related info for every matching settlement.

Get Contract with Semantically Related Textual content — A Vector-Search + Graph information retrieval operate

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

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

async def get_contracts_similar_text(self, clause_text: str) -> Checklist[Agreement]:
#Cypher to traverse from the semantically comparable 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 Checklist of Agreements (with partial information) to be returned
agreements = []
for merchandise in retriever_result.gadgets:
//extract info from returned gadgets and append settlement to outcomes
// full code not proven right here however out there on the Github repo
return agreements

Let’s go over the primary parts of this information retrieval operate

• The Neo4j GraphRAG VectorCypherRetriever permits a developer to carry out semantic similarity on a vector index. In our case, for every semantically comparable 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 linked 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 information retrieval operate

The answer_aggregation_question() operate 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 operate leverages OpenAI gpt-4o to generate the required Cypher question. Let’s stroll via the primary parts of this information retrieval operate.

 async def answer_aggregation_question(self, user_question) -> str:
reply = ""
NEO4J_SCHEMA = """
omitted for brevity (see under 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.gadgets:
content material = str(merchandise.content material)
if content material:
reply += content material + 'nn'
return reply

This operate 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 component 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 info mannequin is ample.

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 {position: 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 Data Graph information retrieval capabilities, 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 information retrieval capabilities and a Neo4j-powered data graph.

We are going to use Microsoft Semantic Kernel, a framework that permits builders to combine LLM operate calling with current APIs and information retrieval capabilities

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 information retrieval capabilities 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 capabilities executed and information retrieved.

A very simple Terminal-based agent might be carried out with just a few traces of code. The snippet under reveals the primary elements of the agent (imports and setting vars eliminated).

logging.basicConfig(degree=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 computerized operate 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:
# Accumulate person enter
userInput = enter("Consumer > ")
# 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 computerized operate 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 accommodates a Worth Restrictions clause however doesn't comprise an Insurance coverage clause:
- **Title:** Birch First International Investments Inc. and Mount Data 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 out there capabilities within the Kernel and decided that answering this query requires invoking two capabilities that, on their very own, received’t present the entire reply.

First, it executes the “Get Contracts with [Price Restriction] Clauses” operate, adopted by the “Get Contracts WITHOUT [Insurance] Clauses” operate. The planner then combines the outcomes from each capabilities to establish the intersection, finally arriving on the appropriate reply.

In the event you have a look at the debugging info, you may verify the sequence of calls carried out by the LLM, together with info on the variety of tokens consumed by the decision. Discover the calls with the two information retrieval capabilities.

2. Sure, please. Present extra particulars

Assistant > Listed below are the detailed details about the contract:
### Contract Particulars:
- **Title:** Birch First International Investments Inc. and Mount Data Holdings Inc. MARKETING AFFILIATE AGREEMENT
- **Settlement Sort:** MARKETING AFFILIATE AGREEMENT
- **Expiration Date:** December 31, 2014
- **Renewal Time period:** One (1) yr
### 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 Period
- Submit-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 want 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 could have observed that the output proven to the person didn’t embrace the id of the contract. Nevertheless, the Semantic Kernel saved all info returned from the capabilities from earlier calls within the dialog reminiscence!

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

3. Does any contract point out the power to make worth modifications infrequently

Assistant > Sure, there's a contract that mentions 
the power to make worth modifications infrequently. 
Right here is the related excerpt:
1. **Birch First International Investments Inc. and Mount Data Holdings Inc. MARKETING AFFILIATE AGREEMENT**
- **Contract ID:** 1
- **Clause Sort:** Worth Restrictions
- **Excerpt:**
```
Firm reserves the fitting to alter its course of and/or charges, infrequently, in its sole and absolute discretion. Within the occasion of a worth and/or payment 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 every other particulars?

With the intention to reply this query, Semantic Kernel is executing the get_contract_similar_text information retrieval operate.

Consumer > any contract mentions the power to make worth modifications infrequently
INFO:semantic_kernel.connectors.ai.open_ai.providers.open_ai_chat_completion_base:processing 1 device calls in parallel.
INFO:semantic_kernel.kernel:Calling contract_search-get_contracts_similar_text
operate with args: {"clause_text":"worth modifications infrequently"}
Assistant > Sure, there's a contract that mentions the power to make worth modifications infrequently. Right here is the related excerpt:
1. **Birch First International Investments Inc. and Mount Data Holdings Inc. MARKETING AFFILIATE AGREEMENT**
- **Contract ID:** 1
- **Clause Sort:** Worth Restrictions
- **Excerpt:**
```
Firm reserves the fitting to alter its course of and/or charges, infrequently, in its sole and absolute discretion. Within the occasion of a worth and/or payment 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 operate makes use of vector search and a Cypher question to retrieve not simply semantically comparable excerpts but in addition 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 information retriever

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

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

Consumer >  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.providers.open_ai_chat_completion_base:processing 1 device calls in parallel.
INFO:semantic_kernel.kernel:Calling contract_search-answer_aggregation_question operate 
with args: {"user_question":"What number of contracts are there within the database?"}
INFO:semantic_kernel.capabilities.kernel_function:Operate accomplished. Period: 0.588805s
INFO:semantic_kernel.connectors.ai.open_ai.providers.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 accommodates a Streamlit app that gives a extra elegant Agent UI. You might be inspired to work together with the agent and make modifications to the ContractPlugin so your agent’s skill to deal with extra questions!

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

By specializing in focused info extraction utilizing LLMs and prompts, constructing a structured data graph with Neo4j, implementing easy information retrieval capabilities, and finally growing a Q&A agent, we created an clever answer 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 info, 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 industrial contract overview agent at this time and expertise the ability of GraphRAG firsthand!

For these desperate to take a deeper dive, please try the sources linked under:

Until in any other case famous, all photographs are by the writer