Since NebulaGraph’s [joint introduction with LlamaIndex](https://www.nebula-graph.io/posts/graph-RAG) in August 2023, Graph RAG has been at the forefront of a technological revolution. It addresses the limitations of conventional search enhancement techniques by providing a more contextually aware and data-trained approach, ensuring that the responses delivered are not only precise but also well-informed.

Today, at the VLDB 2024 LLM+ KG Workshop, we are thrilled to announce the groundbreaking platform designed under the Graph RAG idea to simplify the creation of knowledge applications without the need for programming skills, NebulaGraph RAG.

![image](https://www-cdn.nebula-graph.io/blogs/wey_presenting.JPG)

*Wey Gu, the GenAI lead at NebulaGraph, presenting NebulaGraph RAG at VLDB 2024 LLM+ KG workshop*

# What is NebulaGraph RAG?
NebulaGraph RAG is a minimalistic knowledge application builder that puts the power of Graph RAG technology at your fingertips. It's the go-to solution for users to create search engines, chat bots, and content generation apps through a simple dialogue interface. By activating and circulating internal knowledge, NebulaGraph RAG maximizes its value, turning insights into actions.

# Why NebulaGraph RAG?
For many enterprises, the rich expertise and business insights of team members were often confined to a few, creating knowledge silos and consultation bottlenecks. For domain experts without a computer science background, GenAI technologies like DAG, Workflow, Agent, and RAG can be daunting, posing a significant barrier to the adoption of AI capabilities. As a result, only personnel of the data or AI department typically utilize these advanced tools, akin to how only a few people master complex BI and advanced statistical functions in Excel.

NebulaGraph RAG lowers the barrier to entry for these advanced tools, empowering every employee to create and optimize applications based on their domain knowledge. Guided by an intuitive dialogue interface, users can construct and refine applications as naturally as conversing with a colleague. From next-gen search engines to customer service Q&A systems, report generators, and troubleshooting tools, NebulaGraph RAG integrates cutting-edge technologies with simplicity at its core.

![image](https://www-cdn.nebula-graph.io/blogs/RAG-user-interface.png)
*User Application Interface: GraphRAG Answer Referenced Graph Context*

## Main Benefits for Users
- **Simplified Custom Solution Creation**: Enterprises can effortlessly build customized knowledge applications tailored to their complex needs, optimizing internal workflows without delving into technical details.

- **Inclusive Knowledge Application Building**: With a well-designed user interface and streamlined processes, employees can independently create knowledge bases and build applications. This inclusive approach accelerates the flow of information and resources within the enterprise, enhancing decision-making speed and accuracy.

- **Seamless Integration of Cutting-Edge Technology at Reduced Costs**: By leveraging the latest advanced RAG and Graph RAG technologies without additional development or costly training, businesses can quickly innovate in knowledge management and application creation, accelerating business innovation and value creation.

- **Instant Access to Internal Knowledge Bases**: The search and Q&A capabilities of NebulaGraph RAG enable businesses to rapidly construct search engines for internal knowledge bases, increasing the speed and efficiency with which employees access critical information.

![image](https://www-cdn.nebula-graph.io/blogs/RAG-build-apps.jpg)

*App building interface: Set up, maintain, and optimize apps through natural language*

# Ready to Elevate Your Knowledge Management into RAG Apps?

Compared to other toB RAG products on the market, NebulaGraph RAG excels not only in its exceptional Graph RAG capabilities, but also user-friendliness and accessibility. While other solutions may require extensive programming knowledge and technical expertise, NebulaGraph RAG ensures that even non-technical users can harness the power of advanced AI technologies. Leveraging NebulaGraph RAG will reduce costs of knowledge management, and surely foster a more inclusive and innovative work environment.
Interested in transforming your enterprise's knowledge application capabilities? [Fill out the form](https://www.nebula-graph.io/contact) for a free trial!

We are thrilled to announce NebulaGraph RAG,  the groundbreaking platform designed to simplify the creation of knowledge applications without the need for programming skills

Announcing NebulaGraph RAG: From Knowledge to Apps in Minutes

The advent of AIGC has introduced a new paradigm in content creation, where AI systems generate a wide array of media types, from text to complex visual art. However, the complexity of relationships within data can be challenging for traditional databases. Graph databases offer a solution with their ability to model and navigate the intricate connections between data points, providing a powerful infrastructure for AIGC systems.

# Graph Databases: A Catalyst for AIGC Innovation

## Complex Relationship Management
Traditional relational databases excel in handling structured data but often fall short when dealing with complex relationships. Graph databases, however, are specifically designed to manage complex relationships between entities. They visually represent the connections and dependencies between data points in a graph form. In AIGC scenarios, this capability is particularly vital as it involves understanding and analyzing vast amounts of text and data. Graph databases can efficiently store and query relationships between entities, aiding AI systems in comprehending contextual information deeply and uncovering the underlying complex relationships within data.

## Advanced Querying Capabilities
The advanced querying capabilities of graph databases, such as hybrid vector search and graph pattern matching, offer AIGC an unprecedented ability to retrieve and integrate information. The input for large models is no longer confined to a single document or sentence but can perform a leapfrog search across the entire knowledge graph, achieving cross-domain and cross-document associative queries. This "chain of thought" querying, made possible by the advanced querying features of graph databases, enables AI to mimic human thought processes, navigating flexibly between multiple knowledge points to generate comprehensive and accurate responses.

## Enhancing Efficiency and Quality
The application of graph algorithms through graph databases can significantly speed up AIGC processes and improve the quality of content. Graph databases support the storage of vectorized graphs, allowing graph algorithms to operate on them and solve certain problems within AIGC. For instance, graph algorithms can capture entities and their relationships within a paragraph or summarize and categorize all entities and their relationships in a book. This capability enables graph-based AIGC systems to understand vast amounts of natural language text efficiently without the need for expert intervention. Moreover, graph algorithms can quickly locate relevant information nodes and their relationships, reducing unnecessary information processing steps and thus greatly enhancing the efficiency of content generation and the quality of AIGC.

## Visualization of Reasoning Chains
The visual capabilities of graph databases provide an intuitive way to display the reasoning process of AIGC systems. Through graphical interfaces, users can clearly see every step and logical chain in the reasoning process. This visualization not only enhances the system's transparency and credibility but also helps users better understand the sources and basis of the generated content. In fields such as academic research and business decision-making, this visual reasoning chain is crucial for improving the accuracy and reliability of decision-making.

# Real-world Applications of Graph Databases in AIGC
## Intelligent Q&A Systems
With the support of graph databases, intelligent Q&A systems can not only perform information retrieval and reasoning through traditional knowledge graphs but also support vectorized knowledge graphs. This means the system can manage and retrieve vector data, integrating intelligent Q&A technology based on graph queries and graph calculations with advanced technology based on vector retrieval. This integration not only improves the accuracy and efficiency of Q&A but also significantly reduces additional data storage and management overhead, bringing a smoother and smarter experience to users. At the same time, with the aid of AIGC technology, the system can generate richer and more personalized content, further enhancing user experience and satisfaction.

## News Media and Short Videos
The combination of graph databases and AIGC technology has shown great potential in the fields of internet news media and self-media short videos. By efficiently managing complex relational data through graph databases, AIGC technology can accurately analyze user behavior and automatically generate personalized content. In news recommendations, the combination of the two can quickly match user interests with news hotspots; in the field of short videos, it can achieve intelligent editing and distribution, enhancing user experience and platform efficiency. This integrated application is leading a new trend in the production and dissemination of internet content.

## Content Creation Assistance
For content creators, graph databases provide immense value by integrating vast data resources from the internet into a comprehensive knowledge graph, facilitating tasks such as inspiration, material search, and content integration. Creators can use this graph for inspiration, material search, and content integration. The support of graph databases makes content creation more efficient, accurate, and creative.

# Core Value of Graph Databases to AIGC
## Enhancing Content Quality and Richness
Graph databases provide a comprehensive network of entity relationships as a knowledge base support for AIGC systems. This allows AIGC systems to fully consider the complex relationships and diverse connections between entities when generating content, resulting in content that is closer to reality, rich in depth and breadth. In addition, by combining the reasoning capabilities of large models, AIGC systems can also generate personalized content according to users' specific needs and preferences, further enhancing the richness and appeal of the content.

## Reducing Generation Costs
Although the construction and maintenance costs of graph databases are relatively high, once they are built and integrated with AIGC systems, their efficient data processing and utilization capabilities will significantly reduce the costs associated with content generation. Since graph databases have the advantages of fully utilizing existing data resources, greatly reducing expert intervention, and improving the efficiency of new data collection and processing, the costs at multiple stages of content generation tasks will be significantly reduced. This is of great significance for enterprises and institutions that require a large output of content.

## Improving the Accuracy and Interpretability of Reasoning
The graph model used in graph databases can help make the reasoning process clearer and traceable. When using graph databases as the basis for reasoning in AIGC systems, it can ensure that every step of the reasoning process has a clear logical basis and data support. This interpretability not only enhances users' trust in the generated content but also helps to identify potential problems and areas for improvement. At the same time, further improving the transparency and credibility of the reasoning process by visualizing the reasoning chain is also an important direction for future development.

# Challenges and Future Prospects
## Construction Costs and Technical Thresholds
Currently, the method of relying on experts to manually construct knowledge graphs is relatively costly and technically demanding, which limits the wider application of knowledge graphs. To reduce construction costs and improve usability, the market has begun to see the emergence of some automated construction tools and technical means, such as the automated AIGC approach we currently provide, which supports the low-cost and efficient construction of knowledge graphs. At the same time, strengthening cross-domain cooperation and exchange also helps to promote the popularization and expansion of the application range of graph database technology.

## Data Quality and Updating Issues
Data quality is crucial for AIGC, and data cleaning is often costly, which is a major challenge faced by the industry. Based on graph databases, users can use graph pattern matching, association relationship analysis, and other means to effectively identify and handle erroneous or low-quality data. To ensure the completeness, accuracy, and timeliness of the data in the graph database, we can take various measures, such as introducing missing association relationship prediction technology and generation technology, anomaly detection technology based on graph algorithms and graph analysis, to timely capture and process new data source information; at the same time, strengthen the data verification and cleaning process to ensure the accuracy and integrity of the data; and establish an effective data sharing and collaboration mechanism to promote the integration and utilization of cross-domain data.

# Industry Application Expansion and Standardization
As technology continues to mature and application scenarios expand, the integration of graph databases and AIGC will be applied in more industries and achieve significant results. To promote the healthy development and widespread application of this field, it is particularly important to establish unified standards and specifications to guide the research and development and application practices of technology. These standards and specifications can cover aspects such as data formats, interface protocols, and performance evaluation methods to ensure interoperability and compatibility between different systems and platforms. At the same time, standardization work can also promote technical exchange and cooperation across fields. The vector data management related functions in the database are being considered for inclusion in the future versions of SQL and GQL standards, and this topic is still actively discussed in the industry. This standardization process will undoubtedly help further collaboration and integration of AIGC and databases, thereby promoting the common progress and development of the entire industry.

# Conclusion
As a solid foundation for AIGC, graph databases have demonstrated powerful capabilities in organizing, querying, and reasoning information, significantly enhancing the quality and efficiency of content generation. With ongoing technological advancements and expanding application scenarios, the application prospects of graph databases in the field of AIGC will undoubtedly be broader. 

[The Graph RAG proposed by NebulaGraph](https://www.nebula-graph.io/posts/graph-RAG) last year is undoubtedly a profound insight and positive response to this trend. If you’re interested in developing your AI products empowered by one of the leading graph databases, NebulaGraph, feel free to [reach out](https://www.nebula-graph.io/contact).

Graph databases are the backbone for AIGC because the advanced querying capabilities enhance AI's ability to understand complex data relationships.

Graph Databases: The Ultimate Tool for Enhancing AIGC Quality and Efficiency

*This blog is written by [Diego Sanmartin](https://www.linkedin.com/in/dsanmart/) and originally published on [Medium](https://medium.com/@dsanmart/kg-rag-bridging-the-gap-between-knowledge-and-creativity-of-llm-based-agents-d03754bfb9c1 )*

Large language models (LLMs) have emerged as potential sparks for Artificial General Intelligence (AGI), offering hope for the development of versatile intelligent systems 👀.

# ➕ Bonus: What are intelligent systems?
As a bonus before delving into the topic of the article, it’s nice to understand the historical context and definitions of intelligent systems. The essence of intelligence has been a constant subject of study over time, reflecting centuries of philosophical inquiry and scientific exploration, as can be seen in the following quotes:
> Denis Diderot (1746): “If they find a parrot who could answer to everything, I would claim it to be an intelligent being without hesitation.” 🐦

> Alan Turing (1950): “If a machine can engage in a conversation with a human without being detected as a machine, it has demonstrated human intelligence.”

Now, let’s go into the fun part and explore the concept of current AI Agents.

# What is an AI Agent? 🤖
An AI Agent can be defined as an artificial entity that is capable of sensing its environment, making decisions, and executing actions. This concept brings us back to the fundamental idea of the robot’s sense-plan-act loop, which allows robots to interact with their environment. Following this definition, when we break down an AI Agent into its elemental components, we can fundamentally decompose it into three core elements: perception, brain, and action.

![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*8w9U4wagJt-2NPahHG7EaQ.png)
*Core components of an AI Agent: Perception, Brain, and Action.*

Recent advancements in multimodality and tool execution have notably enhanced both the perception and action components. Today our focus will be directed towards the brain component.

# LLM-based Agents 📈
In the diagram below, the brain within the agent is responsible for making decisions, planning, and reasoning, all while interacting with the storage of memory and knowledge. Current agents leverage LLMs for this, given their efficiency in handling reasoning and decision-making through emerging prompt engineering techniques like Chain of Thought (CoT) and ReAct (Reason and Act).

![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*iS7GHja76EWyqvP950Kxhg.png)
*Brain decomposition of an LLM-Based Agent*

However, despite their capabilities on these tasks, LLMs confront several challenges that make them unreliable for knowledge-intensive tasks. This is due to several factors, including:

1. Their disposition to generate factually incorrect information — often called hallucinations.
2. Limitations related to processing long context lengths effectively, without loosing important details in the middle.
3. The phenomenon of catastrophic forgetting, where the model forgets previously learned information as it learns new information.

As AI Agents start being implemented in real-life applications, there is a growing demand for them to be reliable and accurate agents. Hence, figuring out how to bridge the gap between the creative potential of LLMs and the reliable knowledge required in LLM-based agents remains a formidable challenge.

This post delves into the KG-RAG (Knowledge Graph-Retrieval Augmented Generation) framework, also known as Graph RAG, designed explicitly to confront some of the most persistent challenges encountered in LLMs. Preliminary experiments from this framework, demonstrate notable improvements in the reduction of hallucinated content and suggest a promising path toward developing intelligent systems adept at handling knowledge-intensive tasks.

# What can be done with KG-RAG? 🧠
KG-RAG enhances LLMs by integrating structured Knowledge Graphs (KGs) that store vast amounts of explicit, factual information. This integration reduces the reliance on the latent, often flawed knowledge of LLMs, enabling LLM-based agents with reliable storage of memory and knowledge to mitigate the generation of hallucinated content.

![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*STBiHaXLPHpRHvB8EuNp6w.png)
*Representation of how the brain integrates LLMs for dynamic reasoning and decision-making, alongside KGs for structured knowledge and memory storage.*

# What is a Knowledge Graph? 🤔

A Knowledge Graph (KG) is a method used to represent and store informational facts. It consists of nodes (or entities) and edges, which represent the relationships between these entities.

For example, in the knowledge graph shown, entities such as “Mona Lisa,” “Da Vinci,” and “Louvre” are connected by relationships like “painted,” “is in,” and “located in.” This visual framework not only helps to depict how different entities are related but also facilitates the retrieval of interconnected information efficiently.

![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*uttrGDDtlvCbAAo5OLMZBA.png)

*Knowledge graph visualization example*
A good advantage of using KGs is that they enable us to search for “things, not strings”. They store vast amounts of explicit facts in the form of precise, updatable, and interpretable knowledge triples, which can be represented as (entity)-[relationship]->(entity). Additionally, KGs can actively evolve with the continuous addition of knowledge.

Actually, KGs is what Google uses in Search to provide answers to your questions. As illustrated below, when a user queries “Who is the CEO of Entrepreneur First?” Google uses its Knowledge Graph to fetch and display relevant information. It identifies “Entrepreneur First” as an entity and navigates through the “CEO” relationship to arrive at Alice Bentick and shows how this connection was established in 2011 when she began her tenure as CEO. The KG’s ability to associate Alice Bentick with Entrepreneur First allows Google Search to present a concise and accurate answer to the query.

![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*q8DbVC28e5TkB5uN7BquZQ.png)

*Google search results for “Who is the CEO of Entrepreneur First?”*

Additionally, it provides more information that is connected through relationships to the target node (Alice Bentinck) on the right panel.

# Motivations behind KG-RAG 💪

The current baseline for the development of AI Agents is creating dense vector representations of chunks of text and retrieving them through a similarity search. This method works well for simple cases.

![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*6JbO2c4ZNuPVeoz0dlGHLA.png)

*Example of successful vector retrieval of documents*

This method allows AI to quickly find relevant documents based on text similarity, efficiently handling straightforward queries. However, as the volume of similar documents increases, challenges emerge in finding those chunks that contain the exact information needed.

![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*Pwi2yP3tgb2UhfG4nWzqvA.png)
*Representation of the scalability issues in vector embeddings based RAG*

These challenges motivate the implementation of structured KGs, enabling the navigation through massive amounts of information in a more efficient and accurate manner.

![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*kKwjmTxygk-TSWREunFkHw.png)

# KG-RAG Methodology 🎩

KG-RAG consists of three main stages:

1. **KG Construction**: Converts unstructured text into a structured KG. This step is crucial to maintain the quality of information and can affect later stages if it is not done correctly.
2. **Retrieval**: Carried out through a Chain of Explorations (CoE), a novel retrieval algorithm that employs LLM reasoning to explore nodes and relationships within the KG. It ensures that the retrieval process is both relevant and accurate leveraging the benefits of dense vector representations to locate relevant nodes and relationships within large KGs.
3. **Response Generation**: Generates coherent and contextually appropriate responses.

![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*hyT3JZcs7JuGf-DllMwH5A.png)
*Diagram illustrating the KG-RAG workflow*

# Preliminary Results 👀
Here is an example comparison of KG-RAG against the baseline vector RAG approach. This illustrates how KG-RAG effectively handles complex queries by exploring and reasoning through specific relationships to generate responses.

![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*EWGM-Btmbl0194oVHXpP2w.png)
*KG-RAG vs Dense Vector RAG vs no RAG on the ComplexWebQuestions dataset*

# The Future of Intelligent Agents 🔮
The integration of KGs and LLMs through frameworks like KG-RAG suggests a promising path toward developing intelligent systems capable of tackling knowledge-intensive tasks with high reliability. This approach mitigates some of the current limitations in LLM-based Agents and encourages further research and practical applications of this method. There is a significant opportunity to improve the current capabilities of KG Construction by developing curated high-quality datasets specifically tailored for this field.

KG-RAG holds promise as a potential solution to equip LLMs with external, updatable knowledge that is both reliable and efficient. Furthermore, with the continuous advancements in AI hardware accelerators, the reduction in response times (with KG-RAG and reasoning processes happening behind) will make the interactions with these agents feel more natural to humans.

# Bonus Analogy 💭
From a perspective of human cognition, the analogy of the “extended mind”, becomes particularly relevant. Just as humans extend their cognitive capabilities using tools such as smartphones and notebooks to offload memory and manage complex tasks, LLM-based agents can similarly benefit from external cognitive extensions to enhance their cognitive capacities.

# Closing Note 👋
This medium article is a very short summary of the KG-RAG research paper. If you found this post insightful, delving into the [full paper](https://arxiv.org/abs/2405.12035?source=post_page-----d03754bfb9c1--------------------------------) will provide a more comprehensive understanding of our findings and methodologies.

This post discusses the KG-RAG (Knowledge Graph-Retrieval Augmented Generation) framework or Graph RAG, which addresses common challenges in LLMs. Early experiments show it reduces hallucinated content and could aid in creating systems for knowledge-intensive tasks.

KG-RAG: Bridging the Gap Between Knowledge and Creativity of LLM-based Agents

Graph RAG has been revolutionizing the industry since its [joint introduction](https://www.nebula-graph.io/posts/graph-RAG) with NebulaGraph and LlamaIndex in August 2023, capitalizing on the momentum of LLM and RAG (Retrieval-augmented Generation). In this blog post, we will walk you through what Graph RAG is, why it is revolutionizing, and how to build your Graph RAG that draws on data context to answer complex, multi-part questions with NebulaGraph.

# Understanding Graph RAG and Its Rising Popularity

This cutting-edge technology has garnered widespread interest due to its capability to harness knowledge graphs alongside LLMs, thereby offering a more comprehensive contextual understanding for search engines. This results in more cost-efficient, intelligent, and precise search outcomes. Beyond providing more accurate responses to build user trust, this technology has surmounted the primary obstacles of traditional search augmentation techniques: the absence of context comprehension and data training. Consequently, these advanced retrieval enhancement techniques are poised to expand their reach into various industries, such as medical diagnosis assistance, content creation and recommendation, interactive gaming, and knowledge graph construction.

Microsoft underscored the importance of Graph RAG in the blog post [GraphRAG: Unlocking LLM Discovery on Narrative Private Data](https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/), authored by Jonathan Larson, Senior Principal Data Architect, and Steven Truitt, Principal Program Manager. They illustrated the effectiveness of Graph RAG by contrasting it with a baseline RAG system, concluding that the Graph RAG approach enables the LLM to anchor itself in the graph, resulting in a superior answer that includes provenance through original supporting text. Meanwhile, the baseline RAG struggles with queries that necessitate aggregation of information across the dataset to formulate an answer.

# Building Your Graph RAG with NebulaGraph

NebulaGraph database has integrated with LLM frameworks such as [LlamaIndex](https://www.llamaindex.ai/) and [LangChain](https://www.langchain.com/); you could simply focus on LLM orchestration logic and pipeline design without worrying about complex implementation. You could take a trial to check whether the Graph RAG performs as awesome as it is said with simply 4 steps before exploring further to integrate it into applications or other scenarios. 

***Note:*** 

*As LlamaIndex evolves rapidly, the recent refactor/break change has led to some of the Graph RAG tutorials becoming non-runnable. This blog is here for the updated tutorials of Graph RAG so that you can hands on it without errors.*

*We have been exploring so many in-house approaches before we upstream them later. We believe the basic concept of Graph + RAG in LlamaIndex is worth exploring, so we put the original workshop and notebooks in the reference chapter.*

## Set up your NebulaGraph cluster

You could start with any one of the three methods below to quickly set up a NebulaGraph cluster:

- start the NebulaGraph cluster via [NebulaGraph Lite](https://github.com/nebula-contrib/nebulagraph-lite) in Google Colab
- [deploy the cluster with Docker extension](https://www.nebula-graph.io/posts/nebulagraph-database-on-docker-desktop)
- instantiate a [NebulaGraphStore](https://docs.llamaindex.ai/en/stable/examples/index_structs/knowledge_graph/NebulaGraphKGIndexDemo/)

```
import os
from llama_index.core import KnowledgeGraphIndex, SimpleDirectoryReader
from llama_index.core import StorageContext
from llama_index.graph_stores.nebula import NebulaGraphStore

os.environ["NEBULA_USER"] = "root"
os.environ["NEBULA_PASSWORD"] = "nebula"
os.environ["NEBULA_ADDRESS"] = "127.0.0.1:9669"


space_name = "paul_graham_essay"
edge_types, rel_prop_names = ["relationship"], ["relationship"]  # default, could be omit if create from an empty kg
tags = ["entity"]  # default, could be omit if create from an empty kg

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

storage_context = StorageContext.from_defaults(graph_store=graph_store)
```

Now, with your NebulaGraph cluster set up, you could hands on the knowledge graph building section. **Please make sure to run all the steps below in the Jupyter environment.**

## Dependencies
The implementation of Graph RAG requires the below dependencies.

```
pip install llama-index
pip install llama-index-llms-ollama
pip install llama-index-graph-stores-nebula
pip install ipython-ngql
pip install llama-index-embeddings-huggingface
```

## Create a LlamaIndex Knowledge Graph Index

`KnowledgeGraphIndex` handles automated knowledge graph construction from unstructured text as well as entity-based querying. You need to set up a LlamaIndex Knowledge Graph Index Before creating a Graph RAG query engine. In this example, we 
will demonstrate how to build KG from textual data by creating a document object before moving on to create an index.

```
from llama_index.core import (
    VectorStoreIndex,
    SimpleDirectoryReader,
    KnowledgeGraphIndex,
)

graph_store.query("SHOW HOSTS")

Settings.chunk_size = 512

documents = SimpleDirectoryReader(
    "data"
).load_data()
```

```
kg_index = KnowledgeGraphIndex.from_documents(
    documents,
    storage_context=storage_context,
    max_triplets_per_chunk=10,
    space_name=space_name,
    edge_types=edge_types,
    rel_prop_names=rel_prop_names,
    tags=tags,
    max_knowledge_sequence=15,
)
```

## Create A Naive Graph RAG Retriever
The last step comes to creating a Graph RAG retriever, on top of which the query engine will be built so that you could query with natural language questions.

```
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.retrievers import KnowledgeGraphRAGRetriever

graph_rag_retriever = KnowledgeGraphRAGRetriever(
    storage_context=storage_context,
    verbose=True,
)

query_engine = RetrieverQueryEngine.from_args(
    graph_rag_retriever,
)
response = query_engine.query("What's the relationship between Bob and Alice")
```

Now, you’ve tried Graph RAG and if you’d like to explore more on how to retrieve via both GraphStore and VectorStore, you could find more demo examples here: [https://www.siwei.io/tutors/GraphRAG/101.html](https://www.siwei.io/tutors/GraphRAG/101.html).

Join our RAG discussion and let us know how your Graph RAG goes in our [Slack channel](https://join.slack.com/t/nebulagraph/shared_invite/zt-2h51ct4t0-IlXFaU01mpb3t2WgQ8qqNA).

Reference:

- [https://bit.ly/graph-rag-workshop](https://bit.ly/graph-rag-workshop)
- [https://siwei.io/graph-enabled-llama-index/kg_and_vector_RAG.html](https://siwei.io/graph-enabled-llama-index/kg_and_vector_RAG.html)
- [https://siwei.io/demo-dumps/graph-rag/GraphRAG.html](https://siwei.io/demo-dumps/graph-rag/GraphRAG.html)






This blog will walk you through what Graph RAG is, why it is revolutionizing, and how to build your Graph RAG that draws on data context to answer complex, multi-part questions with NebulaGraph.

Implementing Graph RAG with NebulaGraph

>*This article was written by Rajesh K, and originally published at [Medium](https://pub.towardsai.net/knowledge-graph-qa-using-gemini-and-nebulagraph-lite-2ca3a889f62c).*

Graph databases and knowledge graphs are among the most widely adopted solutions for managing data represented as graphs, consisting of nodes (entities) and edges (relationships). A graph database stores information using a graph-based data model, enabling querying and traversal of the graph structure through specialized graph query languages.

Knowledge graphs extend the capabilities of graph databases by incorporating mechanisms to infer and derive new knowledge from the existing graph data. This added expressiveness allows for more advanced data analysis and extraction of insights across the interconnected data points within the graph.

This article will delve into brief introduction on knowledge graphs followed by generation of knowledge graph using LlamaIndex and nebulagraph-lite.

# What is a Knowledge Graph?
A Knowledge Graph serves as a graphical portrayal of interconnected ideas, items, and their relationships, depicted as a network. It includes real-world entities like objects, people, places, and situations. At its core, a Knowledge Graph usually relies on a graph database, which is specifically crafted to manage data by storing discrete pieces of information and the connections between them.

The core components of KG are :

Entities are real-world items or concepts. These consist of humans, places, activities, and summary thoughts. In graph shape, that is a manner of visualizing relationships among information units, entities are represented as nodes or factors on a graph.

Examples:

- Person/s: Barack Obama, Serena Williams
- Places/Locations: New York City, The Great Pyramids
- Events/Events: World War II, 2008 economic crisis
- Abstraction/Ideology: Democracy, Gravity

Relationships describe relationships between objects and describe how they interact or interact with each other. Relationships are represented as edges connecting the corresponding nodes within the expertise graph. The route of this flow can be unidirectional or bidirectional, relying on the character of the entity courting.

# Categories of Knowledge Graphs

Knowledge graph has the ability to:

- **Effectively manipulate and visualize heterogeneous information**: This includes dealing with records of numerous systems inside a unified framework, facilitating clean and insightful illustration.
- **Integrate with newer data resources**: Knowledge graphs has the inherent flexibility to deal and incorporate facts from novel sources, fostering non-stop expansion of the know-how base.
- **Comprehend and depict relationships across any information store**: They can discover and represent the interconnections among entities dwelling within various information repositories, allowing a holistic understanding of the underlying relationships.

Following are the graph categories:

- **RDF (Resource Description Framework) Triple Stores**: These class focus on storing and dealing with information dependent according to the RDF framework, which utilizes triples (situation, predicate, object) to represent understanding.
- **Labeled Property Graphs**: This class makes a speciality of graphs in which nodes and edges are enriched with informative labels, presenting a more expressive and nuanced illustration of the facts.

# RDF (Resource Description Framework) Graphs
RDF graphs, standing for Resource Description Framework graphs, are a way to represent statistics of the web similar to network structure. They are essentially a collection of statements constructed around topics, predicates, and objects.

Imagine a sentence like “Paris is the capital of France”. In an RDF graph, “Paris” will be the issue, “is the capital of” would be the predicate, and “France” will be the item. Together, these three elements form a single “triple” that represents a fact. An RDF graph can incorporate many such triples, constructing an internet of interconnected records.

The Resource Description Framework (RDF) Triple Store constitutes a standardized facts version for know-how representation. Within this model, every element is assigned a unique identifier the use of Uniform Resource Identifiers (URIs). This mechanism ensures machine-readable identity of topics, predicates, and gadgets. Furthermore, RDF Triple Stores leverage a standardized question language known as SPARQL. This language allows the retrieval of records from the store. Owing to the standardized nature of both information representation and querying, RDF Triple Stores show off interoperability with another understanding graph that clings to the RDF framework.

![image](https://miro.medium.com/v2/resize:fit:720/format:webp/1*3FLR-xCZpg7yUDSxZvOTVw.png)

The graph above depicts individuals (round nodes) inside a social community. Lines (directed links) constitute friendships among them. Additionally, hasincome is related to every individual (dark-rimmed node). Diamond-fashioned nodes depict the opportunity of extra data current within the community (triples).

Pros of RDF graphs:

- **Interoperability**: RDF is a W3C trendy, which means that specific systems can apprehend and alternate records stored in RDF graphs. This makes it a great choice for sharing data throughout platforms and packages.
- **Standardization**: Due to the standardized format, RDF graphs include a trendy question language known as SPARQL. This makes it less difficult to discover and examine the records saved inside the graph.
- **Reasoning and Inference**: RDF graphs can leverage ontologies (think of them as formal descriptions of ideas) to purpose about the information. This allows the machine to infer new statistics that isn’t explicitly stated inside the graph.
- **Flexibility**: RDF graphs can represent an extensive form of facts types and relationships. This makes them appropriate for modeling complicated domains and integrating facts from exceptional sources.

Cons of RDF graphs:

- **Complexity for Deep Searches**: Traversing large RDF graphs for deep searches can be computationally expensive. This can gradual down queries that need to discover many connections.
- **Strict Structure**: RDF information is saved as &quot;triples&quot; (difficulty, predicate, object). This can be less flexible than different graph fashions that allow for properties on entities or relationships themselves.
- **Steeper Learning Curve**: Understanding and operating with RDF requires a good hold close of the underlying standards and the SPARQL question language. This can pose a challenge for new users.

# Labeled Property Graphs (LPGs)
Labeled property graphs (LPGs) are a special type of graph database model used to represent information with interconnected services and their relationships. Here is a breakdown of their highlights:

- **Nodes**: These represent masculine or feminine elements in realities. Each node has a very unique description and can be assigned one or more labels to indicate its type or size (e.g., “person”, “product”).
- **Properties**: Nodes can have key charge pairs associated with them, which store additional data about the entity. These fields allow for basic definitions of the elements in the graph.
- **Edges**: These represent connections between nodes, and show relationships between entities. Like nodes, edges can be marked with a selection of methods (e.g., “knows”, “buys”) and can also have their own properties associated with them.

Key characteristics of LPGs:

- **Rich data structure**: The ability to have properties on both nodes and edges allows for denser and more informative data representation compared to other models like RDF.
- **Efficient storage and querying**: The LPG structure often leads to efficient storage mechanisms and faster traversal of connections within the graph for queries.
- **Flexibility**: LPGs are flexible due to the lack of a predefined schema. This allows for modeling diverse data relationships.

# RDF vs. Property Graphs
![image](https://miro.medium.com/v2/resize:fit:720/format:webp/1*hFk11H42pSuOTsB8jVfeGQ.png)

# Property Graphs QA with LLM
Property graphs and Large Language Models (LLMs) are powerful tools that can be used together to gain new insights from data. Here’s how they can work together:

## Data Augmentation:

- LLMs can be used to generate text descriptions for nodes and edges in a property graph. This can enrich the data and make it easier for other tools or users to understand the relationships.
- LLMs can also be used to generate new nodes and edges based on existing data in the graph. This can be helpful for tasks like anomaly detection or fraud prediction.

## Querying and Exploration:

- LLMs can be used to create natural language interfaces for querying property graphs. This allows users to ask questions about the data in a more intuitive way than using a traditional graph query language.
- LLMs can also be used to summarize the results of graph queries and generate explanations for the findings.

Reasoning and Inference:

LLMs can be used to perform reasoning tasks over property graphs. This could involve inferring new relationships between nodes based on existing data or identifying inconsistencies in the graph.

![image](https://miro.medium.com/v2/resize:fit:640/format:webp/1*D3bN_RXwF-hmQ97qRYB9Pw.png)

Below is demonstration for the stepwise implementation of Knowledge Graph using [LlamaIndex](https://docs.llamaindex.ai/en/stable/) KnowledgeGraphIndex and [NebulaGraph Lite Reference](https://github.com/nebula-contrib/nebulagraph-lite) using Google Gemini LLM and Collab.

>Generate API Key for Gemini

Head on to https://aistudio.google.com/app/prompts/new_chat and generate a new API Key.

>Load the PDF document

```
! mkdir ad && cd ad
! curl https://arxiv.org/pdf/2106.07178.pdf --output AD1.pdf
! mv *.pdf ad/
```
```
! pip install -q transformers

%pip install llama_index pyvis Ipython langchain pypdf  llama-index-llms-huggingface  llama-index-embeddings-langchain llama-index-embeddings-huggingface
%pip install --upgrade --quiet llama-index-llms-gemini  google-generativeai
%pip install --upgrade --quiet llama-index-graph-stores-nebula nebulagraph-lite
```

>Import the google API key

```
import os

from google.colab import userdata
GOOGLE_API_KEY = userdata.get('GOOGLE_API_KEY')
os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
```

>Import the required modules and libraries

```
import logging
import sys

logging.basicConfig(stream=sys.stdout, level=logging.INFO)
logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout))
from llama_index.core import (
                         ServiceContext,
                         KnowledgeGraphIndex)
from llama_index.core import SimpleDirectoryReader
from llama_index.core.storage.storage_context import StorageContext
from pyvis.network import Network

from llama_index.llms.huggingface import HuggingFaceLLM
```
Check for supported gemini Models; here we will be using Gemini 1.0 pro model.

```
import google.generativeai as genai


for m in genai.list_models():
    if "generateContent" in m.supported_generation_methods:
        print(m.name)
        print(m)
```
```
from llama_index.llms.gemini import Gemini

llm = Gemini(model="models/gemini-1.0-pro-latest")
```
>Import the BGE embedding
```
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.core import ServiceContext


embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5")
```
>Load the contents of the ad directory
```
documents = SimpleDirectoryReader("/content/ad").load_data()
print(len(documents))
```

>Start the Nebula graph store lite version docker instance locally.

```
from nebulagraph_lite import nebulagraph_let
n = nebulagraph_let(debug=False)
n.start()
```

>Set up namepsace named “nebula_ad “ and nodes in nebula store

```
%ngql --address 127.0.0.1 --port 9669 --user root --password nebula
```
```
# If not, create it with the following commands from NebulaGraph's console:
%ngql CREATE SPACE nebula_ad(vid_type=FIXED_STRING(256), partition_num=1, replica_factor=1)
```
```
import time

print("Waiting...")

# Delay for 10 seconds
time.sleep(10)

%ngql --address 127.0.0.1 --port 9669 --user root --password nebula
%ngql USE nebula_ad;
%ngql CREATE TAG entity(name string);
%ngql CREATE EDGE relationship(relationship string);
```
>Load the document data to the graph store

```
import os
os.environ["NEBULA_USER"] = "root"
os.environ["NEBULA_PASSWORD"] = "nebula"  # default is "nebula"
os.environ[
    "NEBULA_ADDRESS"
] = "127.0.0.1:9669"  # assumed we have NebulaGraph installed locally

space_name = "nebula_ad"
edge_types, rel_prop_names = ["relationship"], [
    "relationship"
]  # default, could be omit if create from an empty kg
tags = ["entity"]  # default, could be omit if create from an empty kg
```
```
from llama_index.core import StorageContext
from llama_index.graph_stores.nebula import NebulaGraphStore

graph_store = NebulaGraphStore(
    space_name=space_name,
    edge_types=edge_types,
    rel_prop_names=rel_prop_names,
    tags=tags,
)
storage_context = StorageContext.from_defaults(graph_store=graph_store)
```
```
from llama_index.core import Settings

Settings.llm = llm
Settings.embed_model = embed_model
Settings.chunk_size = 512
```
>update the nodes data in graph store
```
# NOTE: can take a while!
index = KnowledgeGraphIndex.from_documents(
    documents,
    storage_context=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
)
```
>Check the inserted graph data in nebula store
```
# Query some random Relationships with Cypher
%ngql USE nebula_ad;
%ngql MATCH ()-[e]->() RETURN e LIMIT 10
```
>Output

![image](https://miro.medium.com/v2/resize:fit:640/format:webp/1*kyN7zp1yjDDEc5D9fzh32A.png)

>Now query the indexed data

```
query_engine = index.as_query_engine()
```
```
from IPython.display import display, Markdown

response = query_engine.query(
    "Tell me about Anomaly?",
)
display(Markdown(f"<b>{response}</b>"))
```
Anomalies, also known as outliers, exceptions, peculiarities, rarities, novelties, etc., in different application fields, refer to abnormal objects that are significantly different from the standard, normal, or expected.

```
from IPython.display import display, Markdown

response = query_engine.query(
    "What are graph anomolies?",
)
display(Markdown(f"<b>{response}</b>"))
```
Graph anomalies can be defined as structural anomalies.

# Conclusion
These simple Knowledge graphs demonstrably capture intricate relationships between entities. This capability facilitates significantly more precise, diverse, and complex querying and reasoning. These can also be extended to complex RDF-based ontology graphs. In the future, we will refine more on the different aspects of how Knowledge graphs can be utilized for RAG and LLM fine-tuning.

Happy Graphing!



This article delves into brief introduction on knowledge graphs followed by generation of knowledge graph using llamaindex and nebulagraph-lite.

Knowledge Graph QA Using Gemini and NebulaGraph Lite

This comprehensive blog is a written transcription of Louis Guitton's talk at a recent conference, where he shared his insights around knowledge on graph RAG and LLMs.

Graphs and Language

As you most probably know, a graph database is designed to store data as connections rather than tables. These connections are nodes or points on a graph, or lines depicting relationships between data points. 

Graph databases look like a network linking various pieces of data, revealing complex patterns and variations. Graph data can power a typical machine learning model by capturing and leveraging intricate relationships between data points. This creates the foundation for the use of graph databases in AI applications. 

According to research by [MarketsandMarkets](https://www.marketsandmarkets.com/Market-Reports/graph-database-market-126230231.html), the graph database market is expected to grow by 20.2% annually. This high growth is primarily propelled by the increasing demand among businesses to develop applications that are fueled by interconnected data . The most familiar example of such applications is a product recommendation engine, common across e-commerce sites. 

And now as we enter the era where more organizations are leveraging artificial intelligence to build applications, the significance of graph technology becomes even more pronounced. 

So it’s highly likely that you are on a quest to explore the utilization of graph databases in AI applications, and this guide is here to offer you precisely that solution. 

Let’s explore how businesses are using graph databases like NebulaGraph for AI applications.  

# Benefits of using graph databases in AI applications

Graph machine learning offers unprecedented data insights, which can add tremendous value to a business. 

These are the key benefits that organizations are gaining as a result of using graph databases to power AI applications: 

## Improving data analytics

Data scientists can use graph algorithms to reveal complex patterns hidden in datasets. Graph data is rich with connections and relationships, which give a clearer understanding of organizational information. 

This leads to better business operations, e.g., hyper-targeted marketing campaigns and streamlined manufacturing workflows. 

## Improving application speed and performance

Compared to traditional tabular databases, graphs offer training data that is more user-friendly for AI and ML algorithms. 

Graph technology can accelerate deep learning processes for businesses that have vast amounts of data. This means that real-time applications built on graph algorithms become more responsive.

Developers can build AI apps faster using graph technology, and end users can enjoy a seamless experience when they interact with these apps. 

## Improving AI accuracy 

Graph machine learning connects relevant data points, meaning that applications yield more precise responses to prompts and queries. 

Developers can build AI applications with graph analytics to increase transparency, so they can see the inner workings of the neural network. 

In addition, data scientists can study the nodes and relationships in the AI model. They can create a highly accurate AI mode when they are able to identify how the data is accessed and processed.  

# How do graph databases work with AI applications? 

Artificial intelligence (AI) applications use vast amounts of data to generate insights. These insights are the related data points or context that the AI model links together automatically. 

Using graph technology, data scientists give context to the neural networks that power applications. 

Here are the major ways that graph technology enhances AI. Please note that these approaches apply both when you are using a commercial graph database option or an [open source graph database](https://nebula-graph.io/): 

## Graph databases offer connected features which drive accuracy

Accuracy is everything in matters of data, and graph databases do a great job here. Connected features are the metrics that show the link between two data points or nodes in a graph database. 

Graph machine learning models become more accurate with more connections. These connected features are critical in artificial intelligence models that detect criminal behavior, such as online fraud. 

Criminals tend to hide their online activities to avoid detection, but their activities are all connected. Graph analytics enable data scientists to see patterns that they may otherwise miss without the help of a graph database. This enables law enforcement authorities to accurately predict and prevent fraud.  

## Graph databases provide context for efficiency

Most organizational data is stored in tables with rows and columns, e.g., a spreadsheet. Machine learning algorithms can use tabular data for training models, but this requires a lot of computing power and human intervention. This means that the algorithm training process becomes slow and expensive. 

Graph machine learning, however, makes AI training more efficient. Graphs store data as nodes and lines rather than tables and indexes. This allows data scientists to train models on already connected data, and this accelerates machine learning pipelines. 

## Graph databases provide a foundation for credibility

[AI hallucinations](https://zapier.com/blog/ai-hallucinations/) are a common problem, where a tool like ChatGPT may present incorrect information as fact. This usually happens because of insufficient data or low quality training data. 

Unfortunately, AI hallucinations can erode trust, making it more difficult for individuals and companies to rely on AI outputs. 

Graph technology is one way to overcome this problem. Since training data is represented as nodes and lines, data scientists can trace which elements the model uses to generate its responses. 

This is particularly important for predictive applications in industries such as finance or healthcare. AI applications in these industries need to be credible to avoid ethical problems.

## Graph databases provide context for decisions

This is possible specifically through knowledge graphs. But first, what is a knowledge graph? 

We define a knowledge graph as an interconnected dataset that has contextual meaning. To put it in a much simpler way, knowledge graphs are used to link relevant information together, just as a human would use past experience to make a choice. 

A knowledge graph uses underlying data to add meaning (context) to the end user's query. The graph algorithms essentially decide which data is relevant to the keyword. This enables users to find exactly what they're searching for in their data. 

An example is the [Thomson Reuters Knowledge Graph Feed](https://www.thomsonreuters.com/en/press-releases/2017/october/thomson-reuters-launches-first-of-its-kind-knowledge-graph-feed.html). It finds relationships between billions of data points to help customers make investment decisions. 

# Emerging fields where graph databases can power AI applications

Graph technology enables data scientists to see how neural networks function. They can build AI applications that are more accurate and transparent. 

Organizations can then use these applications to make faster and better decisions. The following are the major use cases that demonstrate how graph databases function in real-world applications. 

## Fraud detection

Data science plays a critical role in online fraud detection. [Fraud rings](https://www.securitymagazine.com/articles/97824-fraud-rings-detecting-and-defeating-cybercriminal-networks) cultivate different digital personas and false identities to trap unsuspecting victims. 

They then disappear after stealing identities or money, often without a trace. However, graph technology can effectively identify patterns from how fraudsters behave online. One fraud ring can have thousands of data points, e.g., fake social media profiles, online transactions, fraudulent addresses, etc. 

Since graph algorithms can run at a large scale, fraud detectors can use link prediction techniques to identify suspicious user patterns across numerous online platforms. Therefore, they can spot fraud rings and prevent incidents in real-time. 

## Product recommendations

Graph databases are commonly used in recommendation engines. These can be e-commerce websites, hotel booking sites, product comparison platforms, etc. Graph algorithms find links between customer purchases, product searches, and reviews. They also find similarities between different types of customers on an eCommerce platform. 

This interconnected data is what informs the product recommendations. This data powers features like "frequently bought together", "frequently viewed together", or "buy again". Combined, these features increase opportunities for upselling, cross-selling, and repeat sales. An example is [eBay's ShopBot](https://medium.com/@rjpittman/ebay-shopbot-beta-under-the-hood-bedf69157a70), which is linked to Google Assistant to improve customer search results. 

## Social networks

Graph technology plays a vital role in social networks in two main ways. First, it identifies how users are interconnected on the platform, e.g., who has the highest engagements and influence, suspended or inactive accounts, etc. 

Secondly, graph data can identify fake profiles or bots that skew user data. Bot accounts often inflate the active user numbers by automatically reposting or sharing content. However, graph algorithms can identify fake accounts by examining the complex patterns around their behavior. 

For example, a genuine, highly-engaging account and a bot account have different qualities or relationships with other users. A real account has higher two-way engagement than a bot account. The difference in engagement enables platforms to filter out the fake accounts. 


## Location services 

Applications that link to location services need to provide relevant information to users on demand. Examples of such information can be traffic and weather reports, live streaming content, or pest alerts for farmers. 

Location services are also used in marketing campaigns to target customers with content, depending on where they are. Location information is essentially the context behind these applications. 

Graph analytics can determine location connections through subscriber identity module (SIM) tracking and GPS sensors. 

## Regulatory compliance

From a data science perspective, regulatory compliance is a highly dynamic process. Companies accumulate sensitive user data from numerous endpoints, all of which must be protected by the highest privacy standards. 

For example, the General Data Protection Regulation (GDPR) compliance is difficult for businesses. [Over 1,000 businesses](https://www.consultancy.uk/news/31493/four-years-on-companies-still-struggle-with-gdpr-compliance) were fined for noncompliance in 2022. 

Unfortunately, personal data is usually spread out in many different repositories. It can be housed in data centers, on-premise servers, employee accounts, etc. 

With graph technology, your organization can easily connect all the places where sensitive data resides. These connections make it possible for compliance measures to apply across all the data. They also allow a business to delete all personal data if customers request it. 

Other areas of use include robotics, Internet of Things (IoT),Enterprise Content Management, Mobility, and Digital Asset Management. In robotics, for example, adaptive robotics require artificial intelligence and machine learning to process their environment. These machines use data to keep functioning when their surroundings change or if a component breaks down. An example is the Flexiv Rizon adaptive robot, an AI-powered robotic arm used in manufacturing industries. Graph databases are used to store the data that adaptive machines generate. These include object recognition data from sensors, or positioning data from global positioning system (GPS) integrations. They can also be used to simulate and predict the behavior of the robot.  

# Conclusion 

Graph databases uncover hidden patterns and connections that traditional databases may miss.

This rich structure enables AI applications to make more context-aware, accurate predictions. The result is improved user experiences, enhanced data understanding, and more effective decision-making across various industries.

In essence, graph databases empower AI to harness the power of interconnected data.

If your business is looking for more ways to leverage big data in AI applications, then you need to start incorporating graph databases as an essential pillar across your AI development ecosystem.[ Get started](https://docs.nebula-graph.io/3.6.0/#getting_started). 

Find out why graph databases hold the key to unlocking the full potential of AI applications. Uncover opportunities to make the most of your data and spur growth.

Graph Databases: The Hidden Key to Unlocking the Full Potential of AI Applications

With the rapid development of AI technology and advancements in natural language processing, building powerful large language models has become increasingly important for enterprises. Graph database software, as a robust tool for handling complex data structures, provides strong support for constructing domain-specific large language models.
 
NebulaGraph Database, an [open-source distributed graph database](https://www.nebula-graph.io/) built for super large-scale graphs with milliseconds of latency, released its Graph + AI big models solution. It pioneered the Text2Cypher technology for building and querying knowledge graphs based on natural language, offering users powerful capabilities in data management, semantic understanding, and information extraction. This solution enables enterprises to achieve higher-performance domain-specific large language model applications at lower costs, resulting in more intelligent and precise human-computer interactive question-answering results.
 

# NebulaGraph Database: Introducing the Graph + AI Solution
 
Graph database is a novel type of database that represents entities as nodes and relationships between entities as edges, allowing efficient storage, retrieval, and analysis of complex multidimensional data. Practice has shown that constructing knowledge graphs using graph technology enhances In-Context Learning, providing users with more contextual information and enabling large language models to better comprehend relationships between entities and enhance their expressive and reasoning abilities. As a graph database vendor to adopt LangChain, NebulaGraph Database has successfully implemented the Graph In-Context Learning solution based on a Knowledge Graph + Vector DB. Moreover, NebulaGraph Database is dedicated to introducing GraphStore storage context into the Llama Index, incorporating external storage of knowledge graphs and creating a more efficient and user-friendly Graph + LLM solution.
 
In terms of interaction, NebulaGraph Database has already implemented Text2Cypher based on the Graph + LLM solution. Users can easily build and query knowledge graphs through natural language in the dialogue interface. With out-of-the-box enterprise-level services, enterprise users can import massive data into NebulaGraph Database and quickly construct domain-specific knowledge graphs. Leveraging the powerful querying capabilities and performance of NebulaGraph Database, users can accomplish highly accurate searches and intuitive visualizations at a lower cost. Moreover, they can directly interact with the system through natural language for interactive questioning and querying, significantly reducing the barriers to enterprise adoption.
 
# NebulaGraph AI Large Models Solution: Industry Use Cases
 
In the era of information explosion, enterprises need to handle vast amounts of natural language text from different channels and types to obtain valuable information and insights. Large language models (LLMs) tailored to specific industry domains are capable of understanding, analyzing, and generating text information related to the industry.
 
However, traditional training methods suffer from high costs, low efficiency, and insufficient context information, making it challenging to effectively implement large language models in production environments. NebulaGraph Database, with its ability to handle massive, diverse, and complex data scenarios, provides a solution that addresses these issues.
 
## Healthcare Industry

In the healthcare industry, effective management and analysis of vast amounts of medical literature, clinical data, and patient records are essential. With the assistance of NebulaGraph Database's graph technology, enterprises can construct large language models specific to the healthcare domain. By constructing a medical knowledge graph that models medical entities (such as diseases, drugs, treatment methods) and their relationships, large language models can acquire extensive medical knowledge.
 
Using NebulaGraph Database helps accurately link entities mentioned in medical texts to the knowledge graph, eliminating ambiguities and improving model accuracy. Large language models in the healthcare industry can be applied to intelligent diagnosis, disease prediction, and personalized healthcare recommendations, providing more precise and intelligent solutions.
 
## Financial Industry

In the financial sector, in-depth analysis and prediction of complex financial data are required. NebulaGraph Database can assist in building a knowledge graph specific to the financial domain, modeling financial entities (such as stocks, transactions, financial indicators) and their relationships. Language models built on top of NebulaGraph Database can acquire professional knowledge in the financial domain and play a vital role in financial data analysis, investment decision-making, and more.
 
Furthermore, using NebulaGraph's graph technology for relationship extraction and semantic understanding can help extract key information from financial news and research reports, aiding large language models in better understanding the dynamics and trends of the financial market. Large language models in the financial domain can be applied to investment analysis, risk management and intelligent customer service, and users can receive precise answers through natural language, providing more intelligent and efficient services for financial users.
 
## E-commerce retail industry

In the retail industry, businesses often need to deal with a large amount of product information, user reviews, sales data, and more. NebulaGraph Database can help build a knowledge graph for the retail industry, modeling entities such as products, brands, users, and their relationships. Domain-specific large language models in the retail sector can be applied to intelligent product recommendations, customer segmentation, market trend analysis, and more, providing a more intelligent and personalized shopping experience for retail companies.
 
At the same time, NebulaGraph Database's Graph + AI Large Models solution can also play a role in areas such as product recommendations and user-personalized services by leveraging professional knowledge in the retail industry. Entity linking and relationship extraction using graph technology can extract useful information from user reviews, helping the large language models better understand user demands and offer personalized shopping preferences. Users can receive targeted services using natural language, greatly enhancing the user experience.
 
# Future Outlook: Building more intelligent AI large model applications
 
With the continuous development of big data and artificial intelligence technology, the deep integration of graph technology and language models will become a future trend. NebulaGraph Database not only provides a richer knowledge base and semantic understanding capability to language models, helping them better understand industry knowledge and semantics, but also enables more efficient, flexible, and intelligent processing of massive complex relational data.
 
In the future, AI large models will be further developed in various industry domains, and NebulaGraph Database will continue to advance and improve its technological advantages, helping businesses better understand industry data, gain insights into market trends, optimize business decisions, and bring more opportunities and momentum for innovation and development.


This article demonstrates how the NebulaGraph database offers robust support for building domain-specific large language models.

NebulaGraph x LLM：Pioneering the New Paradigm of "Graph + AI" Applications

# LLM App Paradigms

As a big improvement in Cognitive intelligence, LLM had changed many industries, in a way that we didn’t expect to automate, accelerate or enable. Seeing new LLM-enabled applications being created every day, we are all still exploring new methods and use cases for leveraging this magic.

One of the most typical patterns to bring LLM into the loop is to ask LLM to understand things based on proprietory/ certain domain knowledge. For now, there are two paradigms we could add that knowledge to LLM: **fine-tuning and in-context learning**.

Fine-tuning refers to performing add-on training on large language model models with extra knowledge, whereas in-context learning is to adding some extra piece of knowledge to the query prompt. What we observe now is that in-context learning has gained popularity over Fine-tuning due to its simplicity.

And in this blog, I’ll share what we had been doing around the in-context learning approach.

# Llama Index: Interface between data and LLM

## In-context learning

The basic idea of in-context learning is to use existing large language model(not updated) to handle special tasks toward specific knowledge datasets.

For instance, to build an application to answer any questions about one person, or even act as one’s digital avatar, we can apply in-context learning to an autobiography book with LLM. In practice, the application will construct a prompt with the question from the user and some information “searched” from the book, then query the LLM for an answer.

```
┌───────┐         ┌─────────────────┐         ┌─────────┐
│       │         │ Docs/Knowledge  │         │         │
│       │         └─────────────────┘         │         │
│ User  │─────────────────────────────────────▶   LLM   │
│       │                                     │         │
│       │                                     │         │
└───────┘                                     └─────────┘
```

One of the most performant ways to enable this searching approach to get the related info from the Docs/Knowledge(the book in the above example) for the special task, is to leverage Embeddings.

## Embedding

The LLM embedding normally refers to a way to map real word things into a vector in a multidimensional space, for instance, we could map images into a space of (64 x 64) dimension, and if we are doing it well enough, the distance between the two images can reflect the similarity of them.

Another example of embedding is the word2vec algorithm, which literally maps every word into a vector, for instance, and if the embedding is good enough, we could have addition and subtraction on them, we may have:

* `vec(apple) + vec(pie) =~ vec("apple apie")`
Or the vector measure of `vec(apple) + vec(pie) - vec("apple apie") `tends to be 0:
*` |vec(apple) + vec(pie) - vec("apple apie")| =~ 0`
Similarly, we could have “pear” should be closer than “dinosaur” to “apple”:
* `|vec(apple) - vec(pear)| < |vec(apple) - vec(dinosaur)|`
With that, we could in theory search for pieces of the book which are more related to a given question. And the basic process is:
* Split the book into small pieces, create the embedding per each piece, and store them
* When a question comes, compute the embedding of the question
Find top-K similar embeddings of pieces of the book by calculating the distance
* Construct the prompt with both the question and the pieces of the book
* Query the LLM with the prompt

```
                  ┌────┬────┬────┬────┐                  
                  │ 1  │ 2  │ 3  │ 4  │                  
                  ├────┴────┴────┴────┤                  
                  │  Docs/Knowledge   │                  
┌───────┐         │        ...        │       ┌─────────┐
│       │         ├────┬────┬────┬────┤       │         │
│       │         │ 95 │ 96 │    │    │       │         │
│       │         └────┴────┴────┴────┘       │         │
│ User  │─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─▶   LLM   │
│       │                                     │         │
│       │                                     │         │
└───────┘    ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐  └─────────┘
    │          ┌──────────────────────────┐        ▲     
    └────────┼▶│  Tell me ....., please   │├───────┘     
               └──────────────────────────┘              
             │ ┌────┐ ┌────┐               │             
               │ 3  │ │ 96 │                             
             │ └────┘ └────┘               │             
              ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ 
```

## Llama Index

Llama Index is such an open-source toolkit to help in-context learning in best practice:

* It comes with [a bunch of data loaders](https://llamahub.ai/) to serialize docs/knowledge in a unified format, think of PDF, Wikipedia Page, notion, Twitter, etc, and we don’t have to deal with the preprocessing, split the data into pieces, etc, on our own.
* It helps create the Embedding(and some other form of the index) for us and stores the embeddings(in memory or [vector databases](https://github.com/openai/openai-cookbook/blob/main/examples/vector_databases/Using_vector_databases_for_embeddings_search.ipynb)), too, with one line of code.
* It comes out of the box with prompts and other engineering points, so that we don’t have to create and study from scratch, for instance, [create a chatbot on existing data with 4 lines of code](https://twitter.com/jerryjliu0/status/1663213212932902913).


# The problem of doc split and embeddings

The embedding and vector search worked well in many cases, while there are still challenges in some cases, and one of them is it could lose global context/cross-node context.

Think of we are asking “Please tell me things about the author and foo.”, and in this book, the piece with numbers: 1, 3, 6, 19~25, 30~44, and 96~99 are all about the topic of foo. In this case, the simple way of searching top-k embedding of the pieces of the book may not work well because we normally only take a few top-related pieces, which loses many contexts.

```
┌────┬────┬────┬────┐
│ 1  │ 2  │ 3  │ 4  │
├────┴────┴────┴────┤
│  Docs/Knowledge   │
│        ...        │
├────┬────┬────┬────┤
│ 95 │ 96 │    │    │
└────┴────┴────┴────┘

```

The mitigation for that, for instance with Llama Index is to create [composite indices](https://gpt-index.readthedocs.io/en/latest/how_to/index_structs/composability.html), where the VectorStore is only part of it, combining with that, we could define a summary index and/or a tree index, etc to [route different types of questions to different indices](https://gpt-index.readthedocs.io/en/latest/guides/tutorials/unified_query.html), thus to avoid risking the loss of global context when the question required it.

Or, with the help of Knowledge Graph, we could do something differently.

# Knowledge Graph

The term Knowledge Graph was initially coined by Google in May 2012 as part of its efforts to enhance search results and provide more contextual information to users. The Knowledge Graph was designed to understand the relationships between entities and provide direct answers to queries rather than just returning a list of relevant web pages.

A knowledge graph is a way of organizing and connecting information in a graph format, where nodes represent entities, and edges represent the relationships between those entities. The graph structure allows for efficient storage, retrieval, and analysis of data.

It looks like this:

![knowledge graph](https://www-cdn.nebula-graph.io/nebula-website-5.0/images/blogs/llm/llm04.png)

But how could Knowledge Graph help?

# Combination of LLM embeddings and Knowledge Graph

The general idea here is a knowledge graph, as the refined format of the information, can be queried/searched in way smaller granularity than the split we could do on raw data/docs. Thus, by not replacing the large pieces of the data, but combining the two, we can search queries that require global/cross-node context better.

See the following diagram, assume the question is about x, and 20 of all the pieces of the data are highly related to it. We could now still get the top 3 pieces of the doc(say, no. 1, 2, and 96) as the main context to be sent, apart from that, we ask for two hops of graph traversal around x from the knowledge graph, then the full context will be:

* The question “Tell me things about the author and `x`
* Raw doc from piece number 1, 2, and 96, in Llama Index, it’s called node 1, node 2, and node 96.
* Knowledge 10 triplets contain `x` in two-depths graph traversal:
* x -> y(from node 1)
* x -> a(from node 2)
* x -> m(from **node 4**)
* x <- b-> c(from **node 95**)
* x -> d(from node 96)
* n -> x(from **node 98**)
* x <- z <- i(from node **1 and node 3**)
* x <- z <- b(from node **1 and node 95**)

```
┌──────────────────┬──────────────────┬──────────────────┬──────────────────┐
│ .─.       .─.    │  .─.       .─.   │            .─.   │  .─.       .─.   │
│( x )─────▶ y )   │ ( x )─────▶ a )  │           ( j )  │ ( m )◀────( x )  │
│ `▲'       `─'    │  `─'       `─'   │            `─'   │  `─'       `─'   │
│  │     1         │        2         │        3    │    │        4         │
│ .─.              │                  │            .▼.   │                  │
│( z )─────────────┼──────────────────┼──────────▶( i )─┐│                  │
│ `◀────┐          │                  │            `─'  ││                  │
├───────┼──────────┴──────────────────┴─────────────────┼┴──────────────────┤
│       │                      Docs/Knowledge           │                   │
│       │                            ...                │                   │
│       │                                               │                   │
├───────┼──────────┬──────────────────┬─────────────────┼┬──────────────────┤
│  .─.  └──────.   │  .─.             │                 ││  .─.             │
│ ( x ◀─────( b )  │ ( x )            │                 └┼▶( n )            │
│  `─'       `─'   │  `─'             │                  │  `─'             │
│        95   │    │   │    96        │                  │   │    98        │
│            .▼.   │  .▼.             │                  │   ▼              │
│           ( c )  │ ( d )            │                  │  .─.             │
│            `─'   │  `─'             │                  │ ( x )            │
└──────────────────┴──────────────────┴──────────────────┴──`─'─────────────┘
```


And clearly, the refined information related to topic `x` that comes from both other nodes and across the nodes is included in the context to build the prompt of in-context learning.

# Progress of Knowledge Graph in Llama Index

The Knowledge Graph abstraction was initially introduced to Llama Index by [William F.H](https://github.com/jerryjliu/llama_index/pull/433). where the triplets in the knowledge graph were associated with the docs with keywords and stored in memory, then [Logan Markewich](https://github.com/jerryjliu/llama_index/pull/487) enhanced it by adding embedding per triplets, too.

Recently, in the last couple of weeks, I had been [working with the community](https://github.com/jerryjliu/llama_index/issues/1318) on bringing the “GraphStore” storage context to Llama Index and thus introducing external storage of Knowledge Graph, the first implementation is [NebulaGraph the Open-Source Distributed Graph Database](https://www.nebula-graph.io/) that I had been working on since 2021.

During the implementation of this, the option to traverse multiple hops of the graph, and the option to collect more key entities on top-k nodes(to search in the knowledge graph to enable more global context) was introduced, and we are still refining the changes.

With GraphStore introduced, it also makes it possible to perform in-context learning from an existing knowledge graph, combined with other indices, this is also quite promising due to the knowledge graph being considered with high Information density than other structured data.

# About NebulaGraph Database

As a high-performance native distributed graph database, NebulaGraph Database excels in handling mega data sets with hundreds of billions of nodes and trillions of edges, while maintaining millisecond query latency. Relying on its shared-nothing, distributed architecture and computation-and-storage separation, it is highly available, highly secure, and easy to scale out, largely meeting the security requirements of enterprises. Besides, it can be deployed on the public cloud and on-premises as needed.

# Talk to a Graph Database Expert

Get a customized solution for your organization and see how NebulaGraph can help you:

[Contact NebulaGraph](https://www.nebula-graph.io/contact)


NebulaGraph database helps industry-level large language model Applications by bringing the “GraphStore” storage context to Llama Index.

Graph + LLM｜How NebulaGraph database helps industry-level large language model Applications

The growth of e-commerce has led to an overwhelming number of choices for consumers, making it increasingly challenging for online retailers to showcase relevant products and services in order to maintain customer loyalty and retain customers.

One of the most effective solutions to this problem is the use of recommendation engines. 
It has emerged as a key technology to bridge the gap, providing personalized suggestions that improve customer satisfaction and increase sales by analyzing the user’s previous behavior. [Graph databases](https://www.nebula-graph.io) are particularly well-suited for recommendation engines as they can handle large amounts of interconnected data with ease. In this article, we will explore how recommendation engines work in e-commerce, their different types, and the advantages of using graph databases like NebulaGraph for building powerful recommendation systems.

# What is a Recommendation Engine?

A recommendation engine is an algorithmic system that analyzes data on user behavior, preferences, and historical interactions with a product or service, to make personalized recommendations on content, products, or services that a user is likely to enjoy or find relevant.
Recommendation engines are commonly used by companies that offer personalized content or services, such as online retailers, music or video streaming platforms, and social media sites. By using data on a user's past behavior and preferences, a recommendation engine can make accurate predictions on what the user might be interested in, and present them with personalized recommendations.
Recommendation engines play a crucial role in the customer journey, helping businesses improve user experience, increase sales, and retain customers.

# Types of Recommendation Engines for Ecommerce

There are several types of recommendation engines, each with their own approach to providing personalized recommendations. The three most common types of recommendation engines are:

1. **Collaborative filtering**: Collaborative filtering is a technique that recommends items based on the behavior of similar users. This approach analyzes user behavior data such as purchases, ratings, and viewing history, to find similarities between users and recommend items that users with similar behavior patterns have enjoyed. Collaborative filtering can be further divided into two categories: user-based and item-based filtering.
2. **Content-based filtering**: Content-based filtering recommends items based on the user's past behavior and preferences. This approach uses data about the user's past behavior, such as their viewing history or search queries, to recommend items that are similar in content or characteristics to the user's past interactions. For example, if a user has watched a lot of action movies, a content-based recommendation engine might recommend other action movies.
3. **Hybrid filtering**: Hybrid filtering combines both collaborative and content-based filtering to make recommendations. This approach can provide more accurate recommendations by taking into account both the user's past behavior and preferences as well as the behavior of similar users.

Other types of recommendation engines include knowledge-based filtering, which recommends items based on a user's explicitly stated preferences, and context-aware filtering, which takes into account additional data such as the user's location or time of day to make recommendations.

And when it comes to recommendation engines used in e-commerce, common types are:

- **Personalized Recommendations**: These engines provide individualized suggestions based on a user's behavior, preferences, and history.
- **Popular Items**: These recommend the most popular items within a specific category, time frame, or location.
- **Similar Items**: These engines suggest items that are similar to a specific item, based on their features or user behavior.
- **Complementary Items**: Also known as cross-selling recommendations, these engines suggest items that complement a specific item, such as accessories or related products.

# Why Graph Databases Are Well-suited for Recommendation Engines

Graph databases excel in modeling complex relationships between data entities, making them an ideal choice for recommendation engines. Some key advantages of graph databases for recommendation engines include:

- Relationship-centric data modeling: Graph databases represent data as nodes and edges, making it easy to model relationships between users, products, and other relevant data points.
- High query performance: Graph databases provide fast and efficient query execution, enabling [real-time recommendations](https://www.nebula-graph.io/posts/use-cases-of-graph-databases-in-real-time-recommendation).
- Flexibility and schema evolution: Graph databases allow for schema changes without affecting existing data or queries, making it easy to incorporate new data sources and recommendation algorithms.
- Advanced analytics capabilities: Graph databases support advanced analytics, such as community detection and centrality measures, that can improve the accuracy and relevance of recommendations.

# NebulaGraph: A Recommended Solution for E-commerce Recommendation Engines

NebulaGraph is an open-source, distributed graph database that offers high performance, scalability, and ease of use. It is an excellent choice for building recommendation systems for e-commerce because of the following features:

- Efficient querying: NebulaGraph supports a flexible, SQL-like query language called nGQL, allowing for efficient querying and traversing of complex relationships between data entities.
- High scalability: NebulaGraph can handle large-scale graphs and store billions of nodes and edges with low latency, making it ideal for e-commerce platforms with massive amounts of user and item data.
- Data consistency: NebulaGraph ensures strong data consistency through the Raft consensus algorithm, which guarantees that updates are consistently applied across all replicas.
- Easy integration: NebulaGraph provides comprehensive APIs and connectors for popular programming languages, making it simple to integrate with e-commerce platforms and other data processing tools.

# Designing a Recommendation Engine with NebulaGraph Database

Building a recommendation engine with [NebulaGraph](https://nebula-graph.io) involves several steps, including:

1. Data modeling and schema design: Model users, products, and other relevant data points as nodes and their relationships as edges.
2. Importing and processing e-commerce data: Collect data on user behavior, preferences, and product information, and store it in NebulaGraph.
3. Implementing recommendation algorithms using NebulaGraph's query language (nGQL): Develop queries to identify patterns and relationships between users and items and generate personalized recommendations.
4. Testing and validating recommendations: Ensure that the generated recommendations are relevant and accurate by comparing them with actual user behavior and feedback.
5. Integrating the recommendation engine with the e-commerce platform: Use NebulaGraph's APIs and connectors to seamlessly integrate the recommendation engine with the existing e-commerce system, enabling real-time recommendations for users.
6. Continuously updating and refining the recommendation engine: Regularly update the data in NebulaGraph and fine-tune the recommendation algorithms to keep the recommendations fresh and relevant.

# Conclusion

Recommendation engines are essential for e-commerce platforms to provide personalized experiences and improve customer satisfaction. Graph databases, with their ability to model complex relationships and offer high query performance, are well-suited for building such engines. NebulaGraph, an open-source, distributed graph database, is a recommended solution for e-commerce recommendation engines due to its scalability, efficiency, and ease of use. By implementing a recommendation engine with NebulaGraph, e-commerce businesses can significantly enhance their user experience, increase sales, and retain customers in the competitive online marketplace.

# How NebulaGraph Works
1. [NebulaGraph Architecture — A Bird’s Eye View](https://www.nebula-graph.io/posts/nebula-graph-architecture-overview)
2. [Benchmark: NebulaGraph vs Dgraph vs JanusGraph](https://www.nebula-graph.io/posts/benchmarking-mainstraim-graph-databases-dgraph-nebula-graph-janusgraph)
3. [Comparison: Neo4j vs NebulaGraph vs JanusGraph](https://www.nebula-graph.io/posts/performance-comparison-neo4j-janusgraph-nebula-graph)
4. [Deploy the Graph Database on Kubernetes](https://www.nebula-graph.io/posts/how-to-deploy-nebula-graph-in-kubernetes)
5. [Graph Database For Recommendation Systems](https://www.nebula-graph.io/posts/use-cases-of-graph-databases-in-real-time-recommendation)


Recommendation engines are essential for e-commerce platforms to provide personalized experiences and improve customer satisfaction. Graph databases, with their ability to model complex relationships and offer high query performance, are well-suited for building such engines. 

How Recommendation Engine for Ecommerce Works Using Graph Database

Graph databases have been the fastest growing database category since 2013.

Graph Database Market Overview

A graph database is a specialized type of NoSQL database that stores the connections between entities (nodes) and the relations associated with them (edges).

Tag