[Question]: Persisting (and loading) index from Neo4j

[kylemassimilian]

Question Validation

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

Question

I assume you do not have to persist an index after building it using Neo4J... but how do you load the index in?

`def build_neo4j():
    llm = OpenAI(model="gpt-3.5-turbo", temperature=0.1)
    service_context = ServiceContext.from_defaults(llm=llm)
    documents = SimpleDirectoryReader("Data - demo").load_data()
    

    graph_store = Neo4jGraphStore(
        username=username,
        password=password,
        url=url,
        database=database,
    )
    storage_context = StorageContext.from_defaults(graph_store=graph_store)
    index = KnowledgeGraphIndex.from_documents(documents, storage_context, max_tiplets_per_chunk=2, show_progress=True)
`

TY

[dosubot[bot]]

🤖

Hello,

To load an index after building it using Neo4J in the LlamaIndex framework, you can use the load_index_from_storage function from the llama_index.indices.loading module. This function takes a StorageContext object and an optional index_id as arguments. If index_id is not provided, it assumes there's only a single index in the index store and loads it. If there are multiple indices, you need to specify the index_id.

Here is the relevant code:

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

# create a storage context
storage_context = StorageContext(docstore, index_store, vector_store)

# load the index
index = load_index_from_storage(storage_context, index_id='your_index_id')

In this code, docstore, index_store, and vector_store are the document store, index store, and vector store respectively that you have set up for your application. Replace 'your_index_id' with the ID of the index you want to load. After the index is loaded, you can use it for your operations.

Please note that the load_index_from_storage function is used to load a single index from the storage context. The function first checks if an index_id is provided. If it is, it sets index_ids to a list containing the index_id. If not, it sets index_ids to None. It then calls the load_indices_from_storage function with the storage_context and index_ids as parameters, along with any additional keyword arguments.

If no indices are returned, it raises a ValueError stating "No index in storage context, check if you specified the right persist_dir." If more than one index is returned, it raises a ValueError stating "Expected to load a single index, but got {len(indices)} instead. Please specify index_id."

If exactly one index is returned, it returns that index.

I hope this helps! Let me know if you have any other questions.

Best,
Dosu

Sources

• llama_index/tools/tool_spec/load_and_search/base.py
• llama_index/indices/loading.py
• tests/indices/test_loading.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.

[kylemassimilian]

I'm getting the message "No index in storage context, check if you specified the right persist_dir." from my code:

`def query_index(query):
       graph_store = Neo4jGraphStore(
        username=neo_username,
        password=neo_password,
        url=neo_url,
        database=neo_database,
    )
       neo_storage_context = StorageContext.from_defaults(graph_store=graph_store)

       neo_index = load_index_from_storage(neo_storage_context)

       graph_storage_context = StorageContext.from_defaults(persist_dir=kg_demo_persist_dir, fs=s3)
       kg_index = load_index_from_storage(graph_storage_context, "demo_kg_index")
       
       vector_storage_context = StorageContext.from_defaults(persist_dir=vector_demo_persist_dir, fs=s3)
       vector_index = load_index_from_storage(vector_storage_context, "demo_vector_index")
       vector_retriever = VectorIndexRetriever(index=vector_index)
       kg_retriever = KGTableRetriever(index=kg_index, 
                                        retriever_mode="keyword", include_text=False)
       custom_retriever = CustomRetriever(vector_retriever, kg_retriever)

       service_context = ServiceContext.from_defaults(llm=llm, chunk_size=512)
       
       reponse_synthesizer = get_response_synthesizer(
        service_context=service_context,
        response_mode="tree_summarize")
       
       custom_query_engine = RetrieverQueryEngine(
        retriever=custom_retriever, response_synthesizer=reponse_synthesizer
    )
    
       # For more detailed answers, send the text from where the triplets were extracted `include_text=True` to LLM
       kg_query_engine = neo_index.as_query_engine(respone_mode="tree_summarize", include_text=True)

       vector_query_engine = vector_index.as_query_engine()

       print("Querying query engine...")
       start_time = time.time()
       
       response = kg_query_engine.query(query)
       #sources = [source_node.node.metadata["file_name"] for source_node in response.source_nodes]
       #source_text = [source_nodes.node.get_text() for source_nodes in response.source_nodes]
       
       end_time = time.time()
       execution_time = end_time - start_time
       print("Query Time:", execution_time)
       return response`

after persisting the index:

