GitHub - matzls/LightRAG: "LightRAG: Simple and Fast Retrieval-Augmented Generation"

🚀 LightRAG: Simple and Fast Retrieval-Augmented Generation

🎉 News

Algorithm Flowchart

Figure 1: LightRAG Indexing Flowchart - Img Caption : SourceFigure 2: LightRAG Retrieval and Querying Flowchart - Img Caption : Source

Installation

Install LightRAG Core

Install from source (Recommend)

cd LightRAG
pip install -e .

Install from PyPI

pip install lightrag-hku

Install LightRAG Server

The LightRAG Server is designed to provide Web UI and API support. The Web UI facilitates document indexing, knowledge graph exploration, and a simple RAG query interface. LightRAG Server also provide an Ollama compatible interfaces, aiming to emulate LightRAG as an Ollama chat model. This allows AI chat bot, such as Open WebUI, to access LightRAG easily.

Install from PyPI

pip install "lightrag-hku[api]"

Installation from Source

# create a Python virtual enviroment if neccesary# Install in editable mode with API support
pip install -e ".[api]"

For more information about LightRAG Server, please refer to LightRAG Server.

Quick Start

Video demo of running LightRAG locally.
All the code can be found in the examples.
Set OpenAI API key in environment if using OpenAI models: export OPENAI_API_KEY="sk-...".
Download the demo text "A Christmas Carol by Charles Dickens":

curl https://raw.githubusercontent.com/gusye1234/nano-graphrag/main/tests/mock_data.txt > ./book.txt

Query

Use the below Python snippet (in a script) to initialize LightRAG and perform queries:

importosimportasynciofromlightragimportLightRAG, QueryParamfromlightrag.llm.openaiimportgpt_4o_mini_complete, gpt_4o_complete, openai_embedfromlightrag.kg.shared_storageimportinitialize_pipeline_statusfromlightrag.utilsimportsetup_loggersetup_logger("lightrag", level="INFO")
asyncdefinitialize_rag():
rag=LightRAG(
working_dir="your/path",
embedding_func=openai_embed,
llm_model_func=gpt_4o_mini_complete
)
awaitrag.initialize_storages()
awaitinitialize_pipeline_status()
returnragdefmain():
# Initialize RAG instancerag=asyncio.run(initialize_rag())
# Insert textrag.insert("Your text")
# Perform naive searchmode="naive"# Perform local searchmode="local"# Perform global searchmode="global"# Perform hybrid searchmode="hybrid"# Mix mode Integrates knowledge graph and vector retrieval.mode="mix"rag.query(
"What are the top themes in this story?",
param=QueryParam(mode=mode)
)
if__name__=="__main__":
main()

Query Param

classQueryParam:
mode: Literal["local", "global", "hybrid", "naive", "mix"] ="global""""Specifies the retrieval mode: - "local": Focuses on context-dependent information. - "global": Utilizes global knowledge. - "hybrid": Combines local and global retrieval methods. - "naive": Performs a basic search without advanced techniques. - "mix": Integrates knowledge graph and vector retrieval. Mix mode combines knowledge graph and vector search: - Uses both structured (KG) and unstructured (vector) information - Provides comprehensive answers by analyzing relationships and context - Supports image content through HTML img tags - Allows control over retrieval depth via top_k parameter """only_need_context: bool=False"""If True, only returns the retrieved context without generating a response."""response_type: str="Multiple Paragraphs""""Defines the response format. Examples: 'Multiple Paragraphs', 'Single Paragraph', 'Bullet Points'."""top_k: int=60"""Number of top items to retrieve. Represents entities in 'local' mode and relationships in 'global' mode."""max_token_for_text_unit: int=4000"""Maximum number of tokens allowed for each retrieved text chunk."""max_token_for_global_context: int=4000"""Maximum number of tokens allocated for relationship descriptions in global retrieval."""max_token_for_local_context: int=4000"""Maximum number of tokens allocated for entity descriptions in local retrieval."""ids: list[str] |None=None# ONLY SUPPORTED FOR PG VECTOR DBs"""List of ids to filter the RAG."""model_func: Callable[..., object] |None=None"""Optional override for the LLM model function to use for this specific query. If provided, this will be used instead of the global model function. This allows using different models for different query modes. """
...

default value of Top_k can be change by environment variables TOP_K.

LLM and Embedding Injection

LightRAG requires the utilization of LLM and Embedding models to accomplish document indexing and querying tasks. During the initialization phase, it is necessary to inject the invocation methods of the relevant models into LightRAG：

Using Open AI-like APIs

LightRAG also supports Open AI-like chat/embeddings APIs:

asyncdefllm_model_func(
prompt, system_prompt=None, history_messages=[], keyword_extraction=False, **kwargs
) ->str:
returnawaitopenai_complete_if_cache(
"solar-mini",
prompt,
system_prompt=system_prompt,
history_messages=history_messages,
api_key=os.getenv("UPSTAGE_API_KEY"),
base_url="https://api.upstage.ai/v1/solar",
**kwargs
)
asyncdefembedding_func(texts: list[str]) ->np.ndarray:
returnawaitopenai_embed(
texts,
model="solar-embedding-1-large-query",
api_key=os.getenv("UPSTAGE_API_KEY"),
base_url="https://api.upstage.ai/v1/solar"
)
asyncdefinitialize_rag():
rag=LightRAG(
working_dir=WORKING_DIR,
llm_model_func=llm_model_func,
embedding_func=EmbeddingFunc(
embedding_dim=4096,
max_token_size=8192,
func=embedding_func
)
)
awaitrag.initialize_storages()
awaitinitialize_pipeline_status()
returnrag

