LLMQuant/quant-mind

Transform Financial Knowledge into Actionable Intelligence Knowledge Engineering • The Vision • Quick Start • Evaluation • In Production • Roadmap • Contributing QuantMind is an information processor for quantitative finance: it refines raw financial information — papers, news, filings — into structured financial knowledge that downstream retrieval and reasoning can trust. Every piece of knowledge is typed, keeps its citation, and knows its timestamp, so it persists and time-queries standalone. The people who build these refinement flows are increasingly agents — coding agents, with humans behind them. So the repository is designed agent-oriented: you open the checkout, describe the pipeline you want, and an agent builds it here against the repo's contracts, skills, and deterministic verification. It is also a perfectly good importable Python library. 📰 News 🗞️ News 📝 Description 🛠️ 2026-07 Rebuilding the repo agent-native — contexts, skills, hooks — so a coding agent can do QuantMind-quality work inside the checkout. 🎉 Accepted at NeurIPS 2025 Workshop Our paper Quant-Mind has been accepted to the NeurIPS 2025 GenAI in Finance Workshop !🚀 📢 First Release on GitHub Quant-Mind is now live on GitHub — please check it out and join us! 🤗 🧩 Knowledge Engineering Any source → typed knowledge. The target surface — shipping today: PaperFlow · collect_news ; see Roadmap. Deterministic preprocess — fetch / parse / format + clean produce source-faithful values with no model in the loop, so provenance is exact and replayable. Config-driven operations — PaperFlow(cfg).build(input) binds an immutable build config once and applies it per input; collect_news collects a replayable source window; batch_run fans any operation across a list of inputs. You never write asyncio.gather boilerplate. Typed knowledge shapes — a Paper structure tree for whole documents, and flat cards for News / Earnings / Factor / Thesis . Every artifact is self-contained: it carries its own text, an as_of timestamp, and a light source ref, so it persists and time-queries standalone. Retrieval over that knowledge — rag/ (chunking + BM25 / similarity), library/ (local persistence + meaning-based search), and mind/ (agentic, reasoning-based retrieval). Together they serve RAG and Agentic RAG, deep research, and data-MCP serving. This is the substance shipped as the NeurIPS 2025 GenAI-in-Finance workshop paper ( arXiv:2509.21507 ). The always-current statement lives in contexts/design/positioning.md . 🧠 The Vision Harness engineering — any agent → domain specialist. Don't import it. Open it. The repository itself is the product surface — we call this harness engineering . Its AGENTS.md / CLAUDE.md contracts, progressive-disclosure contexts/ , portable skills, and Claude + Codex hooks, all gated by a deterministic verify, upgrade a general coding agent into one that reliably does QuantMind-quality work. The bet: a weak model in a good harness beats a strong model running bare. Repo-level contracts — AGENTS.md / CLAUDE.md state the always-on rules once, in one source, for every agent that opens the repo. Progressive-disclosure contexts/ — agent-facing pages with a Quick Summary / Contents preview, so an agent loads only the one page a task needs. Portable skills — quantmind-dev ships today (contributor setup / commit / PR / component workflow), mirrored for Claude and Codex. Claude + Codex hooks — shared hook scripts give both agents identical hard guarantees without maintaining two copies of a rule. Deterministic verify — scripts/verify.sh runs lint + types + import boundaries + tests, fast-failing in a fixed order; CI runs the exact same script. See contexts/dev/harness-engineering.md for the enforcement mechanics. 🚀 Quick Start The agent path (recommended) QuantMind is meant to be opened, not imported. Point a coding agent at the checkout and describe the pipeline you want: git clone https://github.com/LLMQuant/quant-mind.git cd quant-mind && claude # or: codex Then, in the agent session: "Build me a source-first paper artifact for arXiv 1706.03762, then persist it and search the summary." The agent reads the repo's contracts ( AGENTS.md ), loads the relevant contexts/ pages, writes the pipeline, and runs scripts/verify.sh before it hands the change back. The library path QuantMind is still a normal Python package. We use uv for package management. uv venv && source .venv/bin/activate uv pip install -e . PaperFlow refines one arXiv PDF into a self-contained paper artifact. The cfg type selects the knowledge shape ( PaperStructureCfg → PaperStructureTree , PaperSemanticCfg → PaperSemanticResult ). Bind a PaperStructureCfg to build a source-native structure tree — a hierarchy of page-cited nodes: import asyncio from quantmind . configs import PaperStructureCfg from quantmind . configs . paper import ArxivIdentifier from quantmind . flows import PaperFlow async def main () -> None : flow = PaperFlow ( PaperStructureCfg ( model = "gpt-5.6-luna" )) tree = await flow . build ( ArxivIdentifier ( id = "1706.03762v7" )) print ( tree . id , len ( tree . nodes )) asyncio . run ( main ()) Prefer the semantic shape — a page-aware chunk set plus one cited global summary you can embed and retrieve over? Bind a PaperSemanticCfg instead — same class, different cfg: import asyncio from quantmind . configs import PaperSemanticCfg from quantmind . configs . paper import ArxivIdentifier from quantmind . flows import PaperFlow async def main () -> None : flow = PaperFlow ( PaperSemanticCfg ( model = "gpt-5.6-luna" , chunk_size = 512 )) result = await flow . build ( ArxivIdentifier ( id = "1706.03762v7" )) print ( result . global_summary . summary ) print ( result . source_revision . id , result . chunk_set . id ) asyncio . run ( main ()) Fan out a batch with batch_run import asyncio from datetime import datetime , timedelta , timezone from quantmind . configs import NewsCollectionCfg , NewsWindow from quantmind . flows import batch_run , collect_news async def main () -> None : end = datetime . now ( timezone . utc ) windows = [ NewsWindow ( source = "pr-newswire" , start = end - timedelta ( days = day + 1 ), end = end - timedelta ( days = day ), ) for day in range ( 3 ) ] result = await batch_run ( collect_news , windows , cfg = NewsCollectionCfg ( retain_raw_html = False ), concurrency = 3 , on_error = "skip" , on_progress = lambda done , total : print ( f" { done } / { total } " ), ) print ( f"ok= { result . success_count } failed= { result . failure_count } " ) asyncio . run ( main ()) Resolve free-form intent with magic import asyncio from quantmind . flows import collect_news from quantmind . magic import resolve_magic_input async def main () -> None : inp , cfg = await resolve_magic_input ( "Collect the last day of PR Newswire company news." , target_flow = collect_news , ) batch = await collect_news ( inp , cfg = cfg ) print ( f"documents= { batch . success_count } complete= { batch . complete } " ) asyncio . run ( main ()) More examples live under examples/ ; design contracts live under contexts/design/ . 🔬 Evaluation (In Design) Note Evaluation is in the design phase — no results are claimed yet. Our framing follows Anthropic's Demystifying evals for AI agents . quantmind-bench measures the harness bet directly. Following the SWE-bench model, it runs paired trials on the same model and the same task set : once against a bare checkout, once against the QuantMind repo mounted with its contracts, contexts, skills, and hooks. The reported deltas are cost-to-green, pass@1, pass^k across seeds, and wall-clock — how much a good harness moves a fixed model. Run instrumentation (tokens / cost / duration / a verify oracle) already ships; the protocol that consumes it is being designed, and no numbers are published. A separate llmquant-data-bench will score knowledge quality (correctness, citation precision/recall, point-in-time correctness); it is likewise in design.