前言
前面一章讲述了构建知识图谱来提高基于 RAG 的应用程序的准确性，并且使用 Neo4j 和 LangChain 在 RAG 应用程序中构建和检索知识图谱信息。
图形检索增强生成 (Graph RAG) 这种方法利用图形数据库的结构化特性，将数据组织为节点和关系，以增强检索信息的深度和上下文性。
由于篇幅可能会比较长，这一篇知识点较多，我单独分成了两个小节
一、给定 Cypher 查询结果图表
Cypher 是什么？可能很多小伙伴不太懂这个，一来就产生一个疑问，我这里简单描述一下。
Cypher 其实是 Neo4j的图形查询语言，可让您从图形中检索数据。
它就像是 SQL 语句，不过它是图形的 SQL，但它受到 SQL 的启发，因此我们可以专注于怎么从图形中获取什么数据（而不是如何获取数据）。
后面几章节我会详细对 Cypher 的 语句 进行详细说明。
打开我们 Jupyter（jupyter.org/try-jupyter… Colab（colab.research.google.com/drive/），因为下… yfiles_jupyter_graphs 它支持的环境就是 Jupyter 环境，VS Code 或 Google Colab 环境：
%pip install --upgrade --quiet langchain langchain-community langchain-openai langchain-experimental neo4j wikipedia tiktoken yfiles_jupyter_graphs
from neo4j import GraphDatabase
from yfiles_jupyter_graphs import GraphWidget
os.environ["NEO4J_URI"] = "bolt://*********"
os.environ["NEO4J_USERNAME"] = "ne*******"
os.environ["NEO4J_PASSWORD"] = "de**********"
os.environ["OPENAI_API_KEY"] = "sk-*********"
graph = Neo4jGraph()
# dire
ctly show the graph resulting from the given Cypher query
default_cypher = "MATCH (s)-[r:!MENTIONS]->(t) RETURN s,r,t LIMIT 50"
def showGraphDetail(cypher: str = default_cypher):
# create a neo4j session to run queries
driver = GraphDatabase.driver(
uri = os.environ["NEO4J_URI"],
auth = (os.environ["NEO4J_USERNAME"],
os.environ["NEO4J_PASSWORD"]))
session = driver.session()
widget = GraphWidget(graph = session.run(cypher).graph())
widget.node_label_mapping = 'id'
return widget
showGraphDetail(default_cypher)
"MATCH (s)-[r:!MENTIONS]->(t) RETURN s,r,t LIMIT 50" 这就是一句我们的 Cypher 查询语句，它表示的意思是 "找出图数据库中所有通过非'MENTIONS'关系相连的节点对，返回这些节点和它们之间的关系，但最多只返回50组这样的结果。"
这个查询可以用来探索图中的各种关系，同时排除了 "MENTIONS" 这种特定的关系类型。
它对于了解图的结构和不同实体之间的连接方式很有用，尤其是当你想排除某种特定类型的关系时。 点击运行，出现下面界面：
我们在这里可以看到之前保存到 Neo4j 的图数据。
二、混合检索
图生成后，我们将使用混合检索方法，将向量和关键字索引与 RAG 应用程序的图检索相结合。
在检索过程中，从用户提出问题开始，然后将问题定向到 RAG 检索器。
该检索器采用关键字和向量搜索来搜索非结构化文本数据，并将其与从知识图谱中收集的信息相结合。
由于 Neo4j 同时具有关键字索引和向量索引，因此我们可以使用单个数据库系统实现所有三个检索选项。
从这些来源收集的数据将输入 llm 大模型以生成并提供最终答案。
在我们做图混合检索所之前，我们先看一下图形检索器咋么识别输入中的相关实体，打开我们的视图文件 testite/members/views.py ，新建视图：
# 实体类
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field
from typing import Tuple, List, Optional
from langchain_community.graphs import Neo4jGraph
from langchain_openai import ChatOpenAI
from langchain_experimental.graph_transformers import LLMGraphTransformer
class Entities(BaseModel):
"""Identifying information about entities."""
names: List[str] = Field(
...,
description="All the person, organization, or business entities that "
"appear in the text",
)
def testEntity(request):
llm = ChatOpenAI(temperature=0, model_name="gpt-4o-mini")
# 构建提示角色
prompt = ChatPromptTemplate.from_messages(
[
(
"system",
"You are extracting organization and person entities from the text.",
),
(
"human",
"Use the given format to extract information from the following "
"input: {question}",
),
]
)
entity_chain = prompt | llm.with_structured_output(Entities)
res = entity_chain.invoke({"question": "Where was jack born?"}).names
return JsonResponse({'response': res})
然后天机路由：
path('test_entity/', views.testEntity, name='graphrag'),
浏览器访问 http://127.0.0.1:8000/polls/test_entity/ 可以得到如下输出：
三、Django知识图谱检索方法构建
现在我们可以检测问题中的实体，让我们使用全文索引将它们映射到知识图谱。
首先，我们需要定义一个全文索引和一个函数，该函数将生成允许一些拼写错误的全文查询。
该函数依旧加到视图文件中：
def generate_full_text_query(input: str) -> str:
"""
Generate a full-text search query for a given input string.
This function constructs a query string suitable for a full-text search.
It processes the input string by splitting it into words and appending a
similarity threshold (~2 changed characters) to each word, then combines
them using the AND operator. Useful for mapping entities from user questions
to database values, and allows for some misspelings.
"""
full_text_query = ""
words = [el for el in remove_lucene_chars(input).split() if el]
for word in words[:-1]:
full_text_query += f" {word}~2 AND"
full_text_query += f" {words[-1]}~2"
return full_text_query.strip()
# Fulltext index query
def structured_retriever(question: str) -> str:
"""
Collects the neighborhood of entities mentioned
in the question
"""
result = ""
entities = entity_chain.invoke({"question": question})
for entity in entities.names:
response = graph.query(
"""CALL db.index.fulltext.queryNodes('entity', $query, {limit:2})
YIELD node,score
CALL {
WITH node
MATCH (node)-[r:!MENTIONS]->(neighbor)
RETURN node.id + ' - ' + type(r) + ' -> ' + neighbor.id AS output
UNION ALL
WITH node
MATCH (node)<-[r:!MENTIONS]-(neighbor)
RETURN neighbor.id + ' - ' + type(r) + ' -> ' + node.id AS output
}
RETURN output LIMIT 50
""",
{"query": generate_full_text_query(entity)},
)
result += "\n".join([el['output'] for el in response])
return result
structural_retriever 函数首先检测用户问题中的实体。接下来，它迭代检测到的实体并使用 Cypher 模板来检索相关节点的邻域。我们可以来测试一下：
print(structured_retriever("Who is Dursley I?"))
得到下列答案：
我们在开始时提到的，我们将结合非结构化和图形检索器来创建将传递给 LLM 的最终上下文。
def retriever(question: str):
print(f"Search query: {question}")
structured_data = structured_retriever(question)
unstructured_data = [el.page_content for el in vector_index.similarity_search(question)]
final_data = f"""Structured data:
{structured_data}
Unstructured data:
{"#Document ". join(unstructured_data)}
"""
return final_data
定义 RAG Chain，前面我们基本实现了 RAG 的检索组件。接下来，我将介绍以对话的方式跟进问题的查询：
_template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question,
in its original language.
Chat History:
{chat_history}
Follow Up Input: {question}
Standalone question:""" # noqa: E501
CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
def _format_chat_history(chat_history: List[Tuple[str, str]]) -> List:
buffer = []
for human, ai in chat_history:
buffer.append(HumanMessage(content=human))
buffer.append(AIMessage(content=ai))
return buffer
_search_query = RunnableBranch(
# If input includes chat_history, we condense it with the follow-up question
(
RunnableLambda(lambda x: bool(x.get("chat_history"))).with_config(
run_name="HasChatHistoryCheck"
), # Condense follow-up question and chat into a standalone_question
RunnablePassthrough.assign(
chat_history=lambda x: _format_chat_history(x["chat_history"])
)
| CONDENSE_QUESTION_PROMPT
| ChatOpenAI(temperature=0)
| StrOutputParser(),
),
# Else, we have no chat history, so just pass through the question
RunnableLambda(lambda x : x["question"]),
)
接下来，我们引入一个提示，利用集成混合检索器提供的上下文来生成响应，从而完成 RAG 链的实现。
提示模板如下：
template = """Answer the question based only on the following context:
{context}
Question: {question}
Use natural language and be concise.
Answer:"""
prompt = ChatPromptTemplate.from_template(template)
chain = (
RunnableParallel(
{
"context": _search_query | retriever,
"question": RunnablePassthrough(),
}
)
| prompt
| llm
| StrOutputParser()
)
最后，我们通过下面两种方式测试图形混合检索，第二种我带入了第一种的会话历史，定义一个视图方法：
def hybridRetrievalRag(request):
res = chain.invoke({"question": "Which house did Dursley I belong to?"})
# 或者
res = chain.invoke(
{
"question": "他出身在哪里?",
"chat_history": [
("Which house did Dursley I belong to?", "Mr. Dursley belonged to number four, Privet Drive")],
}
)
return JsonResponse({'response': res})
然后老样子，添加我们的路由：
path('hybrid_retrieval/', views.hybridRetrievalRag, name='graphrag'),
浏览器访问 http://127.0.0.1:8000/polls/hybrid_retrieval/ 可以得到如下输出：
成功得到自己的答案，第二个为啥没有检索到，由于我们在上一篇的段落并没有讲述Mr. Dursley出身在哪里，在图谱中也没检索得到这个问题的关系。
四、总结
这一章我们讲述可怎么结合 Django + langchian + Neo4j 构建 GraphRag ，并完成检索，测试了它的准确性，也看的到它们结合使用的效率以及性能，这种通过知识图谱的检索形式必将成为未来 RAG 不可缺少的一部分。
整个篇章下来从微软的 GraphRag 到 Neo4j 图库存储，最后做混合检索，小伙伴是不是会疑惑，好像并没有完全的联系起来，因为neo4j的图谱是自己储存的，并没有储存 GraphRag 生成的数据。
对的，还缺少一步怎么把存 GraphRag 生成的数据导入到 Neo4j ，下一节我们将讲述， Neo4j 存储 GraphRag 图谱文件，中间涉及到转化。
– 欢迎点赞、关注、转发、收藏【我码玄黄】，gonghao同名