`def build_neo4j():
    llm = OpenAI(model="gpt-3.5-turbo", temperature=0.1)
    service_context = ServiceContext.from_defaults(llm=llm)
    documents = SimpleDirectoryReader("Data - small").load_data()

    graph_store = Neo4jGraphStore(
        username=neo_username,
        password=neo_password,
        url=neo_url,
        database=neo_database,
    )
    storage_context = StorageContext.from_defaults(graph_store=graph_store)
    neo_index = KnowledgeGraphIndex.from_documents(documents, storage_context, max_tiplets_per_chunk=2, 
                                               service_context=service_context, show_progress=True)
    neo_index.storage_context.persist()
    `

and I'm pretty sure my credentials are right (username = neo4j, password = the password when I created my account, url is copy and pasted from the neo4j console with the port, database = neo4j).

Do I need to use bolt here?

but it's probably an issue with my neo4j creds. Can I have some help with these?

`INFO:llama_index.indices.loading:Loading all indices.
Loading all indices.
Traceback (most recent call last):
  File "C:\Users\Kyle\DEV\Satori\IX MVP\scripts\prep_docs6.py", line 324, in <module>
    reponse = query_index(query)
  File "C:\Users\Kyle\DEV\Satori\IX MVP\scripts\prep_docs6.py", line 261, in query_index
    neo_index = load_index_from_storage(neo_storage_context)
  File "C:\Users\Kyle\DEV\Satori\IX MVP\venv\lib\site-packages\llama_index\indices\loading.py", line 36, in load_index_from_storage
    raise ValueError(                                                                                                                       bject at 0x0000012FDBB305B0>.    
ValueError: No index in storage context, check if you specified the right persist_dir.
C:\Users\Kyle\DEV\Satori\IX MVP\venv\lib\site-packages\neo4j\_sync\driver.py:485: ResourceWarning: Unclosed <neo4j._sync.driver.BoltDriver object at 0x0000012FDBB305B0>.
Object allocated at (most recent call last):
  File "C:\Users\Kyle\DEV\Satori\IX MVP\venv\lib\site-packages\neo4j\_sync\driver.py", line 1220
    return cls(pool, default_workspace_config)
  unclosed_resource_warn(self)
Object allocated at (most recent call last):                                                                                                e the session is deprecated. Plea
  File "C:\Users\Kyle\DEV\Satori\IX MVP\venv\lib\site-packages\neo4j\_sync\driver.py", lineno 1220                                           driver will not close drivers au
    return cls(pool, default_workspace_config)
C:\Users\Kyle\DEV\Satori\IX MVP\venv\lib\site-packages\neo4j\_sync\driver.py:489: DeprecationWarning: Relying on Driver's destructor to close the session is deprecated. Please make sure to close the session. Use it as a context (`with` statement) or make sure to call `.close()` explicitly. Future versions of the driver will not close drivers automatically.
  deprecation_warn(`

[raffieeey]

I'm having the same issue, did you manage to solve this?

[fabianslife]

Same issue, I dont know how to laod a graph index after populating it.

[sonalimeh]

I'm having the same issue, if you have solved it, can you please share the steps?

[Huirouuu]

same issue, any updates?

[kylemassimilian]

Would love some guidance here. Added a test function to my file, so it appears my credentials are correct but my llamaindex code is not.

`
def test_neo4j_connection(neo_url, neo_username, neo_password):
    driver = None
    try:
        driver = GraphDatabase.driver(neo_url, auth=(neo_username, neo_password))
        print("Connection to Neo4j database successful.")
    except Exception as e:
        print(f"Failed to connect to Neo4j database. Error: {e}")
    finally:
        if driver is not None:
            driver.close()`

Connection to Neo4j database successful.

[ccrvlh]

Similar situation when using ChromaDB. The SQLite is populated, I have the file, built the context with the vector store, but can't load the index:

chroma_client = chromadb.PersistentClient("chroma.db")
chroma_collection = chroma_client.get_or_create_collection("my_collection")
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = load_index_from_storage(storage_context=storage_context)

I had initially built the index with the storage context (using the vector_store from ChromaVectorStore with the loaded collection):

storage_context = StorageContext.from_defaults(vector_store=vector_store)
service_context = ServiceContext.from_defaults(embed_model=embed_model)
index = VectorStoreIndex(index_struct=IndexDict(), storage_context=storage_context, service_context=service_context)

And then added the nodes to the index with index.insert_nodes.
I wonder what's necessary to actually load the index?

[ccrvlh]

Just realized there's a difference between a VectorStore and an IndexStore. So I was able to reload the index with the exact same code, using the existing collection. I'm still a bit lost on this since I can build a vector_store using my existing collection, and I can build a storage_context with the vector_store, and the load_index_from_storage accepts the storage_context, so maybe I can only load_index_from_storage when I persisted the index? Not sure what it means though, since I though I was automatically persisting the vector when I used a VectorStore with a persistent client.