Using Hugging Face Models

If you want to use Hugging Face models, you only need to set LightRAG as follows:

See lightrag_hf_demo.py

# Initialize LightRAG with Hugging Face modelrag=LightRAG(
working_dir=WORKING_DIR,
llm_model_func=hf_model_complete, # Use Hugging Face model for text generationllm_model_name='meta-llama/Llama-3.1-8B-Instruct', # Model name from Hugging Face# Use Hugging Face embedding functionembedding_func=EmbeddingFunc(
embedding_dim=384,
max_token_size=5000,
func=lambdatexts: hf_embed(
texts,
tokenizer=AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2"),
embed_model=AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
)
),
)

Using Ollama Models

**Overview**

If you want to use Ollama models, you need to pull model you plan to use and embedding model, for example nomic-embed-text.

Then you only need to set LightRAG as follows:

# Initialize LightRAG with Ollama modelrag=LightRAG(
working_dir=WORKING_DIR,
llm_model_func=ollama_model_complete, # Use Ollama model for text generationllm_model_name='your_model_name', # Your model name# Use Ollama embedding functionembedding_func=EmbeddingFunc(
embedding_dim=768,
max_token_size=8192,
func=lambdatexts: ollama_embed(
texts,
embed_model="nomic-embed-text"
)
),
)

Increasing context size

In order for LightRAG to work context should be at least 32k tokens. By default Ollama models have context size of 8k. You can achieve this using one of two ways:

Increasing the num_ctx parameter in Modelfile

Pull the model:

ollama pull qwen2

Display the model file:

ollama show --modelfile qwen2 > Modelfile

Edit the Modelfile by adding the following line:

PARAMETER num_ctx 32768

Create the modified model:

ollama create -f Modelfile qwen2m

Setup num_ctx via Ollama API

Tiy can use llm_model_kwargs param to configure ollama:

rag=LightRAG(
working_dir=WORKING_DIR,
llm_model_func=ollama_model_complete, # Use Ollama model for text generationllm_model_name='your_model_name', # Your model namellm_model_kwargs={"options": {"num_ctx": 32768}},
# Use Ollama embedding functionembedding_func=EmbeddingFunc(
embedding_dim=768,
max_token_size=8192,
func=lambdatexts: ollama_embedding(
texts,
embed_model="nomic-embed-text"
)
),
)

Low RAM GPUs

In order to run this experiment on low RAM GPU you should select small model and tune context window (increasing context increase memory consumption). For example, running this ollama example on repurposed mining GPU with 6Gb of RAM required to set context size to 26k while using gemma2:2b. It was able to find 197 entities and 19 relations on book.txt.

LlamaIndex

LightRAG supports integration with LlamaIndex (llm/llama_index_impl.py):

Integrates with OpenAI and other providers through LlamaIndex
See LlamaIndex Documentation for detailed setup and examples

Example Usage

# Using LlamaIndex with direct OpenAI accessimportasynciofromlightragimportLightRAGfromlightrag.llm.llama_index_implimportllama_index_complete_if_cache, llama_index_embedfromllama_index.embeddings.openaiimportOpenAIEmbeddingfromllama_index.llms.openaiimportOpenAIfromlightrag.kg.shared_storageimportinitialize_pipeline_statusfromlightrag.utilsimportsetup_logger# Setup log handler for LightRAGsetup_logger("lightrag", level="INFO")
asyncdefinitialize_rag():
rag=LightRAG(
working_dir="your/path",
llm_model_func=llama_index_complete_if_cache, # LlamaIndex-compatible completion functionembedding_func=EmbeddingFunc( # LlamaIndex-compatible embedding functionembedding_dim=1536,
max_token_size=8192,
func=lambdatexts: llama_index_embed(texts, embed_model=embed_model)
),
)
awaitrag.initialize_storages()
awaitinitialize_pipeline_status()
returnragdefmain():
# Initialize RAG instancerag=asyncio.run(initialize_rag())
withopen("./book.txt", "r", encoding="utf-8") asf:
rag.insert(f.read())
# Perform naive searchprint(
rag.query("What are the top themes in this story?", param=QueryParam(mode="naive"))
)
# Perform local searchprint(
rag.query("What are the top themes in this story?", param=QueryParam(mode="local"))
)
# Perform global searchprint(
rag.query("What are the top themes in this story?", param=QueryParam(mode="global"))
)
# Perform hybrid searchprint(
rag.query("What are the top themes in this story?", param=QueryParam(mode="hybrid"))
)
if__name__=="__main__":
main()

For detailed documentation and examples, see:

Token Usage Tracking

Overview and Usage

LightRAG provides a TokenTracker tool to monitor and manage token consumption by large language models. This feature is particularly useful for controlling API costs and optimizing performance.

Usage

fromlightrag.utilsimportTokenTracker# Create TokenTracker instancetoken_tracker=TokenTracker()
# Method 1: Using context manager (Recommended)# Suitable for scenarios requiring automatic token usage trackingwithtoken_tracker:
result1=awaitllm_model_func("your question 1")
result2=awaitllm_model_func("your question 2")
# Method 2: Manually adding token usage records# Suitable for scenarios requiring more granular control over token statisticstoken_tracker.reset()
rag.insert()
rag.query("your question 1", param=QueryParam(mode="naive"))
rag.query("your question 2", param=QueryParam(mode="mix"))
# Display total token usage (including insert and query operations)print("Token usage:", token_tracker.get_usage())

