GraphRAGをLangchain+Neo4jで構築！『ONE PIECE』について聞く

FROM nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04

CUDA12.1のベースイメージを指定しています。

RUN apt-get update && apt-get install -y python3-pip python3-venv git nano curl

Python関連のパッケージをインストールしています。

RUN curl -fsSL https://ollama.com/install.sh | sh

Linux版のOllamaをインストールしています。

PythonでOllamaを動かす際にもLinux版Ollamaのインストールが必要になりますのでご注意ください。

RUN /app/.venv/bin/pip install Jupyter jupyterlab

JupyterLabをインストールしています。

RUN /app/.venv/bin/pip install ollama langchain-ollama langchain langsmith langchain-graphrag langchain-community langchain_huggingface langchain_core langchain-experimental neo4j langchain_neo4j tiktoken

LangChainとOllama関連のパッケージをインストールしています。

LLMはOllamaのライブラリを使って動かしますので、PyTorchやTransformerは別途インストール不要です。

FROM neo4j:5.25.1

Neo4jのベースイメージを指定しています。

ENV NEO4JLABS_PLUGINS '[ "apoc" ]'
ENV NEO4J_dbms_security_procedures_unrestricted apoc.*

APOCプラグインをインストール対象として環境変数に設定します。

APOCは、Neo4jで利用できる追加機能ライブラリであり、Cypherクエリを拡張するためのプロシージャを提供します。

RUN curl -L -o /var/lib/neo4j/plugins/apoc-5.25.1-core.jar \
https://github.com/neo4j/apoc/releases/download/5.25.1/apoc-5.25.1-core.jar

Neo4j用のAPOCプラグインをダウンロードし、Neo4jプラグインのディレクトリに配置しています。

EXPOSE 7474 7687

ポートの公開設定を行っています。

7474(HTTPポート)は、Neo4jの Web管理インターフェースが動作するポートです。

7687(Boltポート)は、 Pythonのneo4jライブラリがデータベースと接続するために使用されます。

CMD ["neo4j"]

Dockerコンテナ起動時に Neo4jデータベース を起動します。

bash -c '/usr/local/bin/ollama serve & /app/.venv/bin/jupyter lab --ip="*" --port=8888 --NotebookApp.token="" --NotebookApp.password="" --no-browser --allow-root'

Ollama ServerとJupyterサーバーを起動します。

bash -c '/usr/local/bin/ollama serve：Ollama Serverを起動しています。

PythonのOllamaを使用する際に、Ollama Serverを起動しておく必要がありますので、ご注意ください。

& /app/.venv/bin/jupyter lab --ip="*" --port=8888 --NotebookApp.token="" --NotebookApp.password="" --no-browser --allow-root'

JupyterLabを8888番ポートで起動しています。

environment:
  - NEO4J_apoc_export_file_enabled=true
  - NEO4J_apoc_import_file_enabled=true
  - NEO4J_apoc_import_file_use__neo4j__config=true
  - NEO4J_dbms_security_procedures_unrestricted=apoc.*
  - NEO4J_dbms_memory_heap_initial__size=512m
  - NEO4J_dbms_memory_heap_max__size=2G
  - NEO4J_dbms_default__database=neo4j
  - NEO4J_AUTH=neo4j/your_password

Neo4jデータベースの環境設定をしています。

NEO4J_apoc_export_file_enabled=true：APOCのエクスポート機能を有効化します。

NEO4J_apoc_import_file_enabled=true：APOCのインポート機能を有効化します。

NEO4J_apoc_import_file_use__neo4j__config=true：データインポート時に、ディレクトリ（/import）内のファイルを扱えるようにしています。

NEO4J_dbms_security_procedures_unrestricted=apoc.*：APOCライブラリ内のすべてのプロシージャを許可します。

NEO4J_dbms_memory_heap_initial__size=512m：ヒープメモリの初期サイズを512MBに設定します。

NEO4J_dbms_default__database=neo4j：デフォルトのデータベース名をneo4jに設定します。

NEO4J_AUTH=neo4j/your_password：Neo4jの認証情報を（ユーザー名:neo4j、パスワード:your_password）に指定しています。

os.environ["NEO4J_URI"] = "bolt://neo4j:7687"
os.environ["NEO4J_USERNAME"] = "neo4j"
os.environ["NEO4J_PASSWORD"] = "your_password"

Neo4jに関する環境変数を設定します。

NEO4J_URI: データベースへの接続URIです。この例では、Neo4jがboltプロトコルを使用して、ローカルのポート7687で接続されています。

