[Question]: How to save and load knowledge graph.

[SiraHaruethaipree]

Question Validation

• I have searched both the documentation and discord for an answer.

Question

Hi
Can anyone help me to find the solution for saving the knowledge graph create from KnowledgeGraphIndex.
Thanks

[dosubot[bot]]

🤖

Hi,

To save the knowledge graph created from KnowledgeGraphIndex, you can use the persist method of the SimpleIndexStore class. This method is responsible for persisting the index store to a file. Here is an example of how you can use it:

# Assuming `index_store` is an instance of SimpleIndexStore
index_store.persist(persist_path="path_to_your_file.json")

In this example, "path_to_your_file.json" is the path where you want to save the knowledge graph. If you don't provide a file system (fs), it will use the default one (fsspec.filesystem("file")).

The persist method first checks if the directory of the provided path exists, if not, it creates the directory. Then, it opens the file in write mode and dumps the index store data into it in JSON format.

Please note that the actual implementation of the persist method is provided in the SimpleIndexStore class in the llama_index/storage/index_store/simple_index_store.py file.

The KnowledgeGraphIndex is a class that extends the BaseIndex class and is used to build a Knowledge Graph (KG) by extracting triplets and leveraging the KG during query-time. It is designed to work with the LLM (Language Model) application and uses the LLM's prediction capabilities to extract triplets from the text.

The KnowledgeGraphIndex is related to the SimpleIndexStore through the graph_store attribute. The graph_store is an instance of the GraphStore class, which could be an instance of SimpleGraphStore or any other class that extends GraphStore. The graph_store is used to store the relationships between different nodes in the graph.

In the KnowledgeGraphIndex class, the graph_store is used in several methods such as upsert_triplet where it is used to insert triplets into the graph store. It is also used in the get_networkx_graph method to get the relationship map of the graph.

I hope this helps! If you have any other questions, feel free to ask.

Best,
Dosu

Sources

• [Question]: How I save to disk an index?
• llama_index/graph_stores/types.py
• llama_index/graph_stores/simple.py
• llama_index/storage/index_store/simple_index_store.py
• llama_index/indices/knowledge_graph/base.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[SiraHaruethaipree]

But, I don't sure this code below is correct or not for download knowledge. Because the result when I generate, it not relative with my document.

`llm_predictor = LLMPredictor(llm=LangChainLLM(llm = load_llm()))
embed_model = LangchainEmbedding(HuggingFaceEmbeddings(
        model_name = "sentence-transformers/all-MiniLM-L6-v2",
        model_kwargs = {'device': 'cuda'}))
service_context = ServiceContext.from_defaults(
        llm_predictor=llm_predictor, 
        chunk_size=1000, 
        embed_model = embed_model)

storage_context_graph = StorageContext.from_defaults(persist_dir="index_folder")
kg_index = load_index_from_storage(storage_context = storage_context_graph, service_context = service_context)`

[logan-markewich]

That is indeed the correct way to load an index

What's the exact issue you are facing? Is there a difference in behavior before and after saving/loading?

[SiraHaruethaipree]

I have an idea to integrate knowledge graph with vector index for receive the better URL link referent. However, at the moment I need save and load the knowledge graph because it too large of data, But I am encountering issues where the results knowledge graph not match with my information in documents and provide incorrect information., and sometimes I receive empty results when the Knowledge graph. This my code below :

def load_llm():
    n_gpu_layers = 32 
    n_batch = 512  
    callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
    llm = LlamaCpp(
        model_path="llama-2-7b-chat.ggmlv3.q8_0.bin",
        callback_manager=callback_manager,
        n_gpu_layers=n_gpu_layers,
        n_batch=n_batch,
        verbose=True,
        n_ctx = 4096, 
        temperature = 0.1, 
        max_tokens = 4096
    )
    return llm
llm_predictor = LLMPredictor(llm=LangChainLLM(llm = load_llm()))
embed_model = LangchainEmbedding(HuggingFaceEmbeddings(
        model_name = "sentence-transformers/all-MiniLM-L6-v2",
        model_kwargs = {'device': 'cuda'}))
service_context = ServiceContext.from_defaults(
        llm_predictor=llm_predictor, 
        chunk_size=1000, 
        embed_model = embed_model)

#Graph Vector
storage_context_graph = StorageContext.from_defaults(persist_dir="./llama7b_graph_index",)
kg_index = load_index_from_storage(storage_context = storage_context_graph, service_context = service_context)

kg_keyword_query_engine = kg_index.as_query_engine(
    include_text=False,
    retriever_mode="keyword",
    response_mode="tree_summarize",
)

response = kg_keyword_query_engine.query("Who is Philipp Koehn")
display(Markdown(f"<b>{response}</b>"))

[logan-markewich]

Empty results can happen if no keywords from the query match the knowledge graph, then there is no info to generate a response with 🤔

However, you can combine a vector index with a kg index by following this notebook. No need to use nebula though, the default kg index works fine too

https://gpt-index.readthedocs.io/en/stable/examples/index_structs/knowledge_graph/KnowledgeGraphIndex_vs_VectorStoreIndex_vs_CustomIndex_combined.html

[soufianechami]

@dosu-bot

I'm trying to save and reload a Nebula graph knowledge index using the following example code, but I'm unsure how to proceed. Could you provide some guidance? WHat you provided above is only for SimpleIndexStore. I am using Nebula graph databa.

Reproducible Example

from your_package import NebulaGraphStore, OpenAI, OpenAIEmbedding, ServiceContext, StorageContext, KnowledgeGraphIndex

# Initialize Nebula Graph Store
space_name = "MYEAC_ASSISTANT_TEST"
edge_types, rel_prop_names = ["relationship"], ["relationship"]
tags = ["entity"]

graph_store = NebulaGraphStore(
    space_name=space_name,
    edge_types=edge_types,
    rel_prop_names=rel_prop_names,
    tags=tags,
)

# Initialize Language Models
llm_model_name = 'gpt-3.5-turbo-16k'
embedding_model_name = 'text-embedding-ada-002'

llm = OpenAI(temperature=0, model=llm_model_name)

embedding_llm = OpenAIEmbedding(
    model=embedding_model_name,
    api_key="your_openai_api_key",
    api_base="your_openai_api_base",
    api_type="your_openai_api_type",
    api_version="your_openai_api_version",
)

# Initialize Service Context
service_context = ServiceContext.from_defaults(
    llm=llm,
    embed_model=embedding_llm,
    chunk_size_limit=512
)

# Initialize Graph Storage Context
graph_storage_context = StorageContext.from_defaults(graph_store=graph_store)

# Create Knowledge Graph Index
kg_index = KnowledgeGraphIndex.from_documents(
    "your_base_document_data",
    storage_context=graph_storage_context,
    max_triplets_per_chunk=10,
    space_name=space_name,
    edge_types=edge_types,
    rel_prop_names=rel_prop_names,
    tags=tags,
    include_embeddings=True,
)

Question

Now, I want to save the kg_index object and load it again later. How can I achieve this?

[HOTSONHONET]

Even I am searching for methods. The below code will load your simple graph store if you have used the persist method when kg_index is instantiated.

....


kg_index = KnowledgeGraphIndex.from_documents(
    "your_base_document_data",
    storage_context=graph_storage_context,
    max_triplets_per_chunk=10,
    space_name=space_name,
    edge_types=edge_types,
    rel_prop_names=rel_prop_names,
    tags=tags,
    include_embeddings=True,
)


# Method to save your simple graph store
kg_index.storage_context.persist("<path-to-your-save-directory>")

This code shows how you can reload it again

from llama_index.storage.storage_context import StorageContext
from llama_index.indices.loading import load_index_from_storage

kg_index = load_index_from_storage(
                storage_context = StorageContext.from_defaults(
                    persist_dir = "<path-to-your-save-directory>"
                ),
                index_id = "<your-kg-index-id>" # Optional, if you created multiple indices then only you need it
            )

[LacombeLouis]

Hey @HOTSONHONET,
What if you already have a Nebula graph (on a Docker Image). Do you know how to request it again or how to access the file?
I created the graph directly in Nebula, so I don't have the opportunity to persist the storage.
Thank you!

[devstein]

Hey @soufianechami right now Dosu only responds to issue authors to keep the discussion focused to their issue. We're working on a way to allow users to "fork" a conversation and chat without outside of Github, so stay tuned!

[logan-markewich]

@soufianechami the sample code there is basically correct.

Setup the graph store to point to your existing graph store in nebula, throw it into the storage context, and off you go (since it's in nebula, there is no saving step)

[LacombeLouis]

Hey @logan-markewich,
How do I load the indices if they are already in the NebulaGraph? How do I create my kg_index?
Note: I have created my graph directly in NebulaGraph, so it never created a persist_dir='./storage_graph'.
Thank you!

[HOTSONHONET]

The loading of a simple graph store is taking a very long time, is there any way to load it faster?