Usage Tips

Use context managers for long sessions or batch operations to automatically track all token consumption
For scenarios requiring segmented statistics, use manual mode and call reset() when appropriate
Regular checking of token usage helps detect abnormal consumption early
Actively use this feature during development and testing to optimize production costs

Practical Examples

You can refer to these examples for implementing token tracking:

examples/lightrag_gemini_track_token_demo.py: Token tracking example using Google Gemini model
examples/lightrag_siliconcloud_track_token_demo.py: Token tracking example using SiliconCloud model

These examples demonstrate how to effectively use the TokenTracker feature with different models and scenarios.

Conversation History Support

LightRAG now supports multi-turn dialogue through the conversation history feature. Here's how to use it:

Usage Example

# Create conversation historyconversation_history= [
{"role": "user", "content": "What is the main character's attitude towards Christmas?"},
{"role": "assistant", "content": "At the beginning of the story, Ebenezer Scrooge has a very negative attitude towards Christmas..."},
{"role": "user", "content": "How does his attitude change?"}
]
# Create query parameters with conversation historyquery_param=QueryParam(
mode="mix", # or any other mode: "local", "global", "hybrid"conversation_history=conversation_history, # Add the conversation historyhistory_turns=3# Number of recent conversation turns to consider
)
# Make a query that takes into account the conversation historyresponse=rag.query(
"What causes this change in his character?",
param=query_param
)

Custom Prompt Support

LightRAG now supports custom prompts for fine-tuned control over the system's behavior. Here's how to use it:

Usage Example

# Create query parametersquery_param=QueryParam(
mode="hybrid", # or other mode: "local", "global", "hybrid", "mix" and "naive"
)
# Example 1: Using the default system promptresponse_default=rag.query(
"What are the primary benefits of renewable energy?",
param=query_param
)
print(response_default)
# Example 2: Using a custom promptcustom_prompt="""You are an expert assistant in environmental science. Provide detailed and structured answers with examples.---Conversation History---{history}---Knowledge Base---{context_data}---Response Rules---- Target format and length: {response_type}"""response_custom=rag.query(
"What are the primary benefits of renewable energy?",
param=query_param,
system_prompt=custom_prompt# Pass the custom prompt
)
print(response_custom)

Separate Keyword Extraction

We've introduced a new function query_with_separate_keyword_extraction to enhance the keyword extraction capabilities. This function separates the keyword extraction process from the user's prompt, focusing solely on the query to improve the relevance of extracted keywords.

How It Works?

The function operates by dividing the input into two parts:

User Query
Prompt

It then performs keyword extraction exclusively on the user query. This separation ensures that the extraction process is focused and relevant, unaffected by any additional language in the prompt. It also allows the prompt to serve purely for response formatting, maintaining the intent and clarity of the user's original question.

Usage Example

This example shows how to tailor the function for educational content, focusing on detailed explanations for older students.

rag.query_with_separate_keyword_extraction(
query="Explain the law of gravity",
prompt="Provide a detailed explanation suitable for high school students studying physics.",
param=QueryParam(mode="hybrid")
)

Insert

Basic Insert

# Basic Insertrag.insert("Text")

Batch Insert

# Basic Batch Insert: Insert multiple texts at oncerag.insert(["TEXT1", "TEXT2",...])
# Batch Insert with custom batch size configurationrag=LightRAG(
working_dir=WORKING_DIR,
addon_params={
"insert_batch_size": 4# Process 4 documents per batch
}
)
rag.insert(["TEXT1", "TEXT2", "TEXT3", ...]) # Documents will be processed in batches of 4

The insert_batch_size parameter in addon_params controls how many documents are processed in each batch during insertion. This is useful for:

Managing memory usage with large document collections
Optimizing processing speed
Providing better progress tracking
Default value is 10 if not specified

Insert with ID

If you want to provide your own IDs for your documents, number of documents and number of IDs must be the same.

# Insert single text, and provide ID for itrag.insert("TEXT1", ids=["ID_FOR_TEXT1"])
# Insert multiple texts, and provide IDs for themrag.insert(["TEXT1", "TEXT2",...], ids=["ID_FOR_TEXT1", "ID_FOR_TEXT2"])

Insert using Pipeline

The apipeline_enqueue_documents and apipeline_process_enqueue_documents functions allow you to perform incremental insertion of documents into the graph.

This is useful for scenarios where you want to process documents in the background while still allowing the main thread to continue executing.

And using a routine to process new documents.

rag=LightRAG(..)
awaitrag.apipeline_enqueue_documents(input)
# Your routine in loopawaitrag.apipeline_process_enqueue_documents(input)

Insert Multi-file Type Support

The textract supports reading file types such as TXT, DOCX, PPTX, CSV, and PDF.

importtextractfile_path='TEXT.pdf'text_content=textract.process(file_path)
rag.insert(text_content.decode('utf-8'))

Insert Custom KG

custom_kg= {
"chunks": [
{
"content": "Alice and Bob are collaborating on quantum computing research.",
"source_id": "doc-1"
}
],
"entities": [
{
"entity_name": "Alice",
"entity_type": "person",
"description": "Alice is a researcher specializing in quantum physics.",
"source_id": "doc-1"
},
{
"entity_name": "Bob",
"entity_type": "person",
"description": "Bob is a mathematician.",
"source_id": "doc-1"
},
{
"entity_name": "Quantum Computing",
"entity_type": "technology",
"description": "Quantum computing utilizes quantum mechanical phenomena for computation.",
"source_id": "doc-1"
}
],
"relationships": [
{
"src_id": "Alice",
"tgt_id": "Bob",
"description": "Alice and Bob are research partners.",
"keywords": "collaboration research",
"weight": 1.0,
"source_id": "doc-1"
},
{
"src_id": "Alice",
"tgt_id": "Quantum Computing",
"description": "Alice conducts research on quantum computing.",
"keywords": "research expertise",
"weight": 1.0,
"source_id": "doc-1"
},
{
"src_id": "Bob",
"tgt_id": "Quantum Computing",
"description": "Bob researches quantum computing.",
"keywords": "research application",
"weight": 1.0,
"source_id": "doc-1"
}
]
}
rag.insert_custom_kg(custom_kg)

Citation Functionality

By providing file paths, the system ensures that sources can be traced back to their original documents.

# Define documents and their file pathsdocuments= ["Document content 1", "Document content 2"]
file_paths= ["path/to/doc1.txt", "path/to/doc2.txt"]
# Insert documents with file pathsrag.insert(documents, file_paths=file_paths)

Storage

Using Neo4J for Storage

For production level scenarios you will most likely want to leverage an enterprise solution
for KG storage. Running Neo4J in Docker is recommended for seamless local testing.
See: https://hub.docker.com/_/neo4j

exportNEO4J_URI="neo4j://localhost:7687"exportNEO4J_USERNAME="neo4j"exportNEO4J_PASSWORD="password"# Setup logger for LightRAGsetup_logger("lightrag", level="INFO")
# When you launch the project be sure to override the default KG: NetworkX# by specifying kg="Neo4JStorage".# Note: Default settings use NetworkX# Initialize LightRAG with Neo4J implementation.asyncdefinitialize_rag():
rag=LightRAG(
working_dir=WORKING_DIR,
llm_model_func=gpt_4o_mini_complete, # Use gpt_4o_mini_complete LLM modelgraph_storage="Neo4JStorage", #<-----------override KG default
)
# Initialize database connectionsawaitrag.initialize_storages()
# Initialize pipeline status for document processingawaitinitialize_pipeline_status()
returnrag

see test_neo4j.py for a working example.

Using PostgreSQL for Storage

For production level scenarios you will most likely want to leverage an enterprise solution. PostgreSQL can provide a one-stop solution for you as KV store, VectorDB (pgvector) and GraphDB (apache AGE).

PostgreSQL is lightweight,the whole binary distribution including all necessary plugins can be zipped to 40MB: Ref to Windows Release as it is easy to install for Linux/Mac.
If you prefer docker, please start with this image if you are a beginner to avoid hiccups (DO read the overview): https://hub.docker.com/r/shangor/postgres-for-rag
How to start? Ref to: examples/lightrag_zhipu_postgres_demo.py

Create index for AGE example: (Change below dickens to your graph name if necessary)

load 'age';
SET search_path = ag_catalog, "$user", public;
CREATEINDEXCONCURRENTLY entity_p_idx ON dickens."Entity" (id);
CREATEINDEXCONCURRENTLY vertex_p_idx ON dickens."_ag_label_vertex" (id);
CREATEINDEXCONCURRENTLY directed_p_idx ON dickens."DIRECTED" (id);
CREATEINDEXCONCURRENTLY directed_eid_idx ON dickens."DIRECTED" (end_id);
CREATEINDEXCONCURRENTLY directed_sid_idx ON dickens."DIRECTED" (start_id);
CREATEINDEXCONCURRENTLY directed_seid_idx ON dickens."DIRECTED" (start_id,end_id);
CREATEINDEXCONCURRENTLY edge_p_idx ON dickens."_ag_label_edge" (id);
CREATEINDEXCONCURRENTLY edge_sid_idx ON dickens."_ag_label_edge" (start_id);
CREATEINDEXCONCURRENTLY edge_eid_idx ON dickens."_ag_label_edge" (end_id);
CREATEINDEXCONCURRENTLY edge_seid_idx ON dickens."_ag_label_edge" (start_id,end_id);
createINDEXCONCURRENTLY vertex_idx_node_id ON dickens."_ag_label_vertex" (ag_catalog.agtype_access_operator(properties, '"node_id"'::agtype));
createINDEXCONCURRENTLY entity_idx_node_id ON dickens."Entity" (ag_catalog.agtype_access_operator(properties, '"node_id"'::agtype));
CREATEINDEXCONCURRENTLY entity_node_id_gin_idx ON dickens."Entity" using gin(properties);
ALTERTABLE dickens."DIRECTED" CLUSTER ON directed_sid_idx;
-- drop if necessarydropINDEX entity_p_idx;
dropINDEX vertex_p_idx;
dropINDEX directed_p_idx;
dropINDEX directed_eid_idx;
dropINDEX directed_sid_idx;
dropINDEX directed_seid_idx;
dropINDEX edge_p_idx;
dropINDEX edge_sid_idx;
dropINDEX edge_eid_idx;
dropINDEX edge_seid_idx;
dropINDEX vertex_idx_node_id;
dropINDEX entity_idx_node_id;
dropINDEX entity_node_id_gin_idx;

Known issue of the Apache AGE: The released versions got below issue:
You might find that the properties of the nodes/edges are empty. It is a known issue of the release version: apache/age#1721
You can Compile the AGE from source code and fix it.

Using Faiss for Storage

Install the required dependencies:

pip install faiss-cpu

You can also install faiss-gpu if you have GPU support.

Here we are using sentence-transformers but you can also use OpenAIEmbedding model with 3072 dimensions.

asyncdefembedding_func(texts: list[str]) ->np.ndarray:
model=SentenceTransformer('all-MiniLM-L6-v2')
embeddings=model.encode(texts, convert_to_numpy=True)
returnembeddings# Initialize LightRAG with the LLM model function and embedding functionrag=LightRAG(
working_dir=WORKING_DIR,
llm_model_func=llm_model_func,
embedding_func=EmbeddingFunc(
embedding_dim=384,
max_token_size=8192,
func=embedding_func,
),
vector_storage="FaissVectorDBStorage",
vector_db_storage_cls_kwargs={
"cosine_better_than_threshold": 0.3# Your desired threshold
}
)

Delete

# Delete Entity: Deleting entities by their namesrag.delete_by_entity("Project Gutenberg")
# Delete Document: Deleting entities and relationships associated with the document by doc idrag.delete_by_doc_id("doc_id")

Edit Entities and Relations

LightRAG now supports comprehensive knowledge graph management capabilities, allowing you to create, edit, and delete entities and relationships within your knowledge graph.

Create Entities and Relations

# Create new entityentity=rag.create_entity("Google", {
"description": "Google is a multinational technology company specializing in internet-related services and products.",
"entity_type": "company"
})
# Create another entityproduct=rag.create_entity("Gmail", {
"description": "Gmail is an email service developed by Google.",
"entity_type": "product"
})
# Create relation between entitiesrelation=rag.create_relation("Google", "Gmail", {
"description": "Google develops and operates Gmail.",
"keywords": "develops operates service",
"weight": 2.0
})

Edit Entities and Relations

# Edit an existing entityupdated_entity=rag.edit_entity("Google", {
"description": "Google is a subsidiary of Alphabet Inc., founded in 1998.",
"entity_type": "tech_company"
})
# Rename an entity (with all its relationships properly migrated)renamed_entity=rag.edit_entity("Gmail", {
"entity_name": "Google Mail",
"description": "Google Mail (formerly Gmail) is an email service."
})
# Edit a relation between entitiesupdated_relation=rag.edit_relation("Google", "Google Mail", {
"description": "Google created and maintains Google Mail service.",
"keywords": "creates maintains email service",
"weight": 3.0
})

All operations are available in both synchronous and asynchronous versions. The asynchronous versions have the prefix "a" (e.g., acreate_entity, aedit_relation).

Entity Operations

create_entity: Creates a new entity with specified attributes
edit_entity: Updates an existing entity's attributes or renames it

Relation Operations

create_relation: Creates a new relation between existing entities
edit_relation: Updates an existing relation's attributes

These operations maintain data consistency across both the graph database and vector database components, ensuring your knowledge graph remains coherent.

Data Export Functions

Overview

LightRAG allows you to export your knowledge graph data in various formats for analysis, sharing, and backup purposes. The system supports exporting entities, relations, and relationship data.

Export Functions

Basic Usage

# Basic CSV export (default format)rag.export_data("knowledge_graph.csv")
# Specify any formatrag.export_data("output.xlsx", file_format="excel")

Different File Formats supported

#Export data in CSV formatrag.export_data("graph_data.csv", file_format="csv")
# Export data in Excel sheetrag.export_data("graph_data.xlsx", file_format="excel")
# Export data in markdown formatrag.export_data("graph_data.md", file_format="md")
# Export data in Textrag.export_data("graph_data.txt", file_format="txt")

Additional Options

Include vector embeddings in the export (optional):

rag.export_data("complete_data.csv", include_vector_data=True)

Data Included in Export

All exports include:

Entity information (names, IDs, metadata)
Relation data (connections between entities)
Relationship information from vector database

Entity Merging

Merge Entities and Their Relationships

LightRAG now supports merging multiple entities into a single entity, automatically handling all relationships:

# Basic entity mergingrag.merge_entities(
source_entities=["Artificial Intelligence", "AI", "Machine Intelligence"],
target_entity="AI Technology"
)

With custom merge strategy:

# Define custom merge strategy for different fieldsrag.merge_entities(
source_entities=["John Smith", "Dr. Smith", "J. Smith"],
target_entity="John Smith",
merge_strategy={
"description": "concatenate", # Combine all descriptions"entity_type": "keep_first", # Keep the entity type from the first entity"source_id": "join_unique"# Combine all unique source IDs
}
)

With custom target entity data:

# Specify exact values for the merged entityrag.merge_entities(
source_entities=["New York", "NYC", "Big Apple"],
target_entity="New York City",
target_entity_data={
"entity_type": "LOCATION",
"description": "New York City is the most populous city in the United States.",
}
)

Advanced usage combining both approaches:

# Merge company entities with both strategy and custom datarag.merge_entities(
source_entities=["Microsoft Corp", "Microsoft Corporation", "MSFT"],
target_entity="Microsoft",
merge_strategy={
"description": "concatenate", # Combine all descriptions"source_id": "join_unique"# Combine source IDs
},
target_entity_data={
"entity_type": "ORGANIZATION",
}
)

When merging entities:

All relationships from source entities are redirected to the target entity
Duplicate relationships are intelligently merged
Self-relationships (loops) are prevented
Source entities are removed after merging
Relationship weights and attributes are preserved

Cache

Clear Cache

You can clear the LLM response cache with different modes:

# Clear all cacheawaitrag.aclear_cache()
# Clear local mode cacheawaitrag.aclear_cache(modes=["local"])
# Clear extraction cacheawaitrag.aclear_cache(modes=["default"])
# Clear multiple modesawaitrag.aclear_cache(modes=["local", "global", "hybrid"])
# Synchronous versionrag.clear_cache(modes=["local"])

Valid modes are:

"default": Extraction cache
"naive": Naive search cache
"local": Local search cache
"global": Global search cache
"hybrid": Hybrid search cache
"mix": Mix search cache

LightRAG init parameters

Parameters

Parameter	Type	Explanation	Default
working_dir	`str`	Directory where the cache will be stored	`lightrag_cache+timestamp`
kv_storage	`str`	Storage type for documents and text chunks. Supported types: `JsonKVStorage`,`PGKVStorage`,`RedisKVStorage`,`MongoKVStorage`	`JsonKVStorage`
vector_storage	`str`	Storage type for embedding vectors. Supported types: `NanoVectorDBStorage`,`PGVectorStorage`,`MilvusVectorDBStorage`,`ChromaVectorDBStorage`,`FaissVectorDBStorage`,`MongoVectorDBStorage`,`QdrantVectorDBStorage`	`NanoVectorDBStorage`
graph_storage	`str`	Storage type for graph edges and nodes. Supported types: `NetworkXStorage`,`Neo4JStorage`,`PGGraphStorage`,`AGEStorage`	`NetworkXStorage`
doc_status_storage	`str`	Storage type for documents process status. Supported types: `JsonDocStatusStorage`,`PGDocStatusStorage`,`MongoDocStatusStorage`	`JsonDocStatusStorage`
chunk_token_size	`int`	Maximum token size per chunk when splitting documents	`1200`
chunk_overlap_token_size	`int`	Overlap token size between two chunks when splitting documents	`100`
tiktoken_model_name	`str`	Model name for the Tiktoken encoder used to calculate token numbers	`gpt-4o-mini`
entity_extract_max_gleaning	`int`	Number of loops in the entity extraction process, appending history messages	`1`
entity_summary_to_max_tokens	`int`	Maximum token size for each entity summary	`500`
node_embedding_algorithm	`str`	Algorithm for node embedding (currently not used)	`node2vec`
node2vec_params	`dict`	Parameters for node embedding	`{"dimensions": 1536,"num_walks": 10,"walk_length": 40,"window_size": 2,"iterations": 3,"random_seed": 3,}`
embedding_func	`EmbeddingFunc`	Function to generate embedding vectors from text	`openai_embed`
embedding_batch_num	`int`	Maximum batch size for embedding processes (multiple texts sent per batch)	`32`
embedding_func_max_async	`int`	Maximum number of concurrent asynchronous embedding processes	`16`
llm_model_func	`callable`	Function for LLM generation	`gpt_4o_mini_complete`
llm_model_name	`str`	LLM model name for generation	`meta-llama/Llama-3.2-1B-Instruct`
llm_model_max_token_size	`int`	Maximum token size for LLM generation (affects entity relation summaries)	`32768`（default value changed by env var MAX_TOKENS)
llm_model_max_async	`int`	Maximum number of concurrent asynchronous LLM processes	`4`（default value changed by env var MAX_ASYNC)
llm_model_kwargs	`dict`	Additional parameters for LLM generation
vector_db_storage_cls_kwargs	`dict`	Additional parameters for vector database, like setting the threshold for nodes and relations retrieval	cosine_better_than_threshold: 0.2（default value changed by env var COSINE_THRESHOLD)
enable_llm_cache	`bool`	If `TRUE`, stores LLM results in cache; repeated prompts return cached responses	`TRUE`
enable_llm_cache_for_entity_extract	`bool`	If `TRUE`, stores LLM results in cache for entity extraction; Good for beginners to debug your application	`TRUE`
addon_params	`dict`	Additional parameters, e.g., `{"example_number": 1, "language": "Simplified Chinese", "entity_types": ["organization", "person", "geo", "event"], "insert_batch_size": 10}`: sets example limit, output language, and batch size for document processing	`example_number: all examples, language: English, insert_batch_size: 10`
convert_response_to_json_func	`callable`	Not used	`convert_response_to_json`
embedding_cache_config	`dict`	Configuration for question-answer caching. Contains three parameters: `enabled`: Boolean value to enable/disable cache lookup functionality. When enabled, the system will check cached responses before generating new answers. `similarity_threshold`: Float value (0-1), similarity threshold. When a new question's similarity with a cached question exceeds this threshold, the cached answer will be returned directly without calling the LLM. `use_llm_check`: Boolean value to enable/disable LLM similarity verification. When enabled, LLM will be used as a secondary check to verify the similarity between questions before returning cached answers.	Default: `{"enabled": False, "similarity_threshold": 0.95, "use_llm_check": False}`

Error Handling

Click to view error handling details

The API includes comprehensive error handling:

File not found errors (404)
Processing errors (500)
Supports multiple file encodings (UTF-8 and GBK)

LightRAG API

The LightRAG Server is designed to provide Web UI and API support. For more information about LightRAG Server, please refer to LightRAG Server.

Graph Visualization

The LightRAG Server offers a comprehensive knowledge graph visualization feature. It supports various gravity layouts, node queries, subgraph filtering, and more. For more information about LightRAG Server, please refer to LightRAG Server.

Evaluation

Dataset

The dataset used in LightRAG can be downloaded from TommyChien/UltraDomain.

Generate Query

LightRAG uses the following prompt to generate high-level queries, with the corresponding code in example/generate_query.py.

Prompt

Giventhefollowingdescriptionofadataset:
{description}
Pleaseidentify5potentialuserswhowouldengagewiththisdataset. Foreachuser, list5taskstheywouldperformwiththisdataset. Then, foreach (user, task) combination, generate5questionsthatrequireahigh-levelunderstandingoftheentiredataset.
Outputtheresultsinthefollowingstructure:
-User1: [userdescription]
-Task1: [taskdescription]
-Question1:
-Question2:
-Question3:
-Question4:
-Question5:
-Task2: [taskdescription]
...
-Task5: [taskdescription]
-User2: [userdescription]
...
-User5: [userdescription]
...

Batch Eval

To evaluate the performance of two RAG systems on high-level queries, LightRAG uses the following prompt, with the specific code available in example/batch_eval.py.

Prompt

---Role---Youareanexperttaskedwithevaluatingtwoanswerstothesamequestionbasedonthreecriteria: **Comprehensiveness**, **Diversity**, and**Empowerment**.
---Goal---Youwillevaluatetwoanswerstothesamequestionbasedonthreecriteria: **Comprehensiveness**, **Diversity**, and**Empowerment**.
-**Comprehensiveness**: Howmuchdetaildoestheanswerprovidetocoverallaspectsanddetailsofthequestion?
-**Diversity**: Howvariedandrichistheanswerinprovidingdifferentperspectivesandinsightsonthequestion?
-**Empowerment**: Howwelldoestheanswerhelpthereaderunderstandandmakeinformedjudgmentsaboutthetopic?
Foreachcriterion, choosethebetteranswer (eitherAnswer1orAnswer2) andexplainwhy. Then, selectanoverallwinnerbasedonthesethreecategories.
Hereisthequestion:
{query}
Herearethetwoanswers:
**Answer1:**
{answer1}
**Answer2:**
{answer2}
Evaluatebothanswersusingthethreecriterialistedaboveandprovidedetailedexplanationsforeachcriterion.
OutputyourevaluationinthefollowingJSONformat:
{{
"Comprehensiveness": {{
"Winner": "[Answer 1 or Answer 2]",
"Explanation": "[Provide explanation here]"
}},
"Empowerment": {{
"Winner": "[Answer 1 or Answer 2]",
"Explanation": "[Provide explanation here]"
}},
"Overall Winner": {{
"Winner": "[Answer 1 or Answer 2]",
"Explanation": "[Summarize why this answer is the overall winner based on the three criteria]"
}}
}}

Overall Performance Table

	Agriculture		CS		Legal		Mix
	NaiveRAG	LightRAG	NaiveRAG	LightRAG	NaiveRAG	LightRAG	NaiveRAG	LightRAG
Comprehensiveness	32.4%	67.6%	38.4%	61.6%	16.4%	83.6%	38.8%	61.2%
Diversity	23.6%	76.4%	38.0%	62.0%	13.6%	86.4%	32.4%	67.6%
Empowerment	32.4%	67.6%	38.8%	61.2%	16.4%	83.6%	42.8%	57.2%
Overall	32.4%	67.6%	38.8%	61.2%	15.2%	84.8%	40.0%	60.0%
	RQ-RAG	LightRAG	RQ-RAG	LightRAG	RQ-RAG	LightRAG	RQ-RAG	LightRAG
Comprehensiveness	31.6%	68.4%	38.8%	61.2%	15.2%	84.8%	39.2%	60.8%
Diversity	29.2%	70.8%	39.2%	60.8%	11.6%	88.4%	30.8%	69.2%
Empowerment	31.6%	68.4%	36.4%	63.6%	15.2%	84.8%	42.4%	57.6%
Overall	32.4%	67.6%	38.0%	62.0%	14.4%	85.6%	40.0%	60.0%
	HyDE	LightRAG	HyDE	LightRAG	HyDE	LightRAG	HyDE	LightRAG
Comprehensiveness	26.0%	74.0%	41.6%	58.4%	26.8%	73.2%	40.4%	59.6%
Diversity	24.0%	76.0%	38.8%	61.2%	20.0%	80.0%	32.4%	67.6%
Empowerment	25.2%	74.8%	40.8%	59.2%	26.0%	74.0%	46.0%	54.0%
Overall	24.8%	75.2%	41.6%	58.4%	26.4%	73.6%	42.4%	57.6%
	GraphRAG	LightRAG	GraphRAG	LightRAG	GraphRAG	LightRAG	GraphRAG	LightRAG
Comprehensiveness	45.6%	54.4%	48.4%	51.6%	48.4%	51.6%	50.4%	49.6%
Diversity	22.8%	77.2%	40.8%	59.2%	26.4%	73.6%	36.0%	64.0%
Empowerment	41.2%	58.8%	45.2%	54.8%	43.6%	56.4%	50.8%	49.2%
Overall	45.2%	54.8%	48.0%	52.0%	47.2%	52.8%	50.4%	49.6%

Reproduce

All the code can be found in the ./reproduce directory.

Step-0 Extract Unique Contexts

First, we need to extract unique contexts in the datasets.

Code

defextract_unique_contexts(input_directory, output_directory):
os.makedirs(output_directory, exist_ok=True)
jsonl_files=glob.glob(os.path.join(input_directory, '*.jsonl'))
print(f"Found {len(jsonl_files)} JSONL files.")
forfile_pathinjsonl_files:
filename=os.path.basename(file_path)
name, ext=os.path.splitext(filename)
output_filename=f"{name}_unique_contexts.json"output_path=os.path.join(output_directory, output_filename)
unique_contexts_dict= {}
print(f"Processing file: {filename}")
try:
withopen(file_path, 'r', encoding='utf-8') asinfile:
forline_number, lineinenumerate(infile, start=1):
line=line.strip()
ifnotline:
continuetry:
json_obj=json.loads(line)
context=json_obj.get('context')
ifcontextandcontextnotinunique_contexts_dict:
unique_contexts_dict[context] =Noneexceptjson.JSONDecodeErrorase:
print(f"JSON decoding error in file {filename} at line {line_number}: {e}")
exceptFileNotFoundError:
print(f"File not found: {filename}")
continueexceptExceptionase:
print(f"An error occurred while processing file {filename}: {e}")
continueunique_contexts_list=list(unique_contexts_dict.keys())
print(f"There are {len(unique_contexts_list)} unique `context` entries in the file {filename}.")
try:
withopen(output_path, 'w', encoding='utf-8') asoutfile:
json.dump(unique_contexts_list, outfile, ensure_ascii=False, indent=4)
print(f"Unique `context` entries have been saved to: {output_filename}")
exceptExceptionase:
print(f"An error occurred while saving to the file {output_filename}: {e}")
print("All files have been processed.")

Step-1 Insert Contexts

For the extracted contexts, we insert them into the LightRAG system.

Code

definsert_text(rag, file_path):
withopen(file_path, mode='r') asf:
unique_contexts=json.load(f)
retries=0max_retries=3whileretries<max_retries:
try:
rag.insert(unique_contexts)
breakexceptExceptionase:
retries+=1print(f"Insertion failed, retrying ({retries}/{max_retries}), error: {e}")
time.sleep(10)
ifretries==max_retries:
print("Insertion failed after exceeding the maximum number of retries")

Step-2 Generate Queries

We extract tokens from the first and the second half of each context in the dataset, then combine them as dataset descriptions to generate queries.

Code

tokenizer=GPT2Tokenizer.from_pretrained('gpt2')
defget_summary(context, tot_tokens=2000):
tokens=tokenizer.tokenize(context)
half_tokens=tot_tokens//2start_tokens=tokens[1000:1000+half_tokens]
end_tokens=tokens[-(1000+half_tokens):1000]
summary_tokens=start_tokens+end_tokenssummary=tokenizer.convert_tokens_to_string(summary_tokens)
returnsummary

Step-3 Query

For the queries generated in Step-2, we will extract them and query LightRAG.

Code

defextract_queries(file_path):
withopen(file_path, 'r') asf:
data=f.read()
data=data.replace('**', '')
queries=re.findall(r'- Question \d+: (.+)', data)
returnqueries

Star History

Contribution

Thank you to all our contributors!

🌟Citation

@article{guo2024lightrag,title={LightRAG: SimpleandFastRetrieval-AugmentedGeneration},author={ZiruiGuoandLianghaoXiaandYanhuaYuandTuAoandChaoHuang},year={2024},eprint={2410.05779},archivePrefix={arXiv},primaryClass={cs.IR}}

Thank you for your interest in our work!

Name		Name	Last commit message	Last commit date
.github		.github
README.assets		README.assets
assets		assets
docs		docs
examples		examples
lightrag		lightrag
lightrag_webui		lightrag_webui
reproduce		reproduce
tests		tests
.dockerignore		.dockerignore
.gitattributes		.gitattributes
.gitignore		.gitignore
.pre-commit-config.yaml		.pre-commit-config.yaml
Dockerfile		Dockerfile
LICENSE		LICENSE
MANIFEST.in		MANIFEST.in
README-zh.md		README-zh.md
README.md		README.md
config.ini.example		config.ini.example
docker-compose.yml		docker-compose.yml
env.example		env.example
lightrag-api		lightrag-api
lightrag.service.example		lightrag.service.example
requirements.txt		requirements.txt
setup.py		setup.py

Latest commit

History

Folders and files

Repository files navigation

🚀 LightRAG: Simple and Fast Retrieval-Augmented Generation

🎉 News

Installation

Install LightRAG Core

Install LightRAG Server

Quick Start

Query

Query Param

LLM and Embedding Injection

Token Usage Tracking

Usage

Usage Tips

Practical Examples

Conversation History Support

Custom Prompt Support

Separate Keyword Extraction

Insert

Storage

Delete

Edit Entities and Relations

Entity Operations

Relation Operations

Data Export Functions

Overview

Export Functions

Data Included in Export

Entity Merging

Cache

LightRAG init parameters

Error Handling

LightRAG API

Graph Visualization

Evaluation

Dataset

Generate Query

Batch Eval

Overall Performance Table

Reproduce

Step-0 Extract Unique Contexts

Step-1 Insert Contexts

Step-2 Generate Queries

Step-3 Query

Star History

Contribution

🌟Citation

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages