ChronoFact MCP server
Commit Oct 27, 2026A high-performance Rust microservice that provides temporal calibration, fact verification, and memory management for AI agents.
Also known as ModernOps888/chronofact
- Stars
- 2
- Tools
- 14
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Oct 27, 2026
- License
- MIT
What is ChronoFact MCP?
ChronoFact is a high-performance Rust microservice that provides temporal calibration, fact verification, and memory management for AI agents. It exposes 14 tools, such as chronofact_temporal_check, chronofact_ground_query, chronofact_verify_claims.
Summary generated from the project's README
About ChronoFact MCP server
Developers building agentic AI systems can use ChronoFact to combat model hallucinations, temporal knowledge gaps, and token cost bloat. This high-performance Rust microservice acts as an epistemic backbone, providing temporal calibration, fact verification, and structured memory management. It is designed as a local-first engine using tokio, axum, and rusqlite, making it suitable for low-latency integration into MCP clients via stdio.
The server provides specialized tools like chronofact_temporal_check to identify when an AI's knowledge might be outdated due to model weight freezes. It also includes chronofact_verify_claims for decomposing model outputs into atomic assertions and chronofact_memory_save for managing episodic session ledgers. By pruning unneeded tool schemas and using a TF-IDF router, it helps reduce prompt token usage by 70-90%. The system is built for reliability, featuring cryptographic attestation and strict security controls to prevent prompt injection and SSRF attacks.
What you can do with it
- 1Verifying technical claimsA developer can pass a draft text to the server to decompose it into atomic assertions and check for contradictions.
- 2Auditing source code for securityThe server can automatically flag dangerous patterns like unparameterized SQL or hardcoded secrets in a codebase.
- 3Managing long-term agent memoryAn agent can save critical architectural decisions into a structured ledger to prevent losing context between sessions.
Written from the project's README. Every use case is checked against a quote from it.
ChronoFact MCP tools 14
Detected from the READMEchronofact_temporal_checkchronofact_ground_querychronofact_verify_claimschronofact_verify_code_invariantschronofact_attestation_generatechronofact_memory_savechronofact_memory_dossierchronofact_querychronofact_cost_optimizechronofact_cost_metricschronofact_expand_tool_palettegateway_find_tools
Show all 14 toolsShow fewer tools
gateway_call_toolgateway_list_servers
Configuration
CHRONOFACT_DB
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablemodernops888/chronofact is public and reachablegithub.com/modernops888/chronofact ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-10-27github.com/modernops888/chronofact ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model14 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHub⚡ Project ChronoFact: The 4-Pillar Epistemic AI Backbone
A High-Performance Rust Microservice, MCP Server, and React 19 Cockpit Combating Model Training Freezes, Hallucinations, Cross-Session Amnesia, and Token Cost Bleed.
🏛️ Executive Architecture: The 4 Epistemic Pillars
Large Language Models deployed in agentic environments suffer from four critical failure modes:
- Temporal Deadweight: Weights are frozen 3-8 months before public release.
- Hallucination & Fabrication: Speculative generation of non-existent APIs and incorrect facts.
- Cross-Session Amnesia & Memory Spam: Losing critical architectural decisions, or polluting new chat contexts with irrelevant historical memories.
- Token Context Bloat & Cost Bleed: Dumping massive schemas into prompts every turn, burning millions of tokens and breaking provider prompt caches.
ChronoFact resolves all four failure modes with a zero-latency, local-first Rust engine (tokio + axum + rusqlite WAL) and an Antigravity MCP server:
⚡ What's New in v1.4.1 — Turn-Latency Audit
Measured on the release binary with a JSON-RPC stdio harness (100 calls):
| Defect found | Impact before | After v1.4.1 |
|---|---|---|
| MCP head-of-line blocking — stdio requests processed strictly one at a time | A sub-millisecond chronofact_temporal_check waited 1,691 ms behind a chronofact_ground_query web search (up to 60 s behind gateway_call_tool) |
0.61 ms (concurrent dispatch + single ordered stdout writer) |
Handshake blocked on upstream gateway servers — each servers.json stdio upstream connected sequentially before initialize was answered (15 s handshake timeout each) |
IDE MCP startup delayed by up to N × 15 s ("server failed to load") | initialize answered in 46 ms; upstreams get a 1.5 s budget, slower ones finish in the background, are hot-swapped in, and the client receives notifications/tools/list_changed |
| Oversized stdin frames (> 16 MB) were truncated, and the remainder was parsed as new requests | Stream desync | Drained to the next newline and rejected with JSON-RPC -32600 |
chronofact_temporal_check steady state: 0.44 ms avg / 0.81 ms P95. On stdin EOF the server finishes in-flight calls, flushes, and exits (4 ms).
✨ What's New in v1.4.0 (In Plain English)
Every module, SQL query, regex engine, and MCP handler in ChronoFact was audited line by line and upgraded against raw ground-truth data:
- Zero-Friction MCP Tool Aliases: Agents calling
chronofact_verify_claimswithclaim,claims,statement,text, ordraft_text(orgrounding_sources/evidence), or callingchronofact_memory_savewithkey/name+value/claim, now succeed immediately without brittle schema rejections—while still returning full 4-field diagnostics when called empty. - Faster $O(S \cdot T)$ Claim Verification:
FactVerifiernow pre-lowercases and pre-computes IDF weights across grounding sources once per verification batch instead of re-allocating inside the per-claim loop, using Unicode-safe 5-character stem matching. - 13 Enterprise CI/CD Invariant Rules (Including Lean 4 / Coq Proof Soundness): Added
INV-FORMAL-LEAN4-SOUNDNESS(sorry,admit,sorryAx,Admitted.,@[implemented_by],@[extern]), KLS spectral geometry (arXiv:2610.01447) verification, single-line/* ... */comment-prefix bypass detection, and predicate-aware deprecation checks so linters and verifiers can self-audit cleanly (0violations in4.28 mson the 1,406-lineverifier.rs). - Full 10-Field Cryptographic Attestation & Entailed-Only Citations:
AttestationEnginenow binds all 10 audit fields into the canonicalCHRONOFACT-ATTESTATION:v1HMAC-SHA256 payload, andCitationMapperattaches inline[SRC-N]markers strictly toEntailedclaims. - Deeper Security & Multiplexer Hardening: Strips Unicode bidirectional override characters (
U+202A–U+202E,U+2066–U+2069) before prompt-injection scanning, blocks NAT64 (64:ff9b::/96) private IPv4 SSRF embeds, drains oversized>16 MBstdio frames without corrupting subsequent JSON-RPC turns, and prevents 3-way bare tool collisions across multiplexed MCP servers.
USER QUERY
│
┌──────────────────┴──────────────────┐
▼ ▼
[Pillar 4: TF-IDF Router] [Pillar 1: Temporal Radar]
Prunes unneeded MCP tool schemas Calculates Weight Freeze Delta
(Cuts prompt tokens by 70-90%) (Intercepts post-freeze entities)
│ │
▼ ▼
[Prompt Cache Prefix Anchor] [SSRF-Shielded Web Grounding]
Aligned to provider cache boundaries Validates IP/DNS, defangs HTML
│ │
└──────────────────┬──────────────────┘
│
▼
[Pillar 2: Fact Verifier]
Decomposes into Atomic Claims
Runs Lexical & Invariant Rule Checks (<0.15ms)
│
▼
[Pillar 3: Zero-Pollution Memory]
L1: Sliding conversation buffer
L2: Structured episodic session ledger
L3: Semantic Truth Dossier (Relevance Gated)
│
▼
VERIFIED, COST-OPTIMIZED OUTPUT
🔬 In-Depth Pillar Specifications
🕒 Pillar 1: Dynamic Temporal Horizon Calibration & Weibull Hazard Modeling
- Pre-Release Freeze Margin Tracking:
- LLMs have an official knowledge cutoff and an actual weight freeze date (typically 3-6 months earlier).
- Configurable Policy Templates: Google DeepMind Gemini 4 Argon (
gemini-4-argon/google/gemini-4-argon, Release:2026-10-01, Freeze:2026-07-15, Cutoff:2026-08-01), Gemini 3.8 Pro/Flash, OpenAI GPT-6 Astra (Freeze:2026-03-01, Cutoff:2026-04-01), Sol 6.1 (Freeze:2026-03-15, Cutoff:2026-04-15), Anthropic Claude Opus 5.5 (Freeze:2026-03-01), xAI Grok 4.7, Claude 3.5 Sonnet (Status:Retired EOL Oct 2025). - Data-Driven Model Horizon: The model list (ids, aliases, vendor, release / freeze / cutoff dates, status, notes) lives in
data/model_horizon.jsonand is embedded into the binary at compile time (include_str!). SetCHRONOFACT_MODEL_HORIZON=/path/to/model_horizon.json(same schema) to replace the embedded data at startup without recompiling. If that file is missing or invalid, aWARNis logged and the embedded data is used (no panic). - Merge-Style Overrides: After the base data is loaded,
CHRONOFACT_MODELS_OVERRIDE/CHRONOFACT_MODELS_CONFIG/CHRONOFACT_MODELS_JSON(a file path or an inline JSON array of model records) and a localchronofact_models.json/config/models_override.jsonadd or update individual models on top.
- Rust
TemporalScanner& Clause-Scoped Vendor Attribution:- Automatically identifies temporal references, semantic year markers (
2025+vs2024graduated weighting), library major versions, and fast-moving entities. - Clause-Scoped Multi-Vendor Attribution Guard: Splits compound comparison prompts (
vs,versus,compared to,,,;) into independent clauses so legitimate cross-vendor comparisons ("Compare Claude Sonnet 5.5 vs OpenAI GPT-6 Astra") never trigger false vendor misattribution warnings or hijackeffective_model_id. - Weibull Epistemic Hazard Calibration: Incorporates a calibrated Weibull hazard boost for
days_post_freeze > 60when temporal or fast-moving software signals are detected, computingtemporal_risk_score ∈ [0.0, 1.0]. - When
risk ≥ 0.35, the engine triggers real-time grounded web retrieval and injects an un-jammable<chronofact_temporal_anchor>system header.
- Automatically identifies temporal references, semantic year markers (
🛡️ Pillar 2: Active Claim Extraction, Parametric NeuralNliCalibrator & Enterprise Gating
- Atomic Claim Deconstruction:
- Model outputs are split into atomic assertions categorized into
TechnicalApi,VersionCompatibility,TemporalEvent, orFactualAssertion.
- Model outputs are split into atomic assertions categorized into
- Pre-NLI Invariant Cascade &
NeuralNliCalibrator(<0.15ms):- Word-Boundary IDF-Weighted Matching: Evaluates token overlap using strict word boundaries + 5-character stem matching and protects singular
-stechnical nouns (postgres,redis,kubernetes,status,serverless) while normalizing 4-letter (apis$\to$api) and-ies(policies$\to$policy) plurals. - Numeric / Port / Version Conflict Detector & Litotes Guard: Automatically flags
Contradictedwhen overlapping clauses assert conflicting numeric values (e.g.port 9999vsport 5432) and properly resolves double-negation/litotes ("never fails to preserve"$\models$"preserves"). - Temperature-Scaled
NeuralNliCalibrator& Noisy-OR Contradiction Floor: Computes calibrated entailment probabilities via temperature-scaled logistic inference ($T^* = 0.85$) and enforces a non-dilutable Noisy-OR contradiction floor ($1 - (1 - 0.38)^k$) onhallucination_risk_indexso padding with true claims cannot mask a contradiction. - Explicit No-Evidence State: Every report carries
grounding_sources_available(whether anysourceswere supplied) andchecked_claims_count. A claim that was not checked against any source or deterministic invariant is returned asstatus: "Unverified"withconfidence_score: null(no placeholder number).hallucination_risk_indexis computed over checked claims only and isnullwhen no claim was checked. Claims decided by deterministic invariants (e.g. vendor misattribution, retired models, code-invariant violations) keep their real scores even when no sources are supplied.
- Word-Boundary IDF-Weighted Matching: Evaluates token overlap using strict word boundaries + 5-character stem matching and protects singular
CodeInvariantChecker(13-RuleOnceLockPre-Compiled Enterprise Policy Engine):- Audits source code, PR diffs, formal proofs (Lean 4 / Coq), and configuration manifests across Rust, TypeScript/React, Python, Go, C/C++, Lean 4, SQL, and PowerShell using $O(1)$
OnceLock-cached regex automatons:INV-SEC-RAW-SQL: Unparameterized raw SQL string interpolation (Critical - Blocks CI).INV-SEC-EVAL-EXEC: Dynamic code execution / dangerous HTML injection, including single-line block-comment prefix bypasses/* ... */ eval()(Critical - Blocks CI).INV-SEC-HARDCODED-SECRET: Raw bearer tokens, private keys, API secrets (Critical - Blocks CI).INV-ARCH-DAL-LEAK: Presentation/Controller layers directly invoking raw database connections (High).INV-TEMP-DEPRECATED-LIB: Deprecated/EOL dependencies or hardcoded retired AI model identifiers (High).INV-SEC-SSRF-UNCHECKED: Unvalidated external URL dispatch (Medium).INV-ERR-SILENT-FAIL: Silent error swallowing / empty catch blocks (Medium).INV-REL-ASYNC-BLOCKING: Blocking thread sleeps inside async execution paths (Medium).INV-FORMAL-LEAN4-SOUNDNESS: Incomplete formal proof / unproved axiom escapes (sorry,admit,sorryAx,Admitted.,@[implemented_by],@[extern]) in Lean 4 / Coq (Critical - Blocks CI).
- Audits source code, PR diffs, formal proofs (Lean 4 / Coq), and configuration manifests across Rust, TypeScript/React, Python, Go, C/C++, Lean 4, SQL, and PowerShell using $O(1)$
- Cryptographic Attestation Engine (
AttestationEngine):- Generates verifiable SHA-256 HMAC attestation tokens (
CHRONOFACT-ATTESTATION:v1) bindingattestation_id,project_id,target_name,target_sha256,temporal_anchor,verdict,rules_evaluated,violations_count,critical_violations, andhigh_violationsfor automated CI/CD pipeline gating.
- Generates verifiable SHA-256 HMAC attestation tokens (
- Cryptographic Source Provenance:
- Every citation is tied to an immutable SHA-256 chunk hash with sanitized Markdown references.
🧠 Pillar 3: 3-Tier Memory, BM25 + Temporal Decay & Post-Training Flywheel
- L1 (Working Buffer): In-memory sliding turn window for active conversation context.
- L2 (Episodic Session Ledger & KTO/DPO Post-Training Flywheel): SQLite database (
chronofact_memory.db) running in Write-Ahead Logging (WAL) mode withPRAGMA busy_timeout=5000;. Stores immutable session turns, live drift audit logs, and full untruncatedepistemic_trajectoriesandpost_training_pairs(with Kahneman-Tversky loss-aversion weights $\lambda_{\text{U}} = 2.25$ forUNDESIRABLEcontradictions and $\lambda_{\text{D}} = 1.0$ forDESIRABLEentailments). - L3 (Semantic Truth Dossier): Persistent project invariants (
TECH_STACK,ARCH_RULE,DATA_MODEL,RECENT_DECISION, and custom entity types) ranked with BM25 + Exponential Temporal Recency Decay ($\exp(-0.002 \cdot \Delta t_{\text{days}})$). - Adaptive
MemoryCalibrator:- Eliminates brittle hardcoded similarity thresholds. Provides provider-calibrated distributions for OpenAI
text-embedding-3, BGE, Cohere, and local FastEmbed embeddings. - Dynamically calculates relative similarity cutoffs ($\mu + k \cdot \sigma$) using Bessel's sample variance correction ($n - 1$) and a small-sample guard ($n \le 3$) combined with an absolute baseline floor.
- Eliminates brittle hardcoded similarity thresholds. Provides provider-calibrated distributions for OpenAI
- The Zero-Pollution Guard:
- Evaluates both L3 semantic entities and L2 episodic events against query relevance and suppresses empty
<chronofact_project_truth_dossier>XML shells when zero relevant memories match. - Invariant: If the user asks about an unrelated topic, exactly 0 memory tokens are injected, preventing cross-domain degradation.
- Evaluates both L3 semantic entities and L2 episodic events against query relevance and suppresses empty
✂️ Pillar 4: Token Context Bloat & Cost Bleed Prevention (mcplex Technology)
- Intent-Boosted TF-IDF Tool Router:
- Solves the Lexical Mismatch Problem: When users speak idiomatically ("Why won't this compile?", "There's a bug on line 42"), an intent-aware domain dictionary boosts relevant tools ($+0.35$ relevance boost) without requiring exact unigram overlap, while deduplicating identifier sub-tokens and weighting
#stemprefix matches at $0.5$. - Always-Retain Pinning: Critical execution primitives (
read_file,terminal_exec,run_command) can be permanently pinned so aggressive token pruning never strips foundational capabilities. - Prunes irrelevant schemas down to
top_k(typically 3-4 tools), achieving 70%-91% token savings per turn, while extracting realinputSchema.propertiesparameter names.
- Solves the Lexical Mismatch Problem: When users speak idiomatically ("Why won't this compile?", "There's a bug on line 42"), an intent-aware domain dictionary boosts relevant tools ($+0.35$ relevance boost) without requiring exact unigram overlap, while deduplicating identifier sub-tokens and weighting
- Unified
AppState&McpServerRuntime:- The co-hosted HTTP
:3030Cockpit API and MCP stdio server share the exact sameArc<ToolResponseCache>,Arc<CostTracker>, and SQLiteMemoryEngineviaMcpServer::from_app_state, persisting live cost savings across both interfaces.
- The co-hosted HTTP
- Deterministic Prompt Cache Prefix Alignment & Stateless MCP Mode:
- Formats static system instructions, immutable invariant anchors (
[CHRONOFACT_CACHE_ANCHOR:v1:...]), and stable tool schemas into the exact prefix of HTTP proxy prompts while usingSessionMode::StatelessSingleShotin MCP tool responses to avoid artificial padding bloat.
- Formats static system instructions, immutable invariant anchors (
- Idempotent Tool Response Cache with Slash-Aware FQN Invalidation:
- Caches deterministic tool invocations indexed by
SHA-256(tool_name + args)plus filesystemmtime/sizemetadata, and supports per-server invalidation across"server/tool","server:tool", and"server__tool"namespaces.
- Caches deterministic tool invocations indexed by
- CostTracker:
- Tracks live token savings, pruned tool counts, and estimated USD saved based on industry standard baselines ($3.00/1M tokens).
🔒 Defensive Security Architecture
Self-assessed defensive engineering controls verified via automated test suite in docs/SECURITY_AUDIT.md:
- SSRF Outbound Firewall & Package Registry URL Guard: Blocks private networks (RFC 1918:
10.0.0.0/8,172.16.0.0/12,192.168.0.0/16), IPv6 unique local (fc00::/7), loopback (127.0.0.1), and AWS/GCP cloud metadata endpoints (169.254.169.254,metadata.google.internal). Validates third-party packagehomepage/documentationURLs and falls back to canonicalcrates.io/npmjs.com/pypi.orgURLs if untrusted metadata fails SSRF checks. - Signed Context Envelopes: Injects external web evidence inside demarcated
<untrusted_external_evidence envelope_id="..." hmac_nonce="...">envelopes with boundary escape-tag defanging to defeat indirect prompt injection. - 100% Prepared SQL Statements: Zero raw SQL string interpolation. All queries use parameterized queries (
rusqlite::params!). - Filesystem Path Escaping Defense & Workspace Root Discovery: Sandboxes local file accesses using canonical path checking and resolves workspace-root
chronofact_memory.dbeven when launched frombin/, preventing split-brain SQLite instances. - 16 MB Stdio Frame Cap & Loopback-Only Dev Bind: Caps MCP and upstream stdio line reads at
16 MB(MAX_STDIO_LINE_BYTES) to prevent OOM DoS, and binds both the Rust API (127.0.0.1:3030) and Vite dev server (127.0.0.1:5173) strictly to loopback. - Zero Secret Leak Guarantee: Verified by automated regex scanning: 0 API keys, 0 private credentials, and 0 secret tokens in the repository.
🛠️ Antigravity MCP Server Integration
ChronoFact is designed to run seamlessly as an Antigravity MCP Server.
MCP Configuration
Place the following in your Antigravity or MCP client configuration (mcp_config.json):
Windows
{
"mcpServers": {
"chronofact": {
"command": "C:\\chronofact\\bin\\chronofact.exe",
"args": ["mcp"],
"env": {
"CHRONOFACT_DB": "C:\\chronofact\\chronofact_memory.db"
}
}
}
}
Linux / macOS (POSIX)
{
"mcpServers": {
"chronofact": {
"command": "/usr/local/bin/chronofact",
"args": ["mcp"],
"env": {
"CHRONOFACT_DB": "${HOME}/.chronofact/chronofact_memory.db"
}
}
}
}
Binary Isolation Guarantee: On Windows, the runtime binary is deployed to
C:\chronofact\bin\chronofact.exe. Antigravity communicates with this isolated executable, allowing you to runcargo buildintarget/without Windows file locking (os error 5).
Registered MCP Tools
| Tool Name | Parameters | Purpose |
|---|---|---|
chronofact_temporal_check |
model_id, query |
Calculates knowledge cutoff delta and generates temporal calibration anchor. |
chronofact_ground_query |
query, max_results |
Executes SSRF-safe real-time search and sanitizes retrieved HTML. |
chronofact_verify_claims |
response_text, sources (optional) |
Decomposes response into atomic claims and verifies against sources and deterministic invariants. Returns grounding_sources_available, checked_claims_count; unchecked claims have confidence_score: null, and hallucination_risk_index is null when nothing was checked. |
chronofact_verify_code_invariants |
file_path, content, custom_rules |
Audits code/diffs against 13 enterprise security, architectural, temporal & formal-proof invariants. |
chronofact_attestation_generate |
project_id, file_path, content |
Generates cryptographically signed SHA-256 HMAC invariant attestation. |
chronofact_memory_save |
project_id, entity_name, entity_type, definition (all required), version (optional) |
Saves immutable architectural invariant into L3 memory. All required fields are validated up front; one error lists every missing, blank, or non-string field. |
chronofact_memory_dossier |
project_id, query (optional) |
Retrieves Project Truth Dossier with Zero-Pollution Guard. |
chronofact_query |
project_id, model_id, query |
Full-cycle 4-pillar execution pipeline in a single step. |
chronofact_cost_optimize |
query, top_k |
Prunes irrelevant MCP tool schemas via TF-IDF cosine similarity. |
chronofact_cost_metrics |
(none) | Returns real-time tokens saved, USD savings, and tool cache hit rates. |
chronofact_expand_tool_palette |
query_or_category |
Dynamically re-expands and recovers pruned secondary tools during multi-hop reasoning. |
gateway_find_tools |
query |
Discovers available tools across upstream multiplexed MCP servers. |
gateway_call_tool |
name, arguments, passthrough |
Proxies execution to upstream servers with security sanitization and caching. |
gateway_list_servers |
(none) | Lists active upstream servers, connection modes, and health metrics. |
🚦 Enterprise CI/CD Pipeline Gate (check-ci)
ChronoFact includes a headless CLI command for pre-commit hooks, GitHub Actions, and deployment pipelines:
# Evaluate a file or PR diff against enterprise invariants
chronofact check-ci --path src/main.rs
# Evaluate and generate a signed cryptographic attestation token
chronofact check-ci --path src/main.rs --attest
- Exit Code 0: All critical & high enterprise invariants satisfied.
- Exit Code 1: Invariants violated (e.g. unparameterized raw SQL, raw secrets, layer leaks). Deployment blocked immediately.
🌐 REST API Endpoints
When running chronofact serve --port 3030, the following Axum HTTP API is available:
GET /api/health: Healthcheck endpoint returning server status and engine version.GET /api/models: Model Horizon registry (cutoffs, freeze dates, vendor statuses).POST /api/temporal/check: Evaluates query against target model horizon.POST /api/chat/epistemic: Full-cycle epistemic chat turn with claims, citations, and memory.GET /api/memory/dossier/:project_id: Retrieves the Markdown Project Truth Dossier.POST /api/memory/entity: Persists an architectural entity or invariant.GET /api/drift/events: Returns live stream of intercepted outdated knowledge events.GET /api/security/audit: Telemetry on SSRF firewall, injection shields, and database isolation.GET /api/cost/metrics: Real-time session metrics for tokens saved, cache hits, and USD savings.POST /api/cost/route: Simulates TF-IDF tool routing and returns pruned schema stats.
ChronoFact MCP questions
What tools does ChronoFact MCP provide?
It exposes 14 tools, including chronofact_temporal_check, chronofact_ground_query, chronofact_verify_claims, chronofact_verify_code_invariants, chronofact_attestation_generate.
How does ChronoFact handle model knowledge cutoffs?
It uses a Dynamic Temporal Horizon Calibration system that tracks the difference between an LLM's official knowledge cutoff and its actual weight freeze date.
What happens if a claim cannot be verified against a source?
Claims that are not checked against any source or deterministic invariant are returned with a status of 'Unverified' and a null confidence score.
Can I update the model horizon data without recompiling?
Yes, you can replace the embedded model data at startup by setting the CHRONOFACT_MODEL_HORIZON environment variable to a path containing a JSON file.