Triplex: The Innovative, Cost-Effective Alternative to Microsoft’s Graph Rag

Innovation is the driving force behind progress in the technology industry. Today, we will explore an innovative model called Triplex, which offers a more cost-effective alternative to Microsoft’s Graph Rag for constructing knowledge graphs. This article will delve into how the Triplex model works, its advantages over Graph Rag, and how to implement it in practical applications.

Overview of the Sciphi Triplex Model

The Sciphi Triplex model, or simply Triplex, is an open-source large language model focused on extracting knowledge graphs from unstructured data. Its name comes from its ability to extract entities, relationships, and entity types from text. The model is fine-tuned on a 5.38 billion parameter language model to create high-quality knowledge graphs.

GitHub: https://github.com/NEXGEM/TRIPLEX

Advantages of Triplex Over Microsoft’s Graph Rag

Cost and Performance

One of the most significant advantages of Triplex is its cost-effectiveness. Using Triplex costs only one-tenth of what it would to use Microsoft’s Graph Rag, yet its performance is comparable to the powerful GPT-4 model and even more efficient in certain aspects. While Graph Rag is undeniably powerful, it consumes significant computational resources and has a higher cost of use. In contrast, Triplex achieves its impressive performance through optimized algorithms and architectural design, providing a high-value solution.

Flexibility and Ease of Use

Another key strength of the Triplex model is its flexibility. It supports a wide range of complex application scenarios, and users can immediately utilize the R2R Rag engine and Neo4J for data visualization. In comparison, when using Graph Rag, users must first convert their data into a Neo4J-compatible format, adding an extra layer of operational complexity. Triplex streamlines the process, offering greater ease of use and adaptability to various use cases.

Accuracy and Accessibility

In terms of accuracy, the Triplex model has demonstrated superior performance to GPT-4 in knowledge graph extraction tasks. It leverages the open-source Triplex large language model and can be run through popular frameworks like HuggingFace and Ollama. Moreover, users have the option to run Ollama on their local computers for free, significantly lowering the barrier to entry and making the technology more accessible to a broader range of users.

Step-by-Step Implementation Guide

Now that we’ve covered the key advantages of the Triplex model, let’s walk through the process of using it to extract knowledge graphs from text and store them in a database for visualization.

1. Understanding Basic Concepts

Before diving into the implementation, it’s important to grasp the fundamental concepts at play. Knowledge graph construction (Graph Rag) is distinct from basic retrieval-augmented generation (Basic Rag). While Basic Rag converts data into embeddings and stores them in a vector database, Graph Rag focuses on extracting entities and relationships from the provided data and storing them in a dedicated knowledge graph database.

2. Setting Up the Environment

To get started, you’ll need to install a few essential libraries. Open your terminal and run the following command:

pip install transformers torch

This will install the necessary dependencies, namely the Transformers library and PyTorch.

3. Implementing the Triplex Model

With the environment set up, you can now create a Python file (e.g., app.py) and implement the Triplex model. Here’s an example of what your code might look like:

import json
from transformers import AutoModelForCausalLM, AutoTokenizer

def triple_extract(model, tokenizer, text, entities, predicates):
    prompt = f"{text} [{entities}] [{predicates}]"
    tokens = tokenizer.encode(prompt, return_tensors='pt')
    output = model.generate(tokens)
    response = tokenizer.decode(output[0], skip_special_tokens=True)
    return response

model_name = "sci-fi-trix"
model = AutoModelForCausalLM.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

text = "Elon Musk is the founder of SpaceX"
entities = "Person, Organization"
predicates = "founded by"

response = triple_extract(model, tokenizer, text, entities, predicates)
print(response)

In this code snippet, we define a triple_extract function that takes the Triplex model, a tokenizer, the input text, target entities, and predicates as parameters. It then constructs a prompt, encodes it using the tokenizer, generates the output using the model, and decodes the response.

We load the pre-trained “sci-fi-trix” model and its associated tokenizer using the AutoModelForCausalLM and AutoTokenizer classes from the Transformers library. Finally, we provide an example input text, specify the target entities and predicates, and call the triple_extract function to obtain the extracted knowledge graph triples.

4. Running the Triplex Model

To run the Triplex model, simply execute the Python script from your terminal:

python app.py

The script will load the pre-trained model, process the input text, and print the extracted knowledge graph triples.

Simplified Workflow with OLama

While the above implementation provides a detailed look at the process, you can streamline the workflow even further by leveraging the OLama library. Here’s how you can use OLama to extract knowledge graphs with just a few simple steps:

1. Install OLama by running the following command in your terminal:

   pip install ollama

2. Run the Sci-Fi XX model using OLama:

   ollama run sciphi/triplex

3. Input the same text and entity types as in the previous example, and the model will return the extracted entities and triples.

By using OLama, you can significantly simplify the process of running the Triplex model and extracting knowledge graphs from text.

Streamlining Knowledge Graph Construction with R2R

To further streamline the entire knowledge graph construction process, you can utilize the R2R tool provided by the company behind Sciphi. R2R is designed to help users build, scale, and manage user-facing RAG applications with ease. Here’s a step-by-step guide on how to use R2R:

1. Installing R2R

First, install R2R by running the following command in your terminal:

pip install r2r

2. Configuring R2R

Next, create a configuration file named local_neo4j_kg.yaml and add the following content:

model_name: sci-fi-trix
providers:
  neo4j:
    uri: bolt://localhost:7687
    user: neo4j
    password: your_password

This configuration file specifies the model name and the connection details for your Neo4J database.

3. Running R2R

With the configuration file in place, you can now run R2R using the following command:

r2r serve docker --config local_neo4j_kg.yaml

This command starts R2R and sets up the necessary infrastructure to serve your knowledge graph application.

4. Importing Data

To import data into your knowledge graph, create a text file named data.txt with the following content:

John is a person that works at Google. Paul is a person that works at Microsoft that collaborates with John.

Then, run the following command to ingest the data into your knowledge graph:

r2r ingest files data.txt

R2R will process the input text and populate your Neo4J database with the extracted entities and relationships.

5. Inspecting the Knowledge Graph

To inspect the constructed knowledge graph, run the following command:

r2r inspect knowledge_graph

This command will provide you with an overview of the entities and relationships stored in your knowledge graph.

6. Visualizing the Knowledge Graph

Finally, you can visualize your knowledge graph by accessing the Neo4J interface. Open the Neo4J URL in your web browser, enter your username and password, and explore the relationships between entities in an interactive graph representation.

Conclusion

The Triplex model offers a powerful and cost-effective solution for constructing high-quality knowledge graphs from unstructured text data. By leveraging optimized algorithms and architectural design, Triplex achieves performance comparable to state-of-the-art models like GPT-4 while significantly reducing the cost of use.

Whether you choose to implement Triplex using the Transformers library, simplify the process with OLama, or streamline the entire workflow with R2R, you can harness the potential of this innovative model to extract valuable insights from your text data and build comprehensive knowledge graphs.

As you embark on your knowledge graph construction journey, remember to experiment with different approaches, fine-tune your models to your specific domain, and continuously iterate based on the insights you uncover. With the right tools and techniques, you can unlock the full potential of your text data and drive meaningful progress in your field.