NEO4J_USERNAME: データベースにアクセスするためのユーザー名です。

NEO4J_PASSWORD: データベース接続のパスワードです。「your_password」が設定されていますが、実際の使用時には適切な値に置き換える必要があります。

graph = Neo4jGraph()

Neo4jGraphクラスのインスタンスを作成します。

このインスタンスはNeo4jデータベースとの接続やクエリ実行を可能にします。

graph.query("MATCH (n)  DETACH DELETE n;")

Neo4jデータベース内のすべてのノードとリレーションシップを削除し、初期化します。

MATCH (n):Neo4jのCypherクエリで、すべてのノード (n) を検索します。

DETACH: ノードに関連付けられているすべてのリレーションシップを削除します。
Neo4jではリレーションシップが存在するノードは直接削除できません。そのため、先にリレーションシップを削除する必要があります。

DELETE n: ノード自体を削除します。

llm = OllamaFunctions(model="llama3.1", temperature=0, format="json")

OllamaでLLMのモデルが使えるように、モデルやパラメーター、出力形式を指定します。

model="llama3.1":

• 使用する言語モデルの指定しています。

temperature=0:

• モデルの創造性やランダム性を制御するパラメータです。
• 0は最も決定論的な設定であり、一貫性と正確性を重視した応答を生成します。

format="json":

• 出力形式をJSONに指定します。

ollama.pull('mxbai-embed-large')

指定したモデルをOllamaの環境にダウンロードします。

embeddings = OllamaEmbeddings(model="mxbai-embed-large")

ダウンロードしたモデルを使用して、埋め込み生成用のインスタンスを作成します。

text_path = "./text.txt"
loader = TextLoader(text_path)
raw_documents = loader.load()

テキストファイルを読み込みます。

text_path = "./text.txt": 読み込むテキストファイルのパスを指定します。text.txtは、『ワンピース』のWikiのデータから作成しています。

loader.load(): 実際にテキストファイルを読み込みます。

text_splitter = RecursiveCharacterTextSplitter(chunk_size=250, chunk_overlap=24)
documents = text_splitter.split_documents(raw_documents)

テキストデータをチャンク分割します。

chunk_size=250: 各チャンクのサイズを最大250文字に設定します。

chunk_overlap=24: 各チャンクの間で24文字分の重複を持たせます。重複により、分割されるテキスト間の文脈の継続性を保持しやすくなります。

split_documents(raw_documents): 読み込んだドキュメントを設定されたサイズと重複のルールに基づいて分割します。

llm_transformer = LLMGraphTransformer(llm=llm)
graph_documents = llm_transformer.convert_to_graph_documents(documents)

LLMを用いて、ドキュメントからエンティティやリレーションシップを抽出して、グラフデータの構造に変換します。

• 文書中のエンティティ（例: 人物、組織、場所など）をノードとして抽出。
• それらのエンティティ間の関係性（リレーションシップ）をエッジとして抽出。

graph.add_graph_documents(
  graph_documents, 
  baseEntityLabel=True, 
  include_source=True
)

Neo4jデータベースにグラフデータの追加や設定をします。

• graph_documents: LLMによって変換されたグラフ形式のデータ（エンティティとリレーションシップ）を追加します。
• baseEntityLabel=True: すべてのエンティティにベースラベル（基本的なカテゴリ）を追加します。例: Person, Locationなどのラベルが付与されます。
• include_source=True: 元のドキュメント情報をエンティティやリレーションシップに含めます。

hybrid_index = Neo4jVector.from_existing_graph(
    embeddings,
    search_type="hybrid",
    node_label="Document",
    text_node_properties=["text"],
    embedding_node_property="embedding",
)

ハイブリット検索インデックスの設定をします。

embeddings:埋め込みモデルを指定します。テキストをベクトル化し、意味的な類似度を計算するために使用されます。

search_type="hybrid":検索タイプをハイブリッド検索に指定しています。

ハイブリッド検索とは、ベクトル検索とキーワード検索を組み合わせた手法です。

node_label="Document":

Neo4jデータベース内の「Document」のラベル名を持つノードを検索対象としています。

text_node_properties=["text"]:

「text」のプロパティ名を持つノードを検索対象としています。このプロパティには、テキストデータが格納され、全文検索に使用されます。

embedding_node_property="embedding":

「embedding」のプロパティ名を持つノードを検索対象としています。このプロパティには、ベクトルデータが格納され、ベクトル検索に使用されます。

unstructured_retriever = hybrid_index.as_retriever()

ハイブリット検索インデックスからクエリに基づいて関連情報を取得するリトリーバーを作成します。

driver = GraphDatabase.driver(uri=url, auth=(username, password))

Neo4jデータベースへの接続を確立します。

def create_fulltext_index(tx):
    query = '''
    CREATE FULLTEXT INDEX `fulltext_entity_id` 
    FOR (n:__Entity__) 
    ON EACH [n.id];
    '''
    tx.run(query)

Neo4jに対して全文検索インデックスを作成するクエリを定義します。

• create_fulltext_index(tx)：tx内でクエリを実行します。

• CREATE FULLTEXT INDEX fulltext_entity_id``：インデックス名をfulltext_entity_idと定義しています。
• FOR (n:__Entity__)：__Entity__ラベルが付いたノードがインデックスの対象になります。
• ON EACH [n.id]：ノードのプロパティidが全文検索の対象になります。

def create_index():
    with driver.session() as session:
        session.execute_write(create_fulltext_index)
        print("Fulltext index created successfully.")

Neo4jのセッションを開き、全文検索インデックスを作成するクエリを実行します。

• with driver.session():Neo4jとのセッションを開きます。
• session.execute_write(create_fulltext_index):書き込みトランザクションモードで、Neo4jに対して、全文検索インデックス作成クエリを実行します。

try:
    create_index()
except:
    pass

driver.close()

インデックス作成時に発生する例外処理

• try...except:インデックス作成時にすでに同じインデックスが存在していたり、エラーが発生した場合でも、プログラムを停止せずに処理を続行します。
• driver.close():データベース接続をクローズします。

class Entities(BaseModel):
    names: list[str] = Field(
        ...,
        description="All the person, organization, or business entities that "
        "appear in the text",
    )

エンティティ情報を格納するためのデータモデルを定義しています。

• Entitiesは、エンティティ（人物名や組織名など）を格納するためのデータモデルです。
• BaseModel: Pydanticから提供されるクラスで、データの型検証やバリデーション機能を提供します。
• names: list[str]: namesフィールドは、抽出された人名や組織名、企業名などのエンティティをリスト形式で保持します。
• Field(...):フィールドが必須であることを意味します。
• description：このフィールドの説明を記述しています。

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}",
        ),
    ]
)

このプロンプトはLLMに対して、入力された質問文から組織名や人物名を特定するように指示します。

• システムメッセージでは、モデルに対する指示や役割を設定します。「組織や人物のエンティティを抽出する」ことを指示します。
• ユーザーメッセージでは、実際に人間がモデルに質問する部分を定義します。入力テキストから指定されたフォーマットに従って情報を抽出するように求めています。

entity_chain = prompt | llm.with_structured_output(Entities)
entity_chain.invoke({"question":"Who are Luffy and Shanks?"})

エンティティ抽出用チェーンの構築し、エンティティの抽出を実行しています。

prompt | llm.with_structured_output(Entities)：promptをllmに渡します。LLMの出力をEntitiesデータモデルに従って整形します。

entity_chain.invoke({"question":"Who are Luffy and Shanks?"})：作成したチェーンにクエリを入力して実行しています。

words = [el for el in remove_lucene_chars(input).split() if el]

Luceneにおける特殊文字の除去や空要素を除外し、空でない単語のみをリストに格納します。

• remove_lucene_chars(input):Luceneクエリにおける特殊文字を取り除き正規化します。
  • 特殊文字の例: + - && || ! ( ) { } [ ] ^ " ~ * ? : \ / など。
• .split():入力文字列をスペース区切りで単語に分割し、単語リストを作成します。
• if el:空白文字列を除外します。

for word in words[:-1]:
    full_text_query += f" {word}~2 AND"
full_text_query += f" {words[-1]}~2"

曖昧検索や複数キーワード検索に対応します。

• full_text_query += f" {word}~2 AND":
  • 各単語に曖昧検索の指定~2を追加します。
  • ~2 は、2文字以内の違いがある単語を検索対象に含み、類似した単語を検索できます。
  • 単語同士は AND 演算子で結合し、複数条件を満たす検索を指定します。
• full_text_query += f" {words[-1]}~2"：ループ外で処理される最後の単語にも曖昧検索指定（~2）を追加しますが、無効なクエリとならないように、最後の単語には AND 演算子を付けません。

return full_text_query.strip()

クエリの前後に不要なスペースがあれば除去して返します。

entities = entity_chain.invoke(question)

質問文questionを入力として、エンティティ抽出をするチェーンを実行します。

for entity in entities.names:

抽出されたエンティティごとに、グラフ検索のクエリを実行します。

graph.query(
     """
     CALL db.index.fulltext.queryNodes('fulltext_entity_id', $query, {limit:2})
     YIELD node,score
     (省略)
     """, 
    {"query": generate_full_text_query(entity)},
)

全文検索インデックスを使用して、エンティティに一致するノードを検索します。

• graph.query()の動作の流れ
  • {"query": generate_full_text_query(entity)}は、Lucene形式の検索クエリを作成します。
  • 上記で作成したクエリを以下の$queryに挿入します。
  • CALL db.index.fulltext.queryNodesを使い、Neo4jの全文検索インデックスからエンティティ名に関連するノードを検索します。

• graph.query()の引数の説明
  • fulltext_entity_id：全文検索インデックス名を指定しています。
  • $query：クエリに一致するノードを検索します。（エンティティに関連するノードを検索）
  • {limit:2}：取得する最大ノード数を２つに設定しています。

• YIELD node, score：
  CALLが返すデータの中からどのフィールドを抽出するかを指定します。ここでは検索されたノードとマッチングのスコアを取得しています。

• {"query": generate_full_text_query(entity)}：
  entityを入力として受け取り、Lucene形式の検索クエリを作成します。検索クエリは曖昧検索や複数条件検索に対応しています。ここで作成したクエリが上記の$queryに挿入されます。

CALL (node) {
  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

指定されたノードとに関連する隣接ノードとリレーションシップを検索します。

• CALL(node){ ... } ：サブクエリを実行するために使用される構文です。
• WITH node ：外部クエリからサブクエリに変数 node を引き継ぐために使用されます。
• MATCH (node)-[r:!MENTIONS]->(neighbor):node に関連する隣接ノードと外向きのリレーションシップを検索します。
  • neighbor は、隣接ノード（関連するノード）です。
  • [r:!MENTIONS] の ! は、否定リレーション演算子で、MENTIONS 以外の関係でつながっているノードを見つけます。
• RETURN node.id + ' - ' + type(r) + ' -> ' + neighbor.id AS output：ノードのID、リレーションのタイプ、および隣接ノードのIDを文字列で結合し、output として返します
  • 例："Luffy - RESCUER -> Robin"
• UNION ALL:外向きと内向きのリレーションシップを個別に取得して、重複を排除しません。
• (node)<-[r:!MENTIONS]-(neighbor) :node に向か内向きのリレーションシップを探索します。
• RETURN neighbor.id + ' - ' + type(r) + ' -> ' + node.id AS output：隣接ノードのID、リレーションのタイプ、およびノードのIDを文字列で結合し、output として返します。
  • 例:Robin - ADMIRES -> Luffy
• 結果制限:LIMIT 50で最大50件の結果を取得します。

{"query": generate_full_text_query(entity)}

クエリ文字列内の $query プレースホルダーに以下の値を動的に埋め込みます。

エンティティ名を Lucene構文の全文検索クエリに変換し、曖昧検索や複数条件の検索に対応した値が入ります。

result += "\n".join([el['output'] for el in response])

リストから文字列への変換し、改行区切りで連結します。

structured_data = structured_retriever(question)

質問をもとにグラフ検索を行い、エンティティやリレーションシップを取得します。

unstructured_data = [el.page_content for el in unstructured_retriever.invoke(question)]

質問に関連する情報をハイブリット検索（ベクトル検索＋キーワード検索）で取得します。

final_data = f"""Structured data:
{structured_data}
unstructured_data:
{"#Document ". join(unstructured_data)}
"""

グラフ検索とハイブリット検索のデータをまとめて一つの文字列にフォーマットします。

template = """Answer the question based only on the following context:
{context}

Question: {question}
Use natural language and be concise.
Answer:"""

質問応答のテンプレートを作成します。

• {context}:full_retriever から取得したグラフ検索とハイブリット検索の統合データが入ります。
• {question}: ユーザーの質問が入ります。

chain = (
        {
            "context": full_retriever,
            "question": RunnablePassthrough(),
        }
    | prompt
    | llm
    | StrOutputParser()
)

入力データを順次処理して最終結果を生成するチェーンを作成します。

• context: full_retriever を呼び出し、グラフ検索とハイブリット検索の統合データを取得します。
• question: 質問はそのまま使用します。
• prompt:プロンプトテンプレートにデータを埋め込みます。
• llm:プロンプトに基づきLLMが自然言語で回答します。
• StrOutputParser():LLMの出力を文字列形式で解析し、最終的な結果を返します。