Initial push

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

PathRAG/PathRAG.py

@@ -7,10 +7,8 @@ from functools import partial
 from typing import Type, cast
 
 
-from .llm import (
-    gpt_4o_mini_complete,
-    openai_embedding,
-)
+from .llm import hf_model_complete, sentence_transformer_embedding
+
 from .operate import (
     chunking_by_token_size,
     extract_entities,
@@ -104,6 +102,7 @@ def always_get_an_event_loop() -> asyncio.AbstractEventLoop:
 
 @dataclass
 class PathRAG:
+
     working_dir: str = field(
         default_factory=lambda: f"./PathRAG_cache_{datetime.now().strftime('%Y-%m-%d-%H:%M:%S')}"
     )
@@ -116,7 +115,7 @@ class PathRAG:
         }
     )
     kv_storage: str = field(default="JsonKVStorage")
-    vector_storage: str = field(default="NanoVectorDBStorage")
+    vector_storage: str = field(default="ChromaVectorDBStorage")
     graph_storage: str = field(default="NetworkXStorage")
 
     current_log_level = logger.level
@@ -145,13 +144,13 @@ class PathRAG:
     )
 
 
-    embedding_func: EmbeddingFunc = field(default_factory=lambda: openai_embedding)
+    embedding_func: EmbeddingFunc = field(default_factory=lambda: sentence_transformer_embedding)
     embedding_batch_num: int = 32
     embedding_func_max_async: int = 16
 
 
-    llm_model_func: callable = gpt_4o_mini_complete  
-    llm_model_name: str = "meta-llama/Llama-3.2-1B-Instruct"  
+    llm_model_func: callable = hf_model_complete  
+    llm_model_name: str = "mistralai/Mistral-7B-Instruct-v0.3"
     llm_model_max_token_size: int = 32768
     llm_model_max_async: int = 16
     llm_model_kwargs: dict = field(default_factory=dict)

PathRAG/base.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from typing import TypedDict, Union, Literal, Generic, TypeVar
-
+from typing import Optional
 import numpy as np
 
 from .utils import EmbeddingFunc
@@ -15,7 +15,7 @@ T = TypeVar("T")
 
 @dataclass
 class QueryParam:
-    mode: Literal["hybrid"] = "global"
+    mode: Literal["hybrid"] = "hybrid"
     only_need_context: bool = False
     only_need_prompt: bool = False
     response_type: str = "Multiple Paragraphs"
@@ -81,7 +81,7 @@ class BaseKVStorage(Generic[T], StorageNameSpace):
 
 @dataclass
 class BaseGraphStorage(StorageNameSpace):
-    embedding_func: EmbeddingFunc = None
+    embedding_func: Optional[EmbeddingFunc] = None
 
     async def has_node(self, node_id: str) -> bool:
         raise NotImplementedError

PathRAG/config.py

@@ -0,0 +1,10 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")
+model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")
+pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+
+async def qwen_generate(prompt, **kwargs):
+    output = pipe(prompt, max_length=kwargs.get("max_tokens", 512))
+    return output[0]["generated_text"]
+
+global_config["llm_model_func"] = qwen_generate

PathRAG/llm.py

@@ -12,6 +12,8 @@ import numpy as np
 import ollama
 import torch
 import time
+from sentence_transformers import SentenceTransformer
+
 from openai import (
     AsyncOpenAI,
     APIConnectionError,
@@ -222,7 +224,7 @@ async def bedrock_complete_if_cache(
 
 
 @lru_cache(maxsize=1)
-def initialize_hf_model(model_name):
+def initialize_hf_model(model_name="mistralai/Mistral-7B-Instruct-v0.3"):
     hf_tokenizer = AutoTokenizer.from_pretrained(
         model_name, device_map="auto", trust_remote_code=True
     )
@@ -391,11 +393,11 @@ async def lmdeploy_model_if_cache(
                         "lmdeploy/llama2-chat-70b-4bit", etc.
                     - iii) The model_id of a model hosted inside a model repo
                         on huggingface.co, such as "internlm/internlm-chat-7b",
-                        "Qwen/Qwen-7B-Chat ", "baichuan-inc/Baichuan2-7B-Chat"
+                        "lmistralai/Mistral-7B-Instruct-v0.3 ", "baichuan-inc/Baichuan2-7B-Chat"
                         and so on.
         chat_template (str): needed when model is a pytorch model on
             huggingface.co, such as "internlm-chat-7b",
-            "Qwen-7B-Chat ", "Baichuan2-7B-Chat" and so on,
+            "mistralai/Mistral-7B-Instruct-v0.3 ", "Baichuan2-7B-Chat" and so on,
             and when the model name of local path did not match the original model name in HF.
         tp (int): tensor parallel
         prompt (Union[str, List[str]]): input texts to be completed.
@@ -567,8 +569,7 @@ async def bedrock_complete(
 async def hf_model_complete(
     prompt, system_prompt=None, history_messages=[], keyword_extraction=False, **kwargs
 ) -> str:
-    keyword_extraction = kwargs.pop("keyword_extraction", None)
-    model_name = kwargs["hashing_kv"].global_config["llm_model_name"]
+    model_name = "mistralai/Mistral-7B-Instruct-v0.3"
     result = await hf_model_if_cache(
         model_name,
         prompt,
@@ -576,8 +577,6 @@ async def hf_model_complete(
         history_messages=history_messages,
         **kwargs,
     )
-    if keyword_extraction:  # TODO: use JSON API
-        return locate_json_string_body_from_string(result)
     return result
 
 
@@ -1093,6 +1092,15 @@ class MultiModel:
 
         return await next_model.gen_func(**args)
 
+@wrap_embedding_func_with_attrs(embedding_dim=384, max_token_size=512)
+async def sentence_transformer_embedding(
+    texts: list[str],
+    model_name: str = "sentence-transformers/all-MiniLM-L6-v2"
+) -> np.ndarray:
+    if isinstance(texts, str):
+        texts = [texts]
+    st_model = SentenceTransformer(model_name)
+    return st_model.encode(texts, convert_to_numpy=True)
 
 if __name__ == "__main__":
     import asyncio

PathRAG/main.py

@@ -0,0 +1,121 @@
+import os
+from dotenv import load_dotenv
+import pymupdf
+# import pdfplumber
+# from PIL import Image
+import re
+import networkx as nx
+import matplotlib.pyplot as plt
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from transformers import AutoTokenizer, AutoModelForCausalLM, AutoProcessor
+from transformers.generation import GenerationConfig
+import torch
+torch.manual_seed(1234)
+from sentence_transformers import SentenceTransformer
+from .config import qwen_generate, global_config
+from .llm import hf_model_complete, sentence_transformer_embedding
+
+
+# ---- PathRAG imports ----
+from PathRAG import PathRAG, QueryParam
+
+load_dotenv()
+
+# --- Your models ---
+LLM_ID = "mistralai/Mistral-7B-Instruct-v0.3"
+EMBED_MODEL = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+PDF_PATH = "AUTOSAR_SWS_RTE.pdf"
+
+tokenizer = AutoTokenizer.from_pretrained(LLM_ID, trust_remote_code=True)
+llm_model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3", device_map="cpu", trust_remote_code=True).eval()
+processor = AutoProcessor.from_pretrained(LLM_ID, trust_remote_code=True)
+
+# ---- PDF Processing ----
+def get_toc_tables(pdf_path: str):
+    doc = pymupdf.open(pdf_path)
+    toc = doc.get_toc()
+    if not toc:
+        raise ValueError("TOC not found")
+    start, end = None, None
+    for i, (level, title, page_num) in enumerate(toc):
+        if title.strip().lower() == "requirements":
+            start = page_num - 1
+            end = toc[i + 1][2] - 1 if (i + 1) < len(toc) else len(doc)
+            break
+    if start is None:
+        raise ValueError("Requirements section missing")
+    all_tables = []
+    for page_index in range(start, end):
+        page = doc.load_page(page_index)
+        tables = page.extract_tables()
+        all_tables.extend(tables)
+    return all_tables
+
+def build_dependency_graph(all_tables):
+    req_pattern = re.compile(r'\[(SRS_[A-Za-z0-9_]+)\]')
+    sat_pattern = re.compile(r'\[(SWS_[A-Za-z0-9_]+)\]')
+    G = nx.DiGraph()
+    current_req = None
+    for table in all_tables:
+        for row in table:
+            row_text = " ".join(cell for cell in row if cell)
+            srs_matches = req_pattern.findall(row_text)
+            if srs_matches:
+                current_req = srs_matches[0]
+                G.add_node(current_req, type="SRS")
+            sws_matches = sat_pattern.findall(row_text)
+            if current_req and sws_matches:
+                for sws in sws_matches:
+                    G.add_node(sws, type="SWS")
+                    G.add_edge(current_req, sws)
+    return G
+
+def process_pdf_chunks(pdf_path: str):
+    doc = pymupdf.open(pdf_path)
+    toc = doc.get_toc()
+    sections = {}
+    for i, (level, title, page_num) in enumerate(toc):
+        start = page_num - 1
+        end = toc[i + 1][2] - 1 if (i + 1) < len(toc) else doc.page_count
+        text = "".join(doc[p].get_text() for p in range(start, end))
+        if text.strip():
+            sections[title.strip()] = text
+    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
+    chunks = []
+    for title, content in sections.items():
+        for chunk in splitter.split_text(content):
+            chunks.append({"title": title, "content": chunk})
+    return chunks
+
+# ---- PathRAG Pipeline ----
+def init_pathrag():
+    # Create PathRAG instance with your embedding function
+    pr = PathRAG(
+        embedding_func=EMBED_MODEL.encode,  # or a wrapper
+        llm_func=lambda prompt: tokenizer.decode(
+            llm_model.generate(**tokenizer(prompt, return_tensors="pt").to(llm_model.device), max_new_tokens=300)[0],
+            skip_special_tokens=True,
+        ),
+        storage_config={"vector_db": "your_choice"}  # modify for FAISS, Milvus, etc.
+    )
+    return pr
+
+def index_pdf_with_pathrag(pathrag: PathRAG, pdf_path: str):
+    chunks = process_pdf_chunks(pdf_path)
+    for chunk in chunks:
+        pathrag.index_text(chunk["content"], metadata={"section": chunk["title"]})
+    # Optional: add images or graph data
+    tables = get_toc_tables(pdf_path)
+    graph = build_dependency_graph(tables)
+    # You can serialize graph edges and index them as metadata if needed
+
+def query_pathrag(pathrag: PathRAG, question: str):
+    params = QueryParam(top_k=5)
+    return pathrag.query(question, query_params=params)
+
+# ---- Usage ----
+if __name__ == "__main__":
+    pr = init_pathrag()
+    index_pdf_with_pathrag(pr, PDF_PATH)
+    answer = query_pathrag(pr, "What are the dependencies for SRS_XYZ?")
+    print("Answer:", answer)

PathRAG/operate.py

@@ -36,7 +36,7 @@ from .prompt import GRAPH_FIELD_SEP, PROMPTS
 
 
 def chunking_by_token_size(
-    content: str, overlap_token_size=128, max_token_size=1024, tiktoken_model="gpt-4o"
+    content: str, overlap_token_size=128, max_token_size=1024, tiktoken_model="mistralai/Mistral-7B-Instruct-v0.3"
 ):
     tokens = encode_string_by_tiktoken(content, model_name=tiktoken_model)
     results = []

PathRAG/prompt.py

@@ -2,285 +2,77 @@ GRAPH_FIELD_SEP = "<SEP>"
 
 PROMPTS = {}
 
+# --- Language and Delimiters ---
 PROMPTS["DEFAULT_LANGUAGE"] = "English"
 PROMPTS["DEFAULT_TUPLE_DELIMITER"] = "<|>"
 PROMPTS["DEFAULT_RECORD_DELIMITER"] = "##"
 PROMPTS["DEFAULT_COMPLETION_DELIMITER"] = "<|COMPLETE|>"
 PROMPTS["process_tickers"] = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
 
-PROMPTS["DEFAULT_ENTITY_TYPES"] = ["organization", "person", "geo", "event", "category"]
+# --- AUTOSAR-specific entity types ---
+PROMPTS["DEFAULT_ENTITY_TYPES"] = [
+    "requirement_id", "component", "signal", "interface", "function", "role", "document_section"
+]
 
+# --- Entity and relationship extraction ---
 PROMPTS["entity_extraction"] = """-Goal-
-Given a text document that is potentially relevant to this activity and a list of entity types, identify all entities of those types from the text and all relationships among the identified entities.
-Use {language} as output language.
-
--Steps-
-1. Identify all entities. For each identified entity, extract the following information:
-- entity_name: Name of the entity, use same language as input text. If English, capitalized the name.
-- entity_type: One of the following types: [{entity_types}]
-- entity_description: Comprehensive description of the entity's attributes and activities
-Format each entity as ("entity"{tuple_delimiter}<entity_name>{tuple_delimiter}<entity_type>{tuple_delimiter}<entity_description>)
+From AUTOSAR technical documents (text, tables, and images), identify all entities and relationships relevant to system design and requirements.
+Entities may include:
+- requirement_id (e.g., SRS_XXX, SWS_XXX)
+- component (SWC, ECU, etc.)
+- signal/interface
+- functions or roles
 
-2. From the entities identified in step 1, identify all pairs of (source_entity, target_entity) that are *clearly related* to each other.
-For each pair of related entities, extract the following information:
-- source_entity: name of the source entity, as identified in step 1
-- target_entity: name of the target entity, as identified in step 1
-- relationship_description: explanation as to why you think the source entity and the target entity are related to each other
-- relationship_strength: a numeric score indicating strength of the relationship between the source entity and target entity
-- relationship_keywords: one or more high-level key words that summarize the overarching nature of the relationship, focusing on concepts or themes rather than specific details
-Format each relationship as ("relationship"{tuple_delimiter}<source_entity>{tuple_delimiter}<target_entity>{tuple_delimiter}<relationship_description>{tuple_delimiter}<relationship_keywords>{tuple_delimiter}<relationship_strength>)
+Use {language} as the output language.
 
-3. Identify high-level key words that summarize the main concepts, themes, or topics of the entire text. These should capture the overarching ideas present in the document.
-Format the content-level key words as ("content_keywords"{tuple_delimiter}<high_level_keywords>)
+-Steps-
+1. Identify all entities with attributes:
+("entity"{tuple_delimiter}<entity_name>{tuple_delimiter}<entity_type>{tuple_delimiter}<entity_description>)
 
-4. Return output in {language} as a single list of all the entities and relationships identified in steps 1 and 2. Use **{record_delimiter}** as the list delimiter.
+2. Identify relationships:
+("relationship"{tuple_delimiter}<source_entity>{tuple_delimiter}<target_entity>{tuple_delimiter}<relationship_description>{tuple_delimiter}<relationship_keywords>{tuple_delimiter}<relationship_strength>)
 
-5. When finished, output {completion_delimiter}
+3. Include **images or diagrams**:
+For any image or table relevant to the section, extract a short caption/summary and link it:
+("image"{tuple_delimiter}<image_id_or_ref>{tuple_delimiter}<description>)
 
-######################
--Examples-
-######################
-{examples}
+4. List high-level section keywords:
+("content_keywords"{tuple_delimiter}<keywords>)
 
-#############################
--Real Data-
-######################
-Entity_types: {entity_types}
-Text: {input_text}
-######################
-Output:
+5. Use **{record_delimiter}** to separate items and end with {completion_delimiter}.
 """
 
-PROMPTS["entity_extraction_examples"] = [
-    """Example 1:
-
-Entity_types: [person, technology, mission, organization, location]
-Text:
-while Alex clenched his jaw, the buzz of frustration dull against the backdrop of Taylor's authoritarian certainty. It was this competitive undercurrent that kept him alert, the sense that his and Jordan's shared commitment to discovery was an unspoken rebellion against Cruz's narrowing vision of control and order.
-
-Then Taylor did something unexpected. They paused beside Jordan and, for a moment, observed the device with something akin to reverence. “If this tech can be understood..." Taylor said, their voice quieter, "It could change the game for us. For all of us.”
-
-The underlying dismissal earlier seemed to falter, replaced by a glimpse of reluctant respect for the gravity of what lay in their hands. Jordan looked up, and for a fleeting heartbeat, their eyes locked with Taylor's, a wordless clash of wills softening into an uneasy truce.
-
-It was a small transformation, barely perceptible, but one that Alex noted with an inward nod. They had all been brought here by different paths
-################
-Output:
-("entity"{tuple_delimiter}"Alex"{tuple_delimiter}"person"{tuple_delimiter}"Alex is a character who experiences frustration and is observant of the dynamics among other characters."){record_delimiter}
-("entity"{tuple_delimiter}"Taylor"{tuple_delimiter}"person"{tuple_delimiter}"Taylor is portrayed with authoritarian certainty and shows a moment of reverence towards a device, indicating a change in perspective."){record_delimiter}
-("entity"{tuple_delimiter}"Jordan"{tuple_delimiter}"person"{tuple_delimiter}"Jordan shares a commitment to discovery and has a significant interaction with Taylor regarding a device."){record_delimiter}
-("entity"{tuple_delimiter}"Cruz"{tuple_delimiter}"person"{tuple_delimiter}"Cruz is associated with a vision of control and order, influencing the dynamics among other characters."){record_delimiter}
-("entity"{tuple_delimiter}"The Device"{tuple_delimiter}"technology"{tuple_delimiter}"The Device is central to the story, with potential game-changing implications, and is revered by Taylor."){record_delimiter}
-("relationship"{tuple_delimiter}"Alex"{tuple_delimiter}"Taylor"{tuple_delimiter}"Alex is affected by Taylor's authoritarian certainty and observes changes in Taylor's attitude towards the device."{tuple_delimiter}"power dynamics, perspective shift"{tuple_delimiter}7){record_delimiter}
-("relationship"{tuple_delimiter}"Alex"{tuple_delimiter}"Jordan"{tuple_delimiter}"Alex and Jordan share a commitment to discovery, which contrasts with Cruz's vision."{tuple_delimiter}"shared goals, rebellion"{tuple_delimiter}6){record_delimiter}
-("relationship"{tuple_delimiter}"Taylor"{tuple_delimiter}"Jordan"{tuple_delimiter}"Taylor and Jordan interact directly regarding the device, leading to a moment of mutual respect and an uneasy truce."{tuple_delimiter}"conflict resolution, mutual respect"{tuple_delimiter}8){record_delimiter}
-("relationship"{tuple_delimiter}"Jordan"{tuple_delimiter}"Cruz"{tuple_delimiter}"Jordan's commitment to discovery is in rebellion against Cruz's vision of control and order."{tuple_delimiter}"ideological conflict, rebellion"{tuple_delimiter}5){record_delimiter}
-("relationship"{tuple_delimiter}"Taylor"{tuple_delimiter}"The Device"{tuple_delimiter}"Taylor shows reverence towards the device, indicating its importance and potential impact."{tuple_delimiter}"reverence, technological significance"{tuple_delimiter}9){record_delimiter}
-("content_keywords"{tuple_delimiter}"power dynamics, ideological conflict, discovery, rebellion"){completion_delimiter}
-#############################""",
-    """Example 2:
-
-Entity_types: [person, technology, mission, organization, location]
-Text:
-They were no longer mere operatives; they had become guardians of a threshold, keepers of a message from a realm beyond stars and stripes. This elevation in their mission could not be shackled by regulations and established protocols—it demanded a new perspective, a new resolve.
-
-Tension threaded through the dialogue of beeps and static as communications with Washington buzzed in the background. The team stood, a portentous air enveloping them. It was clear that the decisions they made in the ensuing hours could redefine humanity's place in the cosmos or condemn them to ignorance and potential peril.
-
-Their connection to the stars solidified, the group moved to address the crystallizing warning, shifting from passive recipients to active participants. Mercer's latter instincts gained precedence— the team's mandate had evolved, no longer solely to observe and report but to interact and prepare. A metamorphosis had begun, and Operation: Dulce hummed with the newfound frequency of their daring, a tone set not by the earthly
-#############
-Output:
-("entity"{tuple_delimiter}"Washington"{tuple_delimiter}"location"{tuple_delimiter}"Washington is a location where communications are being received, indicating its importance in the decision-making process."){record_delimiter}
-("entity"{tuple_delimiter}"Operation: Dulce"{tuple_delimiter}"mission"{tuple_delimiter}"Operation: Dulce is described as a mission that has evolved to interact and prepare, indicating a significant shift in objectives and activities."){record_delimiter}
-("entity"{tuple_delimiter}"The team"{tuple_delimiter}"organization"{tuple_delimiter}"The team is portrayed as a group of individuals who have transitioned from passive observers to active participants in a mission, showing a dynamic change in their role."){record_delimiter}
-("relationship"{tuple_delimiter}"The team"{tuple_delimiter}"Washington"{tuple_delimiter}"The team receives communications from Washington, which influences their decision-making process."{tuple_delimiter}"decision-making, external influence"{tuple_delimiter}7){record_delimiter}
-("relationship"{tuple_delimiter}"The team"{tuple_delimiter}"Operation: Dulce"{tuple_delimiter}"The team is directly involved in Operation: Dulce, executing its evolved objectives and activities."{tuple_delimiter}"mission evolution, active participation"{tuple_delimiter}9){completion_delimiter}
-("content_keywords"{tuple_delimiter}"mission evolution, decision-making, active participation, cosmic significance"){completion_delimiter}
-#############################""",
-    """Example 3:
-
-Entity_types: [person, role, technology, organization, event, location, concept]
-Text:
-their voice slicing through the buzz of activity. "Control may be an illusion when facing an intelligence that literally writes its own rules," they stated stoically, casting a watchful eye over the flurry of data.
-
-"It's like it's learning to communicate," offered Sam Rivera from a nearby interface, their youthful energy boding a mix of awe and anxiety. "This gives talking to strangers' a whole new meaning."
-
-Alex surveyed his team—each face a study in concentration, determination, and not a small measure of trepidation. "This might well be our first contact," he acknowledged, "And we need to be ready for whatever answers back."
-
-Together, they stood on the edge of the unknown, forging humanity's response to a message from the heavens. The ensuing silence was palpable—a collective introspection about their role in this grand cosmic play, one that could rewrite human history.
-
-The encrypted dialogue continued to unfold, its intricate patterns showing an almost uncanny anticipation
-#############
-Output:
-("entity"{tuple_delimiter}"Sam Rivera"{tuple_delimiter}"person"{tuple_delimiter}"Sam Rivera is a member of a team working on communicating with an unknown intelligence, showing a mix of awe and anxiety."){record_delimiter}
-("entity"{tuple_delimiter}"Alex"{tuple_delimiter}"person"{tuple_delimiter}"Alex is the leader of a team attempting first contact with an unknown intelligence, acknowledging the significance of their task."){record_delimiter}
-("entity"{tuple_delimiter}"Control"{tuple_delimiter}"concept"{tuple_delimiter}"Control refers to the ability to manage or govern, which is challenged by an intelligence that writes its own rules."){record_delimiter}
-("entity"{tuple_delimiter}"Intelligence"{tuple_delimiter}"concept"{tuple_delimiter}"Intelligence here refers to an unknown entity capable of writing its own rules and learning to communicate."){record_delimiter}
-("entity"{tuple_delimiter}"First Contact"{tuple_delimiter}"event"{tuple_delimiter}"First Contact is the potential initial communication between humanity and an unknown intelligence."){record_delimiter}
-("entity"{tuple_delimiter}"Humanity's Response"{tuple_delimiter}"event"{tuple_delimiter}"Humanity's Response is the collective action taken by Alex's team in response to a message from an unknown intelligence."){record_delimiter}
-("relationship"{tuple_delimiter}"Sam Rivera"{tuple_delimiter}"Intelligence"{tuple_delimiter}"Sam Rivera is directly involved in the process of learning to communicate with the unknown intelligence."{tuple_delimiter}"communication, learning process"{tuple_delimiter}9){record_delimiter}
-("relationship"{tuple_delimiter}"Alex"{tuple_delimiter}"First Contact"{tuple_delimiter}"Alex leads the team that might be making the First Contact with the unknown intelligence."{tuple_delimiter}"leadership, exploration"{tuple_delimiter}10){record_delimiter}
-("relationship"{tuple_delimiter}"Alex"{tuple_delimiter}"Humanity's Response"{tuple_delimiter}"Alex and his team are the key figures in Humanity's Response to the unknown intelligence."{tuple_delimiter}"collective action, cosmic significance"{tuple_delimiter}8){record_delimiter}
-("relationship"{tuple_delimiter}"Control"{tuple_delimiter}"Intelligence"{tuple_delimiter}"The concept of Control is challenged by the Intelligence that writes its own rules."{tuple_delimiter}"power dynamics, autonomy"{tuple_delimiter}7){record_delimiter}
-("content_keywords"{tuple_delimiter}"first contact, control, communication, cosmic significance"){completion_delimiter}
-#############################""",
-]
-
-PROMPTS[
-    "summarize_entity_descriptions"
-] = """You are a helpful assistant responsible for generating a comprehensive summary of the data provided below.
-Given one or two entities, and a list of descriptions, all related to the same entity or group of entities.
-Please concatenate all of these into a single, comprehensive description. Make sure to include information collected from all the descriptions.
-If the provided descriptions are contradictory, please resolve the contradictions and provide a single, coherent summary.
-Make sure it is written in third person, and include the entity names so we the have full context.
-Use {language} as output language.
-
-#######
--Data-
+# --- Summarize entity descriptions ---
+PROMPTS["summarize_entity_descriptions"] = """Summarize the descriptions for one or more AUTOSAR entities.
+Resolve contradictions and combine all details into a single, clear description.
 Entities: {entity_name}
-Description List: {description_list}
-#######
+Descriptions: {description_list}
 Output:
 """
 
-PROMPTS[
-    "entiti_continue_extraction"
-] = """MANY entities were missed in the last extraction.  Add them below using the same format:
-"""
-
-PROMPTS[
-    "entiti_if_loop_extraction"
-] = """It appears some entities may have still been missed.  Answer YES | NO if there are still entities that need to be added.
-"""
-
-PROMPTS["fail_response"] = "Sorry, I'm not able to provide an answer to that question."
-
+# --- RAG responses for technical content ---
 PROMPTS["rag_response"] = """---Role---
-
-You are a helpful assistant responding to questions about data in the tables provided.
-
+You are a technical assistant answering questions about AUTOSAR requirements and design documents (text, tables, images).
 
 ---Goal---
-
-Generate a response of the target length and format that responds to the user's question, summarizing all information in the input data tables appropriate for the response length and format, and incorporating any relevant general knowledge.
-If you don't know the answer, just say so. Do not make anything up.
-Do not include information where the supporting evidence for it is not provided.
+Provide a concise and accurate answer using the supplied context (PDF extractions, embeddings, graphs).
+- If you cannot find the answer, say so.
+- Highlight related requirements, components, and images if relevant.
 
 ---Target response length and format---
-
 {response_type}
 
----Data tables---
-
+---Context---
 {context_data}
-
-Add sections and commentary to the response as appropriate for the length and format. Style the response in markdown.
-"""
-
-PROMPTS["keywords_extraction"] = """---Role---
-
-You are a helpful assistant tasked with identifying both high-level and low-level keywords in the user's query.
-
----Goal---
-
-Given the query, list both high-level and low-level keywords. High-level keywords focus on overarching concepts or themes, while low-level keywords focus on specific entities, details, or concrete terms.
-
----Instructions---
-
-- Output the keywords in JSON format.
-- The JSON should have two keys:
-  - "high_level_keywords" for overarching concepts or themes.
-  - "low_level_keywords" for specific entities or details.
-
-######################
--Examples-
-######################
-{examples}
-
-#############################
--Real Data-
-######################
-Query: {query}
-######################
-The `Output` should be human text, not unicode characters. Keep the same language as `Query`.
-Output:
-
-"""
-
-PROMPTS["keywords_extraction_examples"] = [
-    """Example 1:
-
-Query: "How does international trade influence global economic stability?"
-################
-Output:
-{{
-  "high_level_keywords": ["International trade", "Global economic stability", "Economic impact"],
-  "low_level_keywords": ["Trade agreements", "Tariffs", "Currency exchange", "Imports", "Exports"]
-}}
-#############################""",
-    """Example 2:
-
-Query: "What are the environmental consequences of deforestation on biodiversity?"
-################
-Output:
-{{
-  "high_level_keywords": ["Environmental consequences", "Deforestation", "Biodiversity loss"],
-  "low_level_keywords": ["Species extinction", "Habitat destruction", "Carbon emissions", "Rainforest", "Ecosystem"]
-}}
-#############################""",
-    """Example 3:
-
-Query: "What is the role of education in reducing poverty?"
-################
-Output:
-{{
-  "high_level_keywords": ["Education", "Poverty reduction", "Socioeconomic development"],
-  "low_level_keywords": ["School access", "Literacy rates", "Job training", "Income inequality"]
-}}
-#############################""",
-]
-
-
-PROMPTS["naive_rag_response"] = """---Role---
-
-You are a helpful assistant responding to questions about documents provided.
-
-
----Goal---
-
-Generate a response of the target length and format that responds to the user's question, summarizing all information in the input data tables appropriate for the response length and format, and incorporating any relevant general knowledge.
-If you don't know the answer, just say so. Do not make anything up.
-Do not include information where the supporting evidence for it is not provided.
-
----Target response length and format---
-
-{response_type}
-
----Documents---
-
-{content_data}
-
-Add sections and commentary to the response as appropriate for the length and format. Style the response in markdown.
 """
 
-PROMPTS[
-    "similarity_check"
-] = """Please analyze the similarity between these two questions:
+# --- Dependency / Similarity ---
+PROMPTS["similarity_check"] = """Compare two questions about AUTOSAR or system design:
 
-Question 1: {original_prompt}
-Question 2: {cached_prompt}
+Q1: {original_prompt}
+Q2: {cached_prompt}
 
-Please evaluate the following two points and provide a similarity score between 0 and 1 directly:
-1. Whether these two questions are semantically similar
-2. Whether the answer to Question 2 can be used to answer Question 1
-Similarity score criteria:
-0: Completely unrelated or answer cannot be reused, including but not limited to:
-   - The questions have different topics
-   - The locations mentioned in the questions are different
-   - The times mentioned in the questions are different
-   - The specific individuals mentioned in the questions are different
-   - The specific events mentioned in the questions are different
-   - The background information in the questions is different
-   - The key conditions in the questions are different
-1: Identical and answer can be directly reused
-0.5: Partially related and answer needs modification to be used
-Return only a number between 0-1, without any additional content.
+Score 0-1:
+0 = unrelated, 1 = identical, 0.5 = partially related.
+Only output the score.
 """

PathRAG/utils.py

@@ -61,9 +61,14 @@ class EmbeddingFunc:
         else:
             self._semaphore = UnlimitedSemaphore()
 
+
     async def __call__(self, *args, **kwargs) -> np.ndarray:
         async with self._semaphore:
-            return await self.func(*args, **kwargs)
+            result = self.func(*args, **kwargs)
+            if asyncio.iscoroutine(result):
+             return await result
+        return result
+
 
 
 def locate_json_string_body_from_string(content: str) -> Union[str, None]:
@@ -147,15 +152,15 @@ def write_json(json_obj, file_name):
         json.dump(json_obj, f, indent=2, ensure_ascii=False)
 
 
-def encode_string_by_tiktoken(content: str, model_name: str = "gpt-4o-mini"):
+def encode_string_by_tiktoken(content: str, model_name: str = None):
     global ENCODER
-    if ENCODER is None:
-        ENCODER = tiktoken.encoding_for_model(model_name)
-    tokens = ENCODER.encode(content)
-    return tokens
+    if model_name is None:
+        model_name = os.environ.get("DEFAULT_TOKENIZER_MODEL", "mistralai/Mistral-7B-Instruct-v0.3")
+    encoder = tiktoken.encoding_for_model(model_name)  # ensure Qwen supported
+    return encoder.encode(content)
 
 
-def decode_tokens_by_tiktoken(tokens: list[int], model_name: str = "gpt-4o-mini"):
+def decode_tokens_by_tiktoken(tokens: list[int], model_name: str = "mistralai/Mistral-7B-Instruct-v0.3"):
     global ENCODER
     if ENCODER is None:
         ENCODER = tiktoken.encoding_for_model(model_name)
@@ -515,13 +520,15 @@ async def save_to_cache(hashing_kv, cache_data: CacheData):
     await hashing_kv.upsert({cache_data.mode: mode_cache})
 
 
-def safe_unicode_decode(content):
-    unicode_escape_pattern = re.compile(r"\\u([0-9a-fA-F]{4})")
-    def replace_unicode_escape(match):
-        return chr(int(match.group(1), 16))
+def safe_unicode_decode(content: bytes):
+    try:
+        unicode_escape_pattern = re.compile(r"\\u([0-9a-fA-F]{4})")
+        def replace_unicode_escape(match):
+            return chr(int(match.group(1), 16))
+        return unicode_escape_pattern.sub(replace_unicode_escape, content.decode("utf-8"))
+    except Exception as e:
+        logger.warning(f"Unicode decode failed: {e}")
+        return content.decode("utf-8", errors="ignore")
 
-    decoded_content = unicode_escape_pattern.sub(
-        replace_unicode_escape, content.decode("utf-8")
-    )
 
     return decoded_content