Spaces:
Running
Running
Shoufa Zhang
Deploy DocMorph & SeekMorph interactive Studio and 5-layer production benchmark
66227f0 Download app.py from zhangshoufa/DocMorph: direct link, hf CLI and curl.
- Browser
- Download file 15.4 kB
-
https://huggingface.co/spaces/zhangshoufa/DocMorph/resolve/main/app.py
- Command line
-
hf download hf://spaces/zhangshoufa/DocMorph/app.py
-
curl -L -o app.py https://huggingface.co/spaces/zhangshoufa/DocMorph/resolve/main/app.py
15.4 kB
| """Interactive Gradio workbench for DocMorph and SeekMorph.""" | |
| from __future__ import annotations | |
| import json | |
| from typing import Any | |
| from docmorph import DocumentMorpher, HybridIndex | |
| from seekmorph import ( | |
| KnowledgeItem, | |
| PersonalMemoryStore, | |
| ProactiveTicketRuntime, | |
| SeekMorphEngine, | |
| TriggerEvent, | |
| UserProfile, | |
| ) | |
| from tests.test_docmorph_5layers import ( | |
| run_layer_1_engineering_boundary, | |
| run_layer_2_structure_and_table_preservation, | |
| run_layer_3_information_retrieval_benchmark, | |
| run_layer_4_security_and_tenant_isolation, | |
| run_layer_5_agent_rag_citation_and_grounding, | |
| ) | |
| SAMPLE_MD = """# 2026 LLM Inference & Speculative Decoding Benchmark | |
| ## Hardware Throughput Matrix | |
| | Hardware Cluster | Model | Speculative Engine | Mean Acceptance (tokens) | Throughput (tok/s) | GSM8K Accuracy | | |
| | :--- | :--- | :--- | :--- | :--- | :--- | | |
| | 8x AMD MI308X | DeepSeek-V4.1-Flash | DSpark (Patched) | 2.95 | 312.5 | 99.0% | | |
| | 8x NVIDIA H100 | DeepSeek-V4.1-Flash | DSpark (Patched) | 3.05 | 328.4 | 99.1% | | |
| | 8x AMD MI308X | DeepSeek-V4.1-Flash | DSpark (Unpatched) | 0.00 | 104.2 | N/A | | |
| | 4x NVIDIA L40S | Qwen-2.5-72B-FP8 | Eagle-2 | 2.42 | 168.0 | 98.8% | | |
| | 8x NVIDIA H800 | Qwen-2.5-72B-FP8 | Eagle-2 | 2.61 | 275.6 | 99.2% | | |
| | 8x Intel Gaudi2 | DeepSeek-V4.1-Flash | DSpark (Patched) | 2.81 | 240.8 | 98.9% | | |
| ## Storage & Indexing Notes | |
| All benchmark telemetry logs are indexed in a thread-safe inverted index with pre-retrieval RBAC tenant isolation. | |
| """ | |
| SAMPLE_CSV = """region,enterprise_tier,q1_calls,q2_calls,daily_reach_per_rep,latency_ms | |
| Beijing,Enterprise_A,320000,410000,30,820 | |
| Shanghai,Enterprise_A,280000,360000,29,790 | |
| Shenzhen,Enterprise_B,195000,245000,28,840 | |
| Hangzhou,Enterprise_B,160000,210000,31,760 | |
| Guangzhou,Enterprise_C,145000,185000,27,880 | |
| Chengdu,Enterprise_C,110000,150000,26,910 | |
| """ | |
| SAMPLE_HTML = """<div> | |
| <h1>Storage Engine Specification</h1> | |
| <h2>Write-Ahead Log (WAL)</h2> | |
| <p>Every transaction commit flushes records with fsync before returning ack.</p> | |
| <table> | |
| <tr><th>Parameter</th><th>Default</th><th>Description</th></tr> | |
| <tr><td>wal_sync_method</td><td>fdatasync</td><td>Forces WAL flush to disk</td></tr> | |
| <tr><td>checkpoint_timeout</td><td>5min</td><td>Maximum time between automatic WAL checkpoints</td></tr> | |
| <tr><td>max_wal_size</td><td>16GB</td><td>Maximum WAL size before triggering checkpoint</td></tr> | |
| </table> | |
| """ | |
| def run_docmorph_pipeline( | |
| raw_text: str, | |
| fmt: str, | |
| max_chars: int, | |
| namespace: str, | |
| query: str, | |
| top_k: int, | |
| expand_window: int, | |
| ) -> tuple[str, str, str]: | |
| morpher = DocumentMorpher(max_chars=int(max_chars)) | |
| chunks = morpher.morph_text( | |
| f"document.{fmt}", | |
| raw_text or "", | |
| fmt=fmt, | |
| namespace=(namespace or "default").strip(), | |
| ) | |
| chunk_cards: list[str] = [f"### Total Chunks Generated: `{len(chunks)}`\n"] | |
| jsonl_lines: list[str] = [] | |
| for i, c in enumerate(chunks, 1): | |
| breadcrumb = c.breadcrumb_str or "(Root)" | |
| chunk_cards.append( | |
| f"#### Chunk {i} | `kind={c.kind}` | `chars={len(c.content)}` | Path: `{breadcrumb}`\n\n" | |
| f"{c.content}\n\n---" | |
| ) | |
| jsonl_lines.append(json.dumps(c.to_dict(), ensure_ascii=False)) | |
| index = HybridIndex() | |
| index.add_many(chunks) | |
| search_md_parts: list[str] = [] | |
| if query and query.strip(): | |
| hits = index.search( | |
| query.strip(), | |
| top_k=int(top_k), | |
| namespace=(namespace or "default").strip(), | |
| expand_window=int(expand_window), | |
| ) | |
| if not hits: | |
| search_md_parts.append("No matching chunks found for query in this namespace.") | |
| else: | |
| for rank, h in enumerate(hits, 1): | |
| search_md_parts.append( | |
| f"#### Rank {rank} | `RRF={h.score:.4f}` | `BM25={h.bm25_score:.4f}` | " | |
| f"Path: `{h.chunk.breadcrumb_str or '(Root)'}`\n\n" | |
| f"{h.expanded_content}\n\n---" | |
| ) | |
| else: | |
| search_md_parts.append("Enter a search query to test BM25 + RRF retrieval.") | |
| return "\n".join(chunk_cards), "\n".join(search_md_parts), "\n".join(jsonl_lines) | |
| def run_seekmorph_pipeline( | |
| query: str, | |
| tenant_id: str, | |
| roles_csv: str, | |
| preferred_tags_csv: str, | |
| eval_mode: str, | |
| sender_id: str, | |
| ) -> tuple[str, str]: | |
| engine = SeekMorphEngine() | |
| corpus = [ | |
| KnowledgeItem( | |
| item_id="doc-vllm-dspark", | |
| title="vLLM DeepSeek-V4.1 DSpark Speculative Decoding Fix", | |
| content="Registers packed_modules_mapping across ROCm MI308X and CUDA, restoring 2.95 mean acceptance length.", | |
| tenant_id="acme", | |
| allowed_roles=("admin", "ml", "infra"), | |
| tags=("llm", "gpu", "vllm", "deepseek"), | |
| embedding=(0.92, 0.18, 0.05), | |
| clicks=86, | |
| impressions=180, | |
| age_days=1.0, | |
| ), | |
| KnowledgeItem( | |
| item_id="doc-hybrid-rag", | |
| title="Enterprise Multi-Tenant Hybrid Search & Table Chunking", | |
| content="Combines inverted-index BM25, dense cosine similarity, pre-retrieval RBAC, and table header preservation.", | |
| tenant_id="acme", | |
| allowed_roles=("admin", "ml", "sales"), | |
| tags=("rag", "search", "rbac"), | |
| embedding=(0.25, 0.88, 0.15), | |
| clicks=64, | |
| impressions=150, | |
| age_days=5.0, | |
| ), | |
| KnowledgeItem( | |
| item_id="doc-hr-secret", | |
| title="Executive Compensation Plan 2026", | |
| content="Confidential executive bonus pool and equity allocation.", | |
| tenant_id="acme", | |
| allowed_roles=("hr_exec",), | |
| tags=("hr", "finance"), | |
| embedding=(0.05, 0.05, 0.98), | |
| clicks=12, | |
| impressions=20, | |
| age_days=0.5, | |
| ), | |
| ] | |
| engine.add_many(corpus) | |
| roles = tuple(r.strip() for r in (roles_csv or "").split(",") if r.strip()) | |
| pref_tags = {t.strip(): 1.5 for t in (preferred_tags_csv or "").split(",") if t.strip()} | |
| user = UserProfile( | |
| user_id="u_demo", | |
| tenant_id=(tenant_id or "acme").strip(), | |
| roles=roles, | |
| interest_tags=pref_tags, | |
| ) | |
| hits = engine.search_and_recommend(query or "vllm dspark", user=user, top_k=5) | |
| if not hits: | |
| search_report = "No accessible items matched (filtered by pre-retrieval RBAC or zero lexical/semantic overlap)." | |
| else: | |
| rows = [ | |
| f"### Query Intent: `{hits[0].query_intent}` | Accessible Hits: `{len(hits)}`\n", | |
| "| Rank | Item ID | Title | Final Score | Lexical | Semantic | Personal | Recency |", | |
| "| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |", | |
| ] | |
| for i, h in enumerate(hits, 1): | |
| rows.append( | |
| f"| {i} | `{h.item.item_id}` | {h.item.title} | **{h.final_score:.4f}** | " | |
| f"{h.lexical_score:.3f} | {h.semantic_score:.3f} | {h.personal_score:.3f} | " | |
| f"{h.recency_score:.3f} |" | |
| ) | |
| search_report = "\n".join(rows) | |
| mem_store = PersonalMemoryStore() | |
| mem_store.remember( | |
| memory_id="mem-demo-1", | |
| user_id="u_demo", | |
| tenant_id=(tenant_id or "acme").strip(), | |
| title="Hardware & Inference Preference", | |
| content="Prefers FP8 speculative decoding benchmarks on MI308X with DSpark.", | |
| kind="preference", | |
| tags=("llm", "gpu"), | |
| ) | |
| recalled = mem_store.recall(user, query or "MI308X", top_k=2) | |
| runtime = ProactiveTicketRuntime( | |
| allowed_actors={"alice", "maintainer"}, | |
| tenant_id=(tenant_id or "acme").strip(), | |
| eval_mode=eval_mode, | |
| ) | |
| event = TriggerEvent( | |
| trigger_id="trig-demo", | |
| source="github", | |
| thread_id="issue-101", | |
| actor_id=(sender_id or "stranger").strip(), | |
| text=query or "Please check issue", | |
| addressed=True, | |
| ) | |
| ticket = runtime.receive(event) | |
| agent_report = ( | |
| f"### Personal Agent Memory & SuperAgent Gate\n\n" | |
| f"- **PersonalMemoryStore Recall (`u_demo`)**: `{recalled[0].item.content if recalled else 'None'}` " | |
| f"(clicks=`{recalled[0].item.clicks if recalled else 0}`)\n" | |
| f"- **ProactiveTicketRuntime Gate (`actor={sender_id}`, `eval_mode={eval_mode}`)**: " | |
| f"**{'ALLOWED (Ticket Running)' if ticket is not None else 'BLOCKED (Filtered by Host Gate)'}**" | |
| ) | |
| return search_report, agent_report | |
| def run_all_5_layers() -> str: | |
| layers: list[tuple[str, Any]] = [ | |
| ("Layer 1: Engineering Boundary & 20-Thread Concurrency", run_layer_1_engineering_boundary), | |
| ("Layer 2: Chunking Structure & Table Header Preservation", run_layer_2_structure_and_table_preservation), | |
| ("Layer 3: Information Retrieval (Recall@3 / MRR@3 / NDCG@3)", run_layer_3_information_retrieval_benchmark), | |
| ("Layer 4: Multi-Tenant Security & Zero Ghost Postings", run_layer_4_security_and_tenant_isolation), | |
| ("Layer 5: Agent Tool Grounding & Parallel Call Normalization", run_layer_5_agent_rag_citation_and_grounding), | |
| ] | |
| lines = ["### 5-Layer Production Benchmark Report\n"] | |
| for name, fn in layers: | |
| res = fn() | |
| lines.append(f"#### PASS - {name}") | |
| for k, v in res.items(): | |
| if k != "status": | |
| lines.append(f"- **{k}**: `{v}`") | |
| lines.append("") | |
| return "\n".join(lines) | |
| def build_ui(): | |
| import gradio as gr | |
| with gr.Blocks(title="DocMorph & SeekMorph Studio") as demo: | |
| gr.Markdown( | |
| "# DocMorph & SeekMorph Interactive Workbench\n" | |
| "Structure-aware document chunking (100% table-header preservation across chunks), " | |
| "multi-tenant hybrid retrieval (`BM25 + Dense RRF`), personalized reranking, and 5-layer quality verification.\n" | |
| "GitHub: [DocMorph](https://github.com/peterzhang987723/DocMorph) | " | |
| "[SeekMorph](https://github.com/peterzhang987723/SeekMorph)" | |
| ) | |
| with gr.Tabs(): | |
| with gr.Tab("1. DocMorph: Table-Header Preserving Chunker & Hybrid RAG"): | |
| with gr.Row(): | |
| btn_md = gr.Button("Load Sample: DeepSeek-V4 Benchmark Table (Markdown)") | |
| btn_csv = gr.Button("Load Sample: Enterprise Regional Metrics (CSV)") | |
| btn_html = gr.Button("Load Sample: Unclosed HTML Spec (Fault-Tolerant)") | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| raw_input = gr.Textbox(label="Input Document", value=SAMPLE_MD, lines=14) | |
| with gr.Row(): | |
| fmt_input = gr.Dropdown( | |
| choices=["md", "csv", "html", "json", "txt"], | |
| value="md", | |
| label="Document Format", | |
| ) | |
| max_chars_input = gr.Slider( | |
| minimum=140, | |
| maximum=800, | |
| value=220, | |
| step=20, | |
| label="Max Characters per Chunk (forces table splitting)", | |
| ) | |
| with gr.Row(): | |
| ns_input = gr.Textbox(value="prod", label="Tenant Namespace") | |
| query_input = gr.Textbox(value="MI308X DSpark", label="Hybrid Search Query") | |
| with gr.Row(): | |
| topk_input = gr.Slider(minimum=1, maximum=5, value=3, step=1, label="Top-K") | |
| win_input = gr.Slider(minimum=0, maximum=2, value=0, step=1, label="Context Window Expansion") | |
| run_doc_btn = gr.Button("Morph Document & Run Hybrid Search", variant="primary") | |
| with gr.Column(scale=1): | |
| chunks_out = gr.Markdown(label="Structure-Aware Chunks") | |
| search_out = gr.Markdown(label="Hybrid Search Results") | |
| jsonl_out = gr.Code(label="Exported JSONL (Ready for RAG Ingestion)", language="json") | |
| btn_md.click(lambda: (SAMPLE_MD, "md", 220, "MI308X DSpark"), outputs=[raw_input, fmt_input, max_chars_input, query_input]) | |
| btn_csv.click(lambda: (SAMPLE_CSV, "csv", 160, "Beijing 30"), outputs=[raw_input, fmt_input, max_chars_input, query_input]) | |
| btn_html.click(lambda: (SAMPLE_HTML, "html", 200, "fdatasync"), outputs=[raw_input, fmt_input, max_chars_input, query_input]) | |
| run_doc_btn.click( | |
| run_docmorph_pipeline, | |
| inputs=[raw_input, fmt_input, max_chars_input, ns_input, query_input, topk_input, win_input], | |
| outputs=[chunks_out, search_out, jsonl_out], | |
| ) | |
| demo.load( | |
| run_docmorph_pipeline, | |
| inputs=[raw_input, fmt_input, max_chars_input, ns_input, query_input, topk_input, win_input], | |
| outputs=[chunks_out, search_out, jsonl_out], | |
| ) | |
| with gr.Tab("2. SeekMorph: Pre-Retrieval RBAC, Reranking & SuperAgent Gate"): | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| sm_query = gr.Textbox(value="vllm dspark mi308x", label="Search Query") | |
| sm_tenant = gr.Textbox(value="acme", label="Tenant ID (try 'other' to verify tenant isolation)") | |
| sm_roles = gr.Textbox( | |
| value="admin, ml", | |
| label="User Roles (add 'hr_exec' to unlock confidential HR doc)", | |
| ) | |
| sm_tags = gr.Textbox(value="llm, gpu", label="User Preferred Tags") | |
| sm_eval = gr.Radio(choices=["off", "work", "all"], value="off", label="SuperAgent Eval Mode") | |
| sm_sender = gr.Textbox( | |
| value="stranger", | |
| label="Ticket Sender (try 'maintainer' vs 'stranger')", | |
| ) | |
| sm_btn = gr.Button("Execute SeekMorph Pipeline", variant="primary") | |
| with gr.Column(scale=1): | |
| sm_search_out = gr.Markdown() | |
| sm_agent_out = gr.Markdown() | |
| sm_btn.click( | |
| run_seekmorph_pipeline, | |
| inputs=[sm_query, sm_tenant, sm_roles, sm_tags, sm_eval, sm_sender], | |
| outputs=[sm_search_out, sm_agent_out], | |
| ) | |
| demo.load( | |
| run_seekmorph_pipeline, | |
| inputs=[sm_query, sm_tenant, sm_roles, sm_tags, sm_eval, sm_sender], | |
| outputs=[sm_search_out, sm_agent_out], | |
| ) | |
| with gr.Tab("3. Live 5-Layer Production Benchmark"): | |
| bench_btn = gr.Button("Run All 5 Verification Layers Live", variant="primary") | |
| bench_out = gr.Markdown() | |
| bench_btn.click(run_all_5_layers, outputs=[bench_out]) | |
| demo.load(run_all_5_layers, outputs=[bench_out]) | |
| return demo | |
| if __name__ == "__main__": | |
| ui = build_ui() | |
| ui.launch() | |