LightRAG also supports Open AI-like chat/embeddings APIs:
LightRAG 还支持类似 Open AI 的聊天/嵌入 (embeddings) API：

import os
import numpy as np
from lightrag.utils import wrap_embedding_func_with_attrs
from lightrag.llm.openai import openai_complete_if_cache, openai_embed

async def llm_model_func(
    prompt, system_prompt=None, history_messages=[], keyword_extraction=False, **kwargs
) -> str:
    return await openai_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
    )

@wrap_embedding_func_with_attrs(embedding_dim=4096, max_token_size=8192, model_name="solar-embedding-1-large-query")
async def embedding_func(texts: list[str]) -> np.ndarray:
    return await openai_embed.func(
        texts,
        model="solar-embedding-1-large-query",
        api_key=os.getenv("UPSTAGE_API_KEY"),
        base_url="https://api.upstage.ai/v1/solar"
    )

async def initialize_rag():
    rag = LightRAG(
        working_dir=WORKING_DIR,
        llm_model_func=llm_model_func,
        embedding_func=embedding_func  # Pass the decorated function directly
    )

    await rag.initialize_storages()
    return rag

Important Note on Embedding Function Wrapping:

EmbeddingFunc cannot be nested. Functions that have been decorated with @wrap_embedding_func_with_attrs (such as openai_embed, ollama_embed, etc.) cannot be wrapped again using EmbeddingFunc(). This is why we call xxx_embed.func (the underlying unwrapped function) instead of xxx_embed directly when creating custom embedding functions.

If you want to use Hugging Face models, you only need to set LightRAG as follows:
如果你想使用 Hugging Face 模型，你只需要像下面这样设置 LightRAG：

from functools import partial
from transformers import AutoTokenizer, AutoModel

# Pre-load tokenizer and model
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
embed_model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")

# Initialize LightRAG with Hugging Face model
rag = LightRAG(
    working_dir=WORKING_DIR,
    llm_model_func=hf_model_complete,  # Use Hugging Face model for text generation
    llm_model_name='meta-llama/Llama-3.1-8B-Instruct',  # Model name from Hugging Face
    # Use Hugging Face embedding function
    embedding_func=EmbeddingFunc(
        embedding_dim=384,
        max_token_size=2048,
        model_name="sentence-transformers/all-MiniLM-L6-v2",
        func=partial(
            hf_embed.func,  # Use .func to access the unwrapped function
            tokenizer=tokenizer,
            embed_model=embed_model
        )
    ),
)

import numpy as np
from lightrag.utils import wrap_embedding_func_with_attrs
from lightrag.llm.ollama import ollama_model_complete, ollama_embed

@wrap_embedding_func_with_attrs(embedding_dim=768, max_token_size=8192, model_name="nomic-embed-text")
async def embedding_func(texts: list[str]) -> np.ndarray:
    return await ollama_embed.func(texts, embed_model="nomic-embed-text")

# Initialize LightRAG with Ollama model
rag = LightRAG(
    working_dir=WORKING_DIR,
    llm_model_func=ollama_model_complete,  # Use Ollama model for text generation
    llm_model_name='your_model_name', # Your model name
    embedding_func=embedding_func,  # Pass the decorated function directly
)

Increasing context size
增加上下文大小

Increasing the num_ctx parameter in Modelfile
增加 Modelfile 中的 num_ctx 参数

Pull the model:
拉取模型：

ollama pull qwen2

Display the model file:
显示模型文件：

ollama show --modelfile qwen2 > Modelfile

Edit the Modelfile by adding the following line:
编辑 Modelfile，添加以下行：

PARAMETER num_ctx 32768

Create the modified model:
创建修改后的模型：

ollama create -f Modelfile qwen2m

Setup num_ctx via Ollama API
通过 Ollama API 设置 num_ctx

import numpy as np
from lightrag.utils import wrap_embedding_func_with_attrs
from lightrag.llm.ollama import ollama_model_complete, ollama_embed

@wrap_embedding_func_with_attrs(embedding_dim=768, max_token_size=8192, model_name="nomic-embed-text")
async def embedding_func(texts: list[str]) -> np.ndarray:
    return await ollama_embed.func(texts, embed_model="nomic-embed-text")

rag = LightRAG(
    working_dir=WORKING_DIR,
    llm_model_func=ollama_model_complete,  # Use Ollama model for text generation
    llm_model_name='your_model_name', # Your model name
    llm_model_kwargs={"options": {"num_ctx": 32768}},
    embedding_func=embedding_func,  # Pass the decorated function directly
)

Low RAM GPUs
低 RAM GPU

Integrates with OpenAI and other providers through LlamaIndex
通过 LlamaIndex 与 OpenAI 和其他提供商集成
See LlamaIndex Documentation for detailed setup or the examples
有关详细设置，请参阅 LlamaIndex 文档或示例

# Using LlamaIndex with direct OpenAI access
import asyncio
from lightrag import LightRAG
from lightrag.llm.llama_index_impl import llama_index_complete_if_cache, llama_index_embed
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.llms.openai import OpenAI
from lightrag.utils import setup_logger

# Setup log handler for LightRAG
setup_logger("lightrag", level="INFO")

async def initialize_rag():
    rag = LightRAG(
        working_dir="your/path",
        llm_model_func=llama_index_complete_if_cache,  # LlamaIndex-compatible completion function
        embedding_func=EmbeddingFunc(    # LlamaIndex-compatible embedding function
            embedding_dim=1536,
            max_token_size=2048,
            model_name=embed_model,
            func=partial(llama_index_embed.func, embed_model=embed_model)  # Use .func to access the unwrapped function
        ),
    )

    await rag.initialize_storages()
    return rag

def main():
    # Initialize RAG instance
    rag = asyncio.run(initialize_rag())

    with open("./book.txt", "r", encoding="utf-8") as f:
        rag.insert(f.read())

    # Perform naive search
    print(
        rag.query("What are the top themes in this story?", param=QueryParam(mode="naive"))
    )

    # Perform local search
    print(
        rag.query("What are the top themes in this story?", param=QueryParam(mode="local"))
    )

    # Perform global search
    print(
        rag.query("What are the top themes in this story?", param=QueryParam(mode="global"))
    )

    # Perform hybrid search
    print(
        rag.query("What are the top themes in this story?", param=QueryParam(mode="hybrid"))
    )

if __name__ == "__main__":
    main()

LlamaIndex Documentation
LlamaIndex 文档
Direct OpenAI Example
直接 OpenAI 示例
LiteLLM Proxy Example
LiteLLM 代理示例
LiteLLM Proxy with Opik Example
带有 Opik 的 LiteLLM 代理示例

import os
import numpy as np
from lightrag.utils import wrap_embedding_func_with_attrs
from lightrag.llm.azure_openai import azure_openai_complete_if_cache, azure_openai_embed

# Configure the generation model
async def llm_model_func(
    prompt, system_prompt=None, history_messages=[], keyword_extraction=False, **kwargs
) -> str:
    return await azure_openai_complete_if_cache(
        prompt,
        system_prompt=system_prompt,
        history_messages=history_messages,
        api_key=os.getenv("AZURE_OPENAI_API_KEY"),
        azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
        api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
        deployment_name=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
        **kwargs
    )

# Configure the embedding model
@wrap_embedding_func_with_attrs(
    embedding_dim=1536,
    max_token_size=8192,
    model_name=os.getenv("AZURE_OPENAI_EMBEDDING_MODEL")
)
async def embedding_func(texts: list[str]) -> np.ndarray:
    return await azure_openai_embed.func(
        texts,
        api_key=os.getenv("AZURE_OPENAI_API_KEY"),
        azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
        api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
        deployment_name=os.getenv("AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME")
    )

rag = LightRAG(
    working_dir=WORKING_DIR,
    llm_model_func=llm_model_func,
    embedding_func=embedding_func
)

import os
import numpy as np
from lightrag.utils import wrap_embedding_func_with_attrs
from lightrag.llm.gemini import gemini_model_complete, gemini_embed

# Configure the generation model
async def llm_model_func(
    prompt, system_prompt=None, history_messages=[], keyword_extraction=False, **kwargs
) -> str:
    return await gemini_model_complete(
        prompt,
        system_prompt=system_prompt,
        history_messages=history_messages,
        api_key=os.getenv("GEMINI_API_KEY"),
        model_name="gemini-2.0-flash",
        **kwargs
    )

# Configure the embedding model
@wrap_embedding_func_with_attrs(
    embedding_dim=768,
    max_token_size=2048,
    model_name="models/text-embedding-004"
)
async def embedding_func(texts: list[str]) -> np.ndarray:
    return await gemini_embed.func(
        texts,
        api_key=os.getenv("GEMINI_API_KEY"),
        model="models/text-embedding-004"
    )

rag = LightRAG(
    working_dir=WORKING_DIR,
    llm_model_func=llm_model_func,
    llm_model_name="gemini-2.0-flash",
    embedding_func=embedding_func
)

# Insert single text, and provide ID for it
rag.insert("TEXT1", ids=["ID_FOR_TEXT1"])

# Insert multiple texts, and provide IDs for them
rag.insert(["TEXT1", "TEXT2",...], ids=["ID_FOR_TEXT1", "ID_FOR_TEXT2"])

rag = LightRAG(..)

await rag.apipeline_enqueue_documents(input)
# Your routine in loop
await rag.apipeline_process_enqueue_documents(input)

import textract

file_path = 'TEXT.pdf'
text_content = textract.process(file_path)

rag.insert(text_content.decode('utf-8'))

# Define documents and their file paths
documents = ["Document content 1", "Document content 2"]
file_paths = ["path/to/doc1.txt", "path/to/doc2.txt"]

# Insert documents with file paths
rag.insert(documents, file_paths=file_paths)

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.
用于 KG (Knowledge Graph) 存储。 建议在 Docker 中运行 Neo4J 以进行无缝本地测试。
See: https://hub.docker.com/_/neo4j
参见：https://hub.docker.com/_/neo4j

export NEO4J_URI="neo4j://localhost:7687"
export NEO4J_USERNAME="neo4j"
export NEO4J_PASSWORD="password"
export NEO4J_DATABASE="neo4j" #<----------- If you are using community edition neo4j docker image.

# Setup logger for LightRAG
setup_logger("lightrag", level="INFO")

# When you launch the project be sure to override the default KG by specifying graph_storage="Neo4JStorage".
# Initialize LightRAG with Neo4J implementation.
async def initialize_rag():
    rag = LightRAG(
        working_dir=WORKING_DIR,
        llm_model_func=gpt_4o_mini_complete,  # Use gpt_4o_mini_complete LLM model
        graph_storage="Neo4JStorage", #<-----------override KG default
    )

    # Initialize database connections
    await rag.initialize_storages()
    # Initialize pipeline status for document processing
    return rag

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.
PostgreSQL 是轻量级的，包括所有必要插件在内的整个二进制发行版可以压缩到 40MB：参考 Windows 版本，因为它很容易为 Linux/Mac 安装。
If you prefer docker, please start with this image if you are a beginner to avoid hiccups (Default user password:rag/rag): https://hub.docker.com/r/gzdaniel/postgres-for-rag
如果您更喜欢 docker，如果您是初学者，请从该镜像开始，以避免出现问题（默认用户密码：rag/rag）：https://hub.docker.com/r/gzdaniel/postgres-for-rag
How to start? Ref to: examples/lightrag_gemini_postgres_demo.py
如何开始？ 参考：examples/lightrag_gemini_postgres_demo.py
For high-performance graph database requirements, Neo4j is recommended as Apache AGE's performance is not as competitive.
对于高性能图数据库需求，建议使用 Neo4j，因为 Apache AGE 的性能不具竞争力。

Install the required dependencies:
安装所需的依赖项：

pip install faiss-cpu

Here we are using sentence-transformers but you can also use OpenAIEmbedding model with 3072 dimensions.
这里我们使用 sentence-transformers，但您也可以使用具有 3072 维的 OpenAIEmbedding 模型。

async def embedding_func(texts: list[str]) -> np.ndarray:
    model = SentenceTransformer('all-MiniLM-L6-v2')
    embeddings = model.encode(texts, convert_to_numpy=True)
    return embeddings

# Initialize LightRAG with the LLM model function and embedding function
rag = LightRAG(
    working_dir=WORKING_DIR,
    llm_model_func=llm_model_func,
    embedding_func=EmbeddingFunc(
        embedding_dim=384,
        max_token_size=2048,
        model_name="all-MiniLM-L6-v2",
        func=embedding_func,
    ),
    vector_storage="FaissVectorDBStorage",
    vector_db_storage_cls_kwargs={
        "cosine_better_than_threshold": 0.3  # Your desired threshold
    }
)

Memgraph is a high-performance, in-memory graph database compatible with the Neo4j Bolt protocol.
Memgraph 是一个高性能的内存图数据库，与 Neo4j Bolt 协议兼容。
You can run Memgraph locally using Docker for easy testing:
您可以使用 Docker 在本地运行 Memgraph 以进行简单的测试：
See: https://memgraph.com/download
参见：https://memgraph.com/download

export MEMGRAPH_URI="bolt://localhost:7687"

# Setup logger for LightRAG
setup_logger("lightrag", level="INFO")

# When you launch the project, override the default KG: NetworkX
# by specifying kg="MemgraphStorage".

# Note: Default settings use NetworkX
# Initialize LightRAG with Memgraph implementation.
async def initialize_rag():
    rag = LightRAG(
        working_dir=WORKING_DIR,
        llm_model_func=gpt_4o_mini_complete,  # Use gpt_4o_mini_complete LLM model
        graph_storage="MemgraphStorage", #<-----------override KG default
    )

    # Initialize database connections
    await rag.initialize_storages()
    # Initialize pipeline status for document processing
    return rag

AUTOINDEX (default): Milvus automatically selects the best index
AUTOINDEX (默认)：Milvus 自动选择最佳索引
HNSW: Hierarchical Navigable Small World graph for high recall
HNSW (Hierarchical Navigable Small World)：分层可导航小世界图，用于高召回率
HNSW_SQ: HNSW with scalar quantization for memory savings (requires Milvus 2.6.8+)
HNSW_SQ：HNSW 与标量量化，用于节省内存（需要 Milvus 2.6.8+）
HNSW_PQ, HNSW_PRQ: HNSW with product / product-residual quantization
HNSW_PQ, HNSW_PRQ：HNSW 与乘积/乘积残差量化
IVF_FLAT, IVF_SQ8, IVF_PQ: Inverted-file family indexes
IVF_FLAT, IVF_SQ8, IVF_PQ：倒排文件系列索引
DISKANN: Disk-based approximate nearest neighbor
DISKANN：基于磁盘的近似最近邻
SCANN: Scalable nearest neighbor
SCANN：可扩展的最近邻

# Connection
MILVUS_URI=http://localhost:19530
MILVUS_DB_NAME=lightrag
# MILVUS_USER=root
# MILVUS_PASSWORD=your_password
# MILVUS_TOKEN=your_token

# Storage selection
LIGHTRAG_VECTOR_STORAGE=MilvusVectorDBStorage

# Index configuration (all optional — sensible defaults apply)
MILVUS_INDEX_TYPE=HNSW              # Default: AUTOINDEX
MILVUS_METRIC_TYPE=COSINE           # Default: COSINE
MILVUS_HNSW_M=16                    # Default: 16, range [2-2048]
MILVUS_HNSW_EF_CONSTRUCTION=360     # Default: 360
MILVUS_HNSW_EF=200                  # Default: 200

# HNSW_SQ options (requires Milvus 2.6.8+)
# MILVUS_INDEX_TYPE=HNSW_SQ
# MILVUS_HNSW_SQ_TYPE=SQ8           # SQ4U, SQ6, SQ8, BF16, FP16
# MILVUS_HNSW_SQ_REFINE=false       # Enable refinement
# MILVUS_HNSW_SQ_REFINE_TYPE=FP32   # Refinement precision
# MILVUS_HNSW_SQ_REFINE_K=10        # Refinement expansion factor

# IVF options
# MILVUS_IVF_NLIST=1024
# MILVUS_IVF_NPROBE=16

from lightrag import LightRAG

async def initialize_rag():
    rag = LightRAG(
        working_dir="./rag_storage",
        llm_model_func=...,
        embedding_func=...,
        vector_storage="MilvusVectorDBStorage",
    )
    await rag.initialize_storages()
    return rag

from lightrag import LightRAG

async def initialize_rag():
    rag = LightRAG(
        working_dir="./rag_storage",
        llm_model_func=...,
        embedding_func=...,
        vector_storage="MilvusVectorDBStorage",
        vector_db_storage_cls_kwargs={
            "milvus_uri": "http://localhost:19530",
            "milvus_db_name": "lightrag",
            "index_type": "HNSW",
            "metric_type": "COSINE",
            "hnsw_m": 16,
            "hnsw_ef_construction": 360,
            "hnsw_ef": 200,
            "cosine_better_than_threshold": 0.2,
        },
    )
    await rag.initialize_storages()
    return rag

[milvus]
uri = http://localhost:19530
db_name = lightrag
# user = root
# password = your_password
# token = your_token

HNSW_SQ index type requires Milvus 2.6.8 or higher
HNSW_SQ 索引类型需要 Milvus 2.6.8 或更高版本
LightRAG will automatically validate the server version and raise an error if requirements are not met
LightRAG 将自动验证服务器版本，如果不满足要求，则会引发错误
Other index types work with Milvus 2.0+
其他索引类型与 Milvus 2.0+ 兼容

If no index configuration is provided, LightRAG uses AUTOINDEX (Milvus default behavior)
如果未提供索引配置，LightRAG 将使用 AUTOINDEX（Milvus 默认行为）
Existing collections are not affected; index configuration only applies to newly created collections
现有集合不受影响；索引配置仅适用于新创建的集合

save 900 1
save 300 10
save 60 1000
stop-writes-on-bgsave-error yes
maxmemory 4gb
maxmemory-policy noeviction
maxclients 500

# Create new entity
entity = rag.create_entity("Google", {
    "description": "Google is a multinational technology company specializing in internet-related services and products.",
    "entity_type": "company"
})

# Create another entity
product = rag.create_entity("Gmail", {
    "description": "Gmail is an email service developed by Google.",
    "entity_type": "product"
})

# Create relation between entities
relation = rag.create_relation("Google", "Gmail", {
    "description": "Google develops and operates Gmail.",
    "keywords": "develops operates service",
    "weight": 2.0
})

# Edit an existing entity
updated_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 entities
updated_relation = rag.edit_relation("Google", "Google Mail", {
    "description": "Google created and maintains Google Mail service.",
    "keywords": "creates maintains email service",
    "weight": 3.0
})

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

rag.insert_custom_kg(custom_kg)

create_entity: Creates a new entity with specified attributes
create_entity: 创建具有指定属性的新实体
edit_entity: Updates an existing entity's attributes or renames it
edit_entity: 更新现有实体的属性或重命名它
create_relation: Creates a new relation between existing entities
create_relation: 在现有实体之间创建新关系
edit_relation: Updates an existing relation's attributes
edit_relation: 更新现有关系的属性

# Delete entity and all its relationships (synchronous version)
rag.delete_by_entity("Google")

# Asynchronous version
await rag.adelete_by_entity("Google")

Removes the entity node from the knowledge graph
从知识图中删除实体节点
Deletes all associated relationships
删除所有关联关系
Removes related embedding vectors from the vector database
从向量数据库中删除相关嵌入向量
Maintains knowledge graph integrity
维护知识图的完整性

# Delete relationship between two entities (synchronous version)
rag.delete_by_relation("Google", "Gmail")

# Asynchronous version
await rag.adelete_by_relation("Google", "Gmail")

Removes the specified relationship edge
移除指定的关联关系边 (relationship edge)。
Deletes the relationship's embedding vector from the vector database
从向量数据库 (vector database) 中删除关系的嵌入向量 (embedding vector)。
Preserves both entity nodes and their other relationships
保留实体节点 (entity nodes) 及其它关系。

# Delete by document ID (asynchronous version)
await rag.adelete_by_doc_id("doc-12345")

Smart Cleanup: Automatically identifies and removes entities and relationships that belong only to this document
智能清理：自动识别并删除仅属于此文档的实体和关系。
Preserve Shared Knowledge: If entities or relationships exist in other documents, they are preserved and their descriptions are rebuilt
保留共享知识：如果实体或关系存在于其他文档中，则会保留这些实体和关系，并重建其描述。
Cache Optimization: Clears related LLM cache to reduce storage overhead
缓存优化：清除相关的 LLM 缓存，以减少存储开销。
Incremental Rebuilding: Reconstructs affected entity and relationship descriptions from remaining documents
增量重建：从剩余文档中重建受影响的实体和关系描述。

Delete all text chunks related to the document
删除与文档相关的所有文本块 (text chunks)。
Identify and delete entities and relationships that belong only to this document
识别并删除仅属于此文档的实体和关系。
Rebuild entities and relationships that still exist in other documents
重建仍然存在于其他文档中的实体和关系。
Update all related vector indexes
更新所有相关的向量索引 (vector indexes)。
Clean up document status records
清理文档状态记录。

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

# Define custom merge strategy for different fields
rag.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
    }
)

# Specify exact values for the merged entity
rag.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.",
    }
)

# Merge company entities with both strategy and custom data
rag.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",
    }
)

All relationships from source entities are redirected to the target entity
来自源实体 (source entities) 的所有关系都重定向到目标实体 (target entity)。
Duplicate relationships are intelligently merged
重复关系会被智能合并。
Self-relationships (loops) are prevented
避免自关系（循环）。
Source entities are removed after merging
合并后移除源实体。
Relationship weights and attributes are preserved
关系权重和属性得以保留。

Usage

from lightrag.utils import TokenTracker

# Create TokenTracker instance
token_tracker = TokenTracker()

# Method 1: Using context manager (Recommended)
# Suitable for scenarios requiring automatic token usage tracking
with token_tracker:
    result1 = await llm_model_func("your question 1")
    result2 = await llm_model_func("your question 2")

# Method 2: Manually adding token usage records
# Suitable for scenarios requiring more granular control over token statistics
token_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())

Use context managers for long sessions or batch operations to automatically track all token consumption
对于长时间的会话或批量操作，请使用上下文管理器 (context managers) 来自动跟踪所有 token 消耗
For scenarios requiring segmented statistics, use manual mode and call reset() when appropriate
对于需要分段统计的场景，请使用手动模式并在适当的时候调用 reset()
Regular checking of token usage helps detect abnormal consumption early
定期检查 token 使用量有助于尽早发现异常消耗
Actively use this feature during development and testing to optimize production costs
在开发和测试期间积极使用此功能，以优化生产成本

examples/lightrag_gemini_track_token_demo.py: Token tracking example using Google Gemini model
examples/lightrag_gemini_track_token_demo.py：使用 Google Gemini 模型的 token 追踪示例
examples/lightrag_siliconcloud_track_token_demo.py: Token tracking example using SiliconCloud model
examples/lightrag_siliconcloud_track_token_demo.py：使用 SiliconCloud 模型的 token 追踪示例