LRriver opened a new issue, #344: URL: https://github.com/apache/hugegraph-ai/issues/344
### Search before asking - [x] I had searched in the [feature](https://github.com/apache/hugegraph-ai/issues?q=is%3Aissue+label%3A%22Feature%22) and found no similar feature requirement. ### Feature Description (功能描述) ## Feature Description After graph extraction supports real chunk splitting, the graph extraction flow should be able to extract chunks concurrently with a bounded concurrency limit. The current `PropertyGraphExtract.run()` iterates over chunks serially, which makes long documents slow when the LLM call dominates runtime. The implementation should live in the extraction operator/flow layer, with the demo exposing the setting to users. It should not make unbounded LLM requests. ## Current verification - `PropertyGraphExtract.run()` loops over `chunks` with `for chunk in chunks` and calls the LLM one chunk at a time in `hugegraph-llm/src/hugegraph_llm/operators/llm_op/property_graph_extract.py:98`. - The graph extraction demo button calls `extract_graph` once in `hugegraph-llm/src/hugegraph_llm/demo/rag_demo/vector_graph_block.py:331`. - The RAG demo already uses a Gradio `concurrency_limit=5`, but graph extraction does not have a per-chunk concurrency control. ## Suggested scope - Add a bounded concurrency option for chunk-level graph extraction in the operator/flow layer. - Expose the concurrency setting from the demo after the lower-level extraction path supports it. - Start with a conservative default, for example serial mode or a small limit, to avoid surprising LLM provider load. - Preserve deterministic merge semantics for extracted vertices and edges as much as possible. - Surface chunk-level errors clearly. A single failed chunk should either fail the whole extraction with context or return structured partial-failure details; do not silently drop failures. - Consider making concurrency available only when `split_type != "document"`. ## Mermaid reference ```mermaid flowchart TD Text[Input documents] --> Split[ChunkSplitNode] Split --> Flow[GraphExtractFlow] Flow --> Queue[Bounded extraction queue] Queue --> W1[LLM worker 1] Queue --> W2[LLM worker 2] Queue --> WN[LLM worker N] W1 --> Merge[Parse, validate, merge] W2 --> Merge WN --> Merge Merge --> Output[vertices, edges, chunk errors] ``` ## Acceptance criteria - The extraction flow supports a configured chunk-level concurrency limit. - The demo exposes a clear concurrency setting or uses a documented bounded default. - The number of simultaneous chunk extraction calls never exceeds the configured limit. - Results from concurrent extraction are parsed and filtered with the same validation rules as serial extraction. - Chunk failures are visible to the user. ## Suggested tests - Unit test using a fake LLM to verify the configured concurrency limit. - Test that serial behavior remains available. - Test that chunk results are merged into the same `vertices` and `edges` shape as today. - Test failure behavior for one failed chunk among several successful chunks. ## Dependencies - This is most useful after `01-configurable-graph-extract-chunk-split.md` is implemented. ### Are you willing to submit a PR? - [ ] Yes I am willing to submit a PR! ### Code of Conduct - [x] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct) -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
