หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

การใช้งาน GraphRAG ที่เรียบง่ายและง่ายต่อการแฮ็ก

- GraphRAG นั้นดีและทรงพลัง แต่การใช้งานอย่างเป็นทางการนั้นยาก/เจ็บปวดใน การอ่านหรือแฮ็ก

- โปรเจ็กต์นี้มอบ GraphRAG ที่เล็กกว่า เร็วกว่า และสะอาดกว่า ในขณะที่ยังคงฟังก์ชันการทำงานหลักไว้ (ดูเกณฑ์มาตรฐานและปัญหา)

- หากไม่รวม tests และการแจ้งเตือน nano-graphrag จะมี โค้ดประมาณ 1,100 บรรทัด

- ขนาดเล็กแต่ พกพาสะดวก (faiss, neo4j, ollama...) แบบอะซิงโครนัส และพิมพ์เต็มรูปแบบ

ติดตั้ง

ติดตั้งจากแหล่งที่มา (แนะนำ) 

 # clone this repo first
cd nano-graphrag
pip install -e .

ติดตั้งจาก PyPi 

pip install nano-graphrag

เริ่มต้นอย่างรวดเร็ว

เคล็ดลับ

โปรดตั้งค่าคีย์ OpenAI API ในสภาพแวดล้อม: export OPENAI_API_KEY="sk-..."

เคล็ดลับ

หากคุณใช้ Azure OpenAI API โปรดดูที่ .env.example เพื่อตั้งค่า azure openai ของคุณ จากนั้นส่ง GraphRAG(...,using_azure_openai=True,...) เพื่อเปิดใช้งาน

เคล็ดลับ

หากคุณใช้ Amazon Bedrock API โปรดตรวจสอบให้แน่ใจว่าข้อมูลประจำตัวของคุณได้รับการตั้งค่าอย่างถูกต้องผ่านคำสั่ง เช่น aws configure จากนั้นเปิดใช้งานโดยการกำหนดค่าดังนี้: GraphRAG(...,using_amazon_bedrock=True, best_model_id="us.anthropic.claude-3-sonnet-20240229-v1:0", cheap_model_id="us.anthropic.claude-3-haiku-20240307-v1:0",...) . โปรดดูสคริปต์ตัวอย่าง

เคล็ดลับ

หากคุณไม่มีคีย์ใดๆ ลองดูตัวอย่างการใช้ transformers และ ollama หากคุณต้องการใช้ LLM หรือ Embedding Model อื่น ให้ตรวจสอบ Advances

ดาวน์โหลดสำเนา A Christmas Carol โดย Charles Dickens: 

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

ใช้ข้อมูลโค้ดหลามด้านล่าง: 

 from nano_graphrag import GraphRAG , QueryParam

graph_func = GraphRAG ( working_dir = "./dickens" )

with open ( "./book.txt" ) as f :
    graph_func . insert ( f . read ())

# Perform global graphrag search
print ( graph_func . query ( "What are the top themes in this story?" ))

# Perform local graphrag search (I think is better and more scalable one)
print ( graph_func . query ( "What are the top themes in this story?" , param = QueryParam ( mode = "local" )))

ครั้งต่อไปที่คุณเริ่มต้น GraphRAG จาก working_dir เดียวกัน มันจะโหลดบริบททั้งหมดใหม่โดยอัตโนมัติ

การแทรกแบทช์ 

 graph_func . insert ([ "TEXT1" , "TEXT2" ,...])
การแทรกส่วนเพิ่ม

nano-graphrag รองรับการแทรกส่วนเพิ่ม จะไม่มีการคำนวณหรือข้อมูลที่ซ้ำกัน: 

 with open ( "./book.txt" ) as f :
    book = f . read ()
    half_len = len ( book ) // 2
    graph_func . insert ( book [: half_len ])
    graph_func . insert ( book [ half_len :])

nano-graphrag ใช้ md5-hash ของเนื้อหาเป็นคีย์ ดังนั้นจึงไม่มีชิ้นส่วนที่ซ้ำกัน

อย่างไรก็ตาม แต่ละครั้งที่คุณแทรก ชุมชนของกราฟจะถูกคำนวณใหม่และรายงานชุมชนจะถูกสร้างขึ้นใหม่

ไร้เดียงสา RAG

nano-graphrag รองรับการแทรกและการสืบค้น RAG ที่ไร้เดียงสาเช่นกัน: 

 graph_func = GraphRAG ( working_dir = "./dickens" , enable_naive_rag = True )
...
# Query
print ( rag . query (
      "What are the top themes in this story?" ,
      param = QueryParam ( mode = "naive" )
)

อะซิงก์

สำหรับแต่ละวิธี NAME(...) จะมีวิธี async ที่สอดคล้องกัน aNAME(...) 

 await graph_func . ainsert (...)
await graph_func . aquery (...)
...

พารามิเตอร์ที่ใช้ได้

GraphRAG และ QueryParam เป็น dataclass ใน Python ใช้ help(GraphRAG) และ help(QueryParam) เพื่อดูพารามิเตอร์ที่มีทั้งหมด! หรือตรวจสอบส่วนความก้าวหน้าเพื่อดูตัวเลือกบางอย่าง

ส่วนประกอบ

ด้านล่างนี้เป็นส่วนประกอบที่คุณสามารถใช้ได้:

พิมพ์ อะไร ที่ไหน
นิติศาสตร์มหาบัณฑิต OpenAI บิวท์อิน
อเมซอน ข้อเท็จจริง บิวท์อิน
ดีปซีค ตัวอย่าง
ollama ตัวอย่าง
การฝัง OpenAI บิวท์อิน
อเมซอน ข้อเท็จจริง บิวท์อิน
ประโยคหม้อแปลง ตัวอย่าง
ฐานข้อมูลเวกเตอร์ nano-vectordb บิวท์อิน
hnswlib ตัวอย่างในตัว
milvus-lite ตัวอย่าง
ไฟส์ ตัวอย่าง
การจัดเก็บกราฟ networkx บิวท์อิน
neo4j ในตัว(doc)
การแสดงภาพ กราฟมล ตัวอย่าง
ก้อน ตามขนาดโทเค็น บิวท์อิน
โดยตัวแยกข้อความ บิวท์อิน

  • Built-in หมายความว่าเรามีการใช้งานภายใน nano-graphrag examples หมายความว่าเรามีการใช้งานนั้นภายในบทช่วยสอนภายใต้โฟลเดอร์ตัวอย่าง

  • ตรวจสอบตัวอย่าง/เกณฑ์มาตรฐานเพื่อดูการเปรียบเทียบระหว่างส่วนประกอบต่างๆ

  • ยินดีเสมอที่จะสนับสนุนส่วนประกอบเพิ่มเติม

ความก้าวหน้า

ตัวเลือกการตั้งค่าบางอย่าง
  • GraphRAG(...,always_create_working_dir=False,...) จะข้ามขั้นตอนการสร้าง dir ใช้มันหากคุณเปลี่ยนส่วนประกอบทั้งหมดของคุณไปเป็นพื้นที่เก็บข้อมูลที่ไม่ใช่ไฟล์
ค้นหาเฉพาะบริบทที่เกี่ยวข้องเท่านั้น

graph_func.query ส่งคืนคำตอบสุดท้ายโดยไม่ต้องสตรีม

หากคุณต้องการรวม nano-graphrag ในโครงการของคุณ คุณสามารถใช้ param=QueryParam(..., only_need_context=True,...) ซึ่งจะส่งคืนบริบทที่ดึงมาจากกราฟเท่านั้น เช่น: 

 # Local mode
-----Reports-----
```csv
id,	content
0,	# FOX News and Key Figures in Media and Politics...
1, ...
```
...

# Global mode
----Analyst 3----
Importance Score: 100
Donald J. Trump: Frequently discussed in relation to his political activities...
...

คุณสามารถรวมบริบทนั้นเข้ากับพรอมต์ที่คุณกำหนดเองได้

พรอมต์

nano-graphrag ใช้พรอมต์จากวัตถุ dict nano_graphrag.prompt.PROMPTS คุณสามารถเล่นกับมันและแทนที่ข้อความแจ้งภายในได้

คำแนะนำที่สำคัญบางประการ:

  • PROMPTS["entity_extraction"] ใช้เพื่อแยกเอนทิตีและความสัมพันธ์ออกจากกลุ่มข้อความ
  • PROMPTS["community_report"] ใช้เพื่อจัดระเบียบและสรุปคำอธิบายของคลัสเตอร์กราฟ
  • PROMPTS["local_rag_response"] คือเทมเพลตพร้อมท์ของระบบสำหรับการสร้างการค้นหาในท้องถิ่น
  • PROMPTS["global_reduce_rag_response"] คือเทมเพลตข้อความแจ้งของระบบสำหรับการสร้างการค้นหาทั่วโลก
  • PROMPTS["fail_response"] เป็นการตอบกลับทางเลือกเมื่อไม่มีอะไรเกี่ยวข้องกับข้อความค้นหาของผู้ใช้
ปรับแต่ง Chunking

nano-graphrag ช่วยให้คุณสามารถปรับแต่งวิธีการแบ่งส่วนของคุณเองได้ ลองดูตัวอย่าง

เปลี่ยนไปใช้วิธีแบ่งข้อความแบบแยกส่วนในตัว: 

 from nano_graphrag . _op import chunking_by_seperators

GraphRAG (..., chunk_func = chunking_by_seperators ,...)
ฟังก์ชัน LLM

ใน nano-graphrag เราต้องการ LLM สองประเภท คือประเภทที่ดีและราคาถูก แบบแรกใช้เพื่อวางแผนและตอบสนอง แบบหลังใช้เพื่อสรุป โดยค่าเริ่มต้น อันที่ยอดเยี่ยมคือ gpt-4o และอันที่ถูกคือ gpt-4o-mini

คุณสามารถใช้ฟังก์ชัน LLM ของคุณเองได้ (อ้างอิงถึง _llm.gpt_4o_complete ): 

 async def my_llm_complete (
    prompt , system_prompt = None , history_messages = [], ** kwargs
) -> str :
  # pop cache KV database if any
  hashing_kv : BaseKVStorage = kwargs . pop ( "hashing_kv" , None )
  # the rest kwargs are for calling LLM, for example, `max_tokens=xxx`
	...
  # YOUR LLM calling
  response = await call_your_LLM ( messages , ** kwargs )
  return response

แทนที่ค่าเริ่มต้นด้วย: 

 # Adjust the max token size or the max async requests if needed
GraphRAG ( best_model_func = my_llm_complete , best_model_max_token_size = ..., best_model_max_async = ...)
GraphRAG ( cheap_model_func = my_llm_complete , cheap_model_max_token_size = ..., cheap_model_max_async = ...)

คุณสามารถอ้างอิงถึงตัวอย่างนี้ที่ใช้ deepseek-chat เป็นโมเดล LLM

คุณสามารถอ้างอิงถึงตัวอย่างนี้ที่ใช้ ollama เป็นแบบจำลอง LLM

เอาต์พุต Json

nano-graphrag จะใช้ best_model_func เพื่อส่งออก JSON ด้วยพารามิเตอร์ "response_format": {"type": "json_object"} อย่างไรก็ตาม มีโมเดลโอเพ่นซอร์สบางรุ่นที่อาจสร้าง JSON ที่ไม่เสถียร

nano-graphrag แนะนำอินเทอร์เฟซหลังกระบวนการเพื่อให้คุณแปลงการตอบกลับเป็น JSON ลายเซ็นของ func นี้อยู่ด้านล่าง: 

 def YOUR_STRING_TO_JSON_FUNC ( response : str ) -> dict :
  "Convert the string response to JSON"
  ...

และส่ง func ของคุณเองโดย GraphRAG(...convert_response_to_json_func=YOUR_STRING_TO_JSON_FUNC,...)

ตัวอย่างเช่น คุณสามารถอ้างถึง json_repair เพื่อซ่อมแซมสตริง JSON ที่ส่งคืนโดย LLM

ฟังก์ชั่นการฝัง

คุณสามารถแทนที่ฟังก์ชันการฝังเริ่มต้นด้วยอินสแตนซ์ _utils.EmbedddingFunc ใดก็ได้

ตัวอย่างเช่น ค่าเริ่มต้นคือการใช้ API การฝัง OpenAI: 

 @ wrap_embedding_func_with_attrs ( embedding_dim = 1536 , max_token_size = 8192 )
async def openai_embedding ( texts : list [ str ]) -> np . ndarray :
    openai_async_client = AsyncOpenAI ()
    response = await openai_async_client . embeddings . create (
        model = "text-embedding-3-small" , input = texts , encoding_format = "float"
    )
    return np . array ([ dp . embedding for dp in response . data ])

แทนที่ฟังก์ชันการฝังเริ่มต้นด้วย: 

 GraphRAG ( embedding_func = your_embed_func , embedding_batch_num = ..., embedding_func_max_async = ...)

คุณสามารถอ้างถึงตัวอย่างที่ใช้ sentence-transformer เพื่อคำนวณการฝังในเครื่อง

ส่วนประกอบการจัดเก็บข้อมูล

คุณสามารถแทนที่ส่วนประกอบที่เกี่ยวข้องกับการจัดเก็บข้อมูลทั้งหมดเป็นการใช้งานของคุณเองได้ โดยส่วนใหญ่แล้ว nano-graphrag จะใช้พื้นที่เก็บข้อมูลสามประเภท:

base.BaseKVStorage สำหรับจัดเก็บข้อมูลคู่คีย์-json

  • ตามค่าเริ่มต้น เราใช้พื้นที่จัดเก็บไฟล์ดิสก์เป็นแบ็กเอนด์
  • GraphRAG(.., key_string_value_json_storage_cls=YOURS,...)

base.BaseVectorStorage สำหรับการจัดทำดัชนีการฝัง

  • ตามค่าเริ่มต้น เราใช้ nano-vectordb เป็นแบ็กเอนด์
  • เรามีที่เก็บข้อมูล hnswlib ในตัว ลองดูตัวอย่างนี้
  • ลองดูตัวอย่างนี้ที่ใช้ milvus-lite เป็นแบ็กเอนด์ (ไม่มีใน Windows)
  • GraphRAG(.., vector_db_storage_cls=YOURS,...)

base.BaseGraphStorage สำหรับจัดเก็บกราฟความรู้

  • โดยค่าเริ่มต้น เราใช้ networkx เป็นแบ็กเอนด์
  • เรามี Neo4jStorage ในตัวสำหรับกราฟ ลองดูบทช่วยสอนนี้
  • GraphRAG(.., graph_storage_cls=YOURS,...)

คุณสามารถอ้างถึง nano_graphrag.base เพื่อดูรายละเอียดอินเทอร์เฟซสำหรับแต่ละส่วนประกอบ

คำถามที่พบบ่อย

ตรวจสอบ FQA

แผนการทำงาน

ดู ROADMAP.md

มีส่วนช่วย

nano-graphrag เปิดรับการสนับสนุนทุกประเภท อ่านสิ่งนี้ก่อนที่คุณจะมีส่วนร่วม

เกณฑ์มาตรฐาน

  • เกณฑ์มาตรฐานสำหรับภาษาอังกฤษ
  • มาตรฐานสำหรับชาวจีน
  • สมุดบันทึกการประเมินผลงาน RAG แบบมัลติฮอป

โครงการที่ใช้ nano-graphrag

  • กราฟทางการแพทย์ RAG: กราฟ RAG สำหรับข้อมูลทางการแพทย์
  • LightRAG: การสร้างแบบเสริมการเรียกค้นที่ง่ายและรวดเร็ว
  • fast-graphrag: RAG ที่ปรับให้เข้ากับกรณีการใช้งาน ข้อมูล และการสืบค้นของคุณอย่างชาญฉลาด

ยินดีต้อนรับสู่การดึงคำขอหากโครงการของคุณใช้ nano-graphrag มันจะช่วยให้ผู้อื่นเชื่อถือ repo นี้❤️

ปัญหา

  • nano-graphrag ไม่ได้ใช้คุณสมบัติ covariates ของ GraphRAG
  • nano-graphrag ใช้การค้นหาทั่วโลกที่แตกต่างจากต้นฉบับ ต้นฉบับใช้สไตล์เหมือนการลดแผนที่เพื่อเติมเต็มชุมชนทั้งหมดให้อยู่ในบริบท ในขณะที่ nano-graphrag ใช้เฉพาะชุมชนที่สำคัญและเป็นศูนย์กลางระดับบนสุดของ K เท่านั้น (ใช้ QueryParam.global_max_consider_community เพื่อควบคุม โดยค่าเริ่มต้นคือ 512 ชุมชน)
ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด