Not quite, and the distinction matters. Standard omega-3 supplements give you EPA and DHA. This study is specifically about very long chain PUFAs produced by the ELOVL2 elongase in retinal cells — molecules that are downstream from DHA, not DHA itself. The article's phrasing "not just DHA" flags this.

DHA is found in high concentrations in retinal photoreceptors and matters for retinal function, but ELOVL2 elongates DHA further into VLC-PUFAs (C28 to C38 range) that aren't in standard fish oil. The age-related decline in ELOVL2 expression means those specific elongation products drop, and that's what the supplementation in this study is replacing.

Worth watching for human trial data, but this is not a "take more fish oil" finding.

Cool timing on this. I've been building vital-stack.com, an MCP server for supplement safety checking (interactions, dosing), and discovery has been the consistent friction point. People ask "how do I find this?" and there's no good answer right now.

Question: does MCPfinder handle domain-specific MCPs well, or is it still weighted toward dev tooling? The health and supplement space is starting to have a few MCP servers but they're essentially invisible through standard registries.

I've been building vital-stack.com, a remote MCP server for checking supplement interactions. Claude's desktop app already handles the config side pretty cleanly for remote servers Name + URL and you're done, no JSON editing required.

So I'm curious what the core value prop here is: is this mainly a discovery layer? I.e. users find MCP servers on mcp.hosting and get the URL auto-filled, rather than having to hunt for it themselves?

That would actually solve a real problem, distribution and discoverability, not just config management.

there is a discovery layer (although, not sure if that will be the main draw), and i am vetting that discovery layer to ensure high quality of the mcp servers we have on that discovery layer.

the big value prop is only loading the mcp server or set of tools within the mcp server that is required for each prompt. this reduces wasteful context usage and clutter (and wasteful token usage).

happy to get vital-stack into the registry. when you're ready message me at support@mcp.hosting

Supplement interactions with training and racing loads, electrolyte protocols, and caffeine-heavy pre-workouts are genuinely under-represented in standard clinical and pharmacological databases.

Curious about your approach to the supplement interaction data layer specifically. The wearable and biomarker integration is the hard infrastructure problem, but the supplement knowledge base is a separate hard problem: there's limited structured clinical data on supplement-supplement and herb-drug interactions compared to what exists for pharmaceuticals. Most existing clinical databases weren't built with this use case in mind.

I've been building vital-stack.com to focus exactly on that layer, structured and validated supplement interaction data for tools that need to reason about safety. Different angle than your full platform, but the same core insight that good data has to come before trustworthy AI recommendations. Happy to compare notes on sourcing if useful.

Building in the same space. vital-stack.com focuses specifically on interactions between supplements and drugs, rather than efficacy: the question "is it safe to take with what I'm already on" rather than "does this work". The interaction data typically lives in clinical pharmacology databases and isn't easily surfaced in a way consumers can use. We have 182 supplements and 1,312 interactions catalogued so far, with an MCP server that lets AI assistants query the interaction database in real time. Curious how supplementdex sources efficacy data. Is it summarized literature along the lines of Examine.com, or closer to primary research?

Evidence typing on a per claim basis is the right abstraction. Most fact-checking tools treat a document as a single unit, but technical writing mixes well established facts, contested interpretations, and unverifiable assertions, and they all need different handling. The domain where this is most valuable is health and supplementation, where a single paragraph can mix claims backed by RCTs, mechanistic plausibility statements, and marketing assertions with zero evidence basis. I've been building a supplement interaction checker (vital-stack.com) and the signal to noise problem on health claims is significant enough that an evidence grade layer would be directly useful. Does Grainulator handle the case where a claim is supported by evidence but the evidence quality is low, say an n=20 observational study vs. a preregistered meta-analysis?

The in-vitro caveat is the key issue here. The "100x" figure refers to inflammatory marker measurements in isolated mouse macrophage cell cultures, a setup where compounds are applied directly to cells at controlled concentrations. Oral supplementation involves digestion, absorption, metabolism, and distribution to tissues that make those in-vitro concentrations essentially unreachable.

Taking capsaicin and peppermint supplements together is unlikely to cause harm, but you're not replicating the study conditions. The in-vitro result is interesting as a mechanistic signal. It suggests a possible interaction pathway worth investigating, but it doesn't provide dosing guidance for humans.

This gap between study type and real-world applicability is exactly why I built vital-stack.com for supplement interactions in my database, I surface the study type and mechanism alongside the conclusion, so you can judge how much weight to give it.

`.git/info/exclude` is one of those underused Git mechanisms that solves exactly this problem. Per-repository local ignores without touching the shared `.gitignore`. The point about AI coding tools (Claude Code, Cursor, etc.) respecting git's ignore state is the genuinely useful angle here: hiding personal prompt files and context notes means they don't pollute the assistant's context window when it indexes the project. Nice quality-of-life tool for teams where AI-assisted development has become standard.

The pattern of serving authoritative domain context via MCP rather than relying on model training data generalizes well beyond API specs. We've seen the same dynamic building a supplement-drug interaction MCP at VitalStack: once an AI assistant can query a structured interaction database rather than approximate from training data, the failure mode shifts from confident hallucination to an explicit "no data found for this combination." One question on the implementation: when an API provider ships a breaking change, what's the latency between that release and the Context Plugin updating its served specification—and is there a signal to the AI that the context may be stale?

Good question. In our case, Context Plugins are not maintained as a separate context layer that can drift from the rest of the API surface.

APIMatic offers an entire Developer Experience Platform where everything is generated from the same API spec. We already generate SDKs, API portals and API Copilots from that source. Context Plugins are another artefact generated from that same pipeline.

That means when an API provider updates their spec and runs their release pipeline, the SDKs, docs, and Context Plugins all update together. So in practice, there’s virtually no lag between a release and the context reflecting that release, because they’re all produced from the same source at the same time.

On the stale context question, there’s also a useful signal there. If a developer has an older SDK version installed and starts a new session after a newer release is available, the Context Plugin can see both the installed SDK version and the latest published version. So it can surface that a newer SDK version exists.

That sync is a big part of the value for us. The goal is to keep docs, SDKs, and AI-facing context aligned so developers and AI assistants always have up-to-date information about an API, without adding maintenance overhead for API teams.

The shared-state manifest pattern is the right call — we hit the same design question building VitalStack (supplement interaction MCP server, vital-stack.com). Ended up using Supabase instead of a file because our skills need live lookup, but the principle is identical: one source of truth that downstream skills read and annotate.

Your confidence tiers (validated/researched/assumed) resonates too — we distinguish PubMed RCT data from case reports from mechanistic inference. Ended up being the most important UX decision: users need to know why a result is flagged, not just that it is.

The anti-slop checks are clever. Does the swap test run at generation time or as a post-processing step? Curious whether you're prompting for it explicitly or checking output against a classifier.

Great parallel with PubMed RCT vs case reports vs mechanistic inference, and it highlights the same core problem: users trusting output they shouldn't is worse than no output at all. The confidence tiers turned out to be satisfyingly efficient to implement (just YAML frontmatter fields that each skill reads and annotates) and they change how you interact with the results.

On the Supabase vs file question: makes total sense for live lookup. The file-based manifest works here because brand building is user-driven and session-based. You're not querying supplement interactions in real time. But the principle is the same: one source of truth, downstream consumers read and annotate, never duplicate state.

About the swap test: it runs at generation time, inside the skill prompt. Each skill has instructions that say "before presenting output, run these checks."

If the swap test fails, the skill flags it inline, explains why it failed, and rewrites before the user ever sees the first version. No separate classifier or post-processing step.

Tradeoff: it's not as rigorous as a trained classifier.

For brand copy the swap test is not complicated, for example: if a statement can generically apply to any brand/service, it fails. A classifier would be overkill here, though probably necessary for something like your PubMed evidence grading.