async def build_index(
    config: GraphRagConfig,
    method: IndexingMethod | str = IndexingMethod.Standard,
    is_update_run: bool = False,
    memory_profile: bool = False,
    callbacks: list[WorkflowCallbacks] | None = None,
    additional_context: dict[str, Any] | None = None,
    verbose: bool = False,
    input_documents: pd.DataFrame | None = None,
) -> list[PipelineRunResult]

[
    PipelineRunResult(
        workflow="load_input_documents",
        result={...},
        errors=[],
        total_runtime=1.5,
    ),
    ...
]

import asyncio
from graphrag.config import load_config
from graphrag.api import build_index

async def main():
    config = load_config(root_dir="./my_project")
    results = await build_index(
        config=config,
        method="standard",
        verbose=True,
    )
    for result in results:
        print(f"{result.workflow}: {result.total_runtime:.2f}s")

asyncio.run(main())

async def local_search(
    config: GraphRagConfig,
    entities: pd.DataFrame,
    communities: pd.DataFrame,
    community_reports: pd.DataFrame,
    text_units: pd.DataFrame,
    relationships: pd.DataFrame,
    covariates: pd.DataFrame | None,
    community_level: int,
    response_type: str,
    query: str,
    callbacks: list[QueryCallbacks] | None = None,
    verbose: bool = False,
) -> tuple[str, dict]

(
    "Answer text...",  # LLM 生成的答案
    {  # 上下文数据
        "entities": [...],
        "relationships": [...],
        "text_units": [...],
        "reports": [...],
    }
)

import asyncio
import pandas as pd
from graphrag.config import load_config
from graphrag.api import local_search

async def main():
    config = load_config(root_dir="./my_project")
    
    # 加载索引数据
    output_dir = "./my_project/output"
    entities = pd.read_parquet(f"{output_dir}/entities.parquet")
    communities = pd.read_parquet(f"{output_dir}/communities.parquet")
    community_reports = pd.read_parquet(f"{output_dir}/community_reports.parquet")
    text_units = pd.read_parquet(f"{output_dir}/text_units.parquet")
    relationships = pd.read_parquet(f"{output_dir}/relationships.parquet")
    
    # 执行查询
    response, context = await local_search(
        config=config,
        entities=entities,
        communities=communities,
        community_reports=community_reports,
        text_units=text_units,
        relationships=relationships,
        covariates=None,
        community_level=2,
        response_type="Multiple Paragraphs",
        query="What are the key partnerships?",
    )
    
    print("Answer:", response)
    print("Context entities:", len(context["entities"]))

asyncio.run(main())

async def global_search(
    config: GraphRagConfig,
    entities: pd.DataFrame,
    communities: pd.DataFrame,
    community_reports: pd.DataFrame,
    community_level: int | None,
    dynamic_community_selection: bool,
    response_type: str,
    query: str,
    callbacks: list[QueryCallbacks] | None = None,
    verbose: bool = False,
) -> tuple[str, dict]

# 流式局部搜索
async for chunk in local_search_streaming(...):
    print(chunk, end="", flush=True)

# 流式全局搜索
async for chunk in global_search_streaming(...):
    print(chunk, end="", flush=True)

async def generate_indexing_prompts(
    config: GraphRagConfig,
    domain: str | None = None,
    selection_method: DocSelectionType = DocSelectionType.RANDOM,
    limit: int = 15,
    max_tokens: int = 12000,
    chunk_size: int = 200,
    language: str | None = None,
    discover_entity_types: bool = True,
    output: Path = Path("prompts"),
) -> None

await generate_indexing_prompts(
    config=config,
    domain="financial technology",
    selection_method="auto",
    limit=50,
    output=Path("./custom_prompts"),
)

graphrag init [OPTIONS]

# 在当前目录初始化
graphrag init

# 在指定目录初始化
graphrag init --root ./my_graphrag_project

# 强制覆盖
graphrag init --root ./my_graphrag_project --force

my_graphrag_project/
├── settings.yaml        # 配置文件
├── .env                 # 环境变量（需手动创建）
├── input/               # 输入文档目录
├── output/              # 输出索引目录
├── cache/               # 缓存目录
└── prompts/             # 提示词目录（可选）

graphrag index [OPTIONS]

# 基本用法
graphrag index --root ./my_project

# 使用自定义配置
graphrag index --config ./custom_settings.yaml

# Fast 模式（跳过 LLM）
graphrag index --method fast

# 详细日志
graphrag index --verbose

# 禁用缓存（重新计算所有）
graphrag index --no-cache

# 仅验证配置
graphrag index --dry-run

graphrag update [OPTIONS]

# 增量更新
graphrag update --root ./my_project

# Fast 模式增量更新
graphrag update --method fast --root ./my_project

graphrag query [OPTIONS]

# 局部搜索
graphrag query \
  --method local \
  --query "What is the relationship between Microsoft and OpenAI?" \
  --root ./my_project

# 全局搜索
graphrag query \
  --method global \
  --query "What are the main trends in AI?" \
  --root ./my_project

# 动态社区选择
graphrag query \
  --method global \
  --query "Explain the AI ecosystem" \
  --dynamic-community-selection \
  --root ./my_project

# 流式输出
graphrag query \
  --method local \
  --query "Summarize the key findings" \
  --streaming \
  --root ./my_project

# 自定义响应类型
graphrag query \
  --method local \
  --query "List the top 5 entities" \
  --response-type "Bullet List" \
  --root ./my_project

graphrag prompt-tune [OPTIONS]

# 基本用法（随机选择文档）
graphrag prompt-tune --root ./my_project

# 指定领域
graphrag prompt-tune \
  --domain "financial technology" \
  --root ./my_project

# 使用 auto 模式（聚类选择）
graphrag prompt-tune \
  --selection-method auto \
  --n-subset-max 500 \
  --k 20 \
  --root ./my_project

# 指定语言
graphrag prompt-tune \
  --language chinese \
  --root ./my_project

# 自定义输出目录
graphrag prompt-tune \
  --output ./custom_prompts \
  --root ./my_project

class WorkflowCallbacks:
    def on_pipeline_start(self, workflows: list[str]):
        """管道开始"""
    
    def on_pipeline_end(self, results: list[PipelineRunResult]):
        """管道结束"""
    
    def on_workflow_start(self, workflow_name: str):
        """工作流开始"""
    
    def on_workflow_end(self, workflow_name: str, result: Any):
        """工作流结束"""
    
    def on_error(self, message: str, cause: Exception | None = None):
        """错误发生"""
    
    def on_warning(self, message: str):
        """警告发生"""
    
    def on_log(self, message: str):
        """日志消息"""
    
    def on_progress(self, current: int, total: int, message: str):
        """进度更新"""

class MyCallbacks(WorkflowCallbacks):
    def on_workflow_start(self, workflow_name: str):
        print(f"开始执行: {workflow_name}")
    
    def on_workflow_end(self, workflow_name: str, result: Any):
        print(f"完成: {workflow_name}")
    
    def on_error(self, message: str, cause: Exception | None = None):
        print(f"错误: {message}")

# 使用回调
await build_index(
    config=config,
    callbacks=[MyCallbacks()],
)

class QueryCallbacks:
    def on_context(self, context: Any):
        """上下文构建完成"""
    
    def on_map_response_start(self, chunks: list[str]):
        """Map 阶段开始（Global Search）"""
    
    def on_map_response_end(self, responses: list[str]):
        """Map 阶段结束"""
    
    def on_response_start(self):
        """响应生成开始"""
    
    def on_response_end(self, response: str):
        """响应生成结束"""

class MyQueryCallbacks(QueryCallbacks):
    def on_context(self, context: Any):
        print(f"上下文包含 {len(context['entities'])} 个实体")
    
    def on_response_end(self, response: str):
        print(f"生成答案长度: {len(response)} 字符")

# 使用回调
response, context = await local_search(
    config=config,
    ...,
    callbacks=[MyQueryCallbacks()],
)

# 1. 初始化项目
graphrag init --root ./my_project

# 2. 准备数据（手动将文档放入 input/）

# 3. 配置调整（编辑 settings.yaml）

# 4. 验证配置
graphrag index --dry-run --root ./my_project

# 5. 构建索引（首次使用 standard 模式）
graphrag index --verbose --root ./my_project

# 6. 测试查询
graphrag query \
  --method local \
  --query "Test query" \
  --root ./my_project

# 7. 优化提示词（可选）
graphrag prompt-tune --domain "your domain" --root ./my_project

# 8. 增量更新（添加新文档后）
graphrag update --root ./my_project

# 使用环境变量配置
export OPENAI_API_KEY=sk-...
export AZURE_STORAGE_CONNECTION_STRING=...

# 后台运行索引构建
nohup graphrag index \
  --root /var/graphrag/project \
  --config /etc/graphrag/settings.yaml \
  --verbose \
  > /var/log/graphrag/index.log 2>&1 &

# 监控进度
tail -f /var/log/graphrag/index.log