truthstack-mcp 2.1.0

package/DISCOVERY-QUESTS.md

@@ -0,0 +1,160 @@
+# TruthStack Discovery Quests — Tier 0 (Distribution)
+## Week 1 Execution Checklist
+
+**Philosophy:** The quest isn't just "enrich the database" — it's "go get us discovered."
+Discovery → Adoption → Contribution → Enrichment. You can't skip steps.
+
+---
+
+## Category 1: MCP Directory Submissions
+
+Submit TruthStack MCP server to every directory with rich metadata, health/supplement tags, 
+example prompts, and a link to the GitHub repo.
+
+- [ ] **Official MCP Registry** — registry.modelcontextprotocol.io
+  - Tags: health, supplements, drug-interactions, safety, pharmacology
+  - Description: "First supplement-drug interaction safety tool for AI agents"
+  
+- [ ] **GitHub modelcontextprotocol/servers** — Open PR to add to official list
+  - Category: Health & Safety
+  - Include: description, 5 tools listed, example usage
+  
+- [ ] **Glama.ai** — MCP server directory
+  
+- [ ] **MCPServerHub** — Community directory
+  
+- [ ] **Awesome MCP Servers** — GitHub awesome list (multiple repos)
+  - Search GitHub for "awesome-mcp-servers" — submit to all active ones
+  
+- [ ] **Smithery** — MCP server registry
+  
+- [ ] **Kong MCP** — If directory exists by launch
+
+**Target: 5-7 directory listings in week 1**
+
+---
+
+## Category 2: Framework Presence
+
+Working code examples posted where agent developers find tools.
+
+- [ ] **GitHub repo: truthstack-example-health-agent**
+  - Claude Desktop config + working demo
+  - LangChain tool wrapper with example script
+  - README with setup in <5 minutes
+  
+- [ ] **LangChain community** — Post example in LangChain Discord/forums
+  - Title: "Supplement safety tool for health agents"
+  - Include working code snippet
+  
+- [ ] **CrewAI community** — Post example agent that uses TruthStack
+  - "Health Safety Agent" that checks stacks before recommending
+
+- [ ] **AutoGen/LlamaIndex** — GitHub gist with integration example (week 2)
+
+**Target: 3 framework examples published by end of week 2**
+
+---
+
+## Category 3: GitHub Outreach
+
+Find health AI agent repos and suggest TruthStack integration.
+
+- [ ] Search GitHub: "health agent" "supplement" — find active repos
+- [ ] Search GitHub: "langchain health" "crewai health" — find health-focused agent projects
+- [ ] Search GitHub: "medication" "drug interaction" "ai agent" — find adjacent projects
+- [ ] For each active repo (>10 stars, recent commits):
+  - Open a constructive issue: "Supplement safety integration available"
+  - Include: what TruthStack does, how to integrate (3 lines), link to example repo
+  - **DO NOT spam.** Only repos where supplement safety is genuinely useful.
+
+**Target: 5-10 constructive GitHub issues/PRs opened**
+
+---
+
+## Category 4: Content Seeding
+
+Technical posts that show up in developer searches.
+
+- [ ] **Blog post:** "Why your health AI agent needs a real interaction database"
+  - Host on truthstack.co/blog or Medium
+  - Include the demo contrast (LLM vs API)
+  - Target keywords: "supplement drug interaction API", "health AI agent safety"
+  
+- [ ] **dev.to post:** Technical walkthrough of MCP integration
+  - Tags: #ai #health #mcp #agents
+  
+- [ ] **Reddit r/AI_Agents** — Share the MCP server with context
+  - Not promotional — frame as "I built this, feedback welcome"
+  
+- [ ] **Hacker News** — "Show HN: Supplement safety API for AI agents"
+  - Best timing: Tuesday or Wednesday morning US time
+  - Lead with the demo contrast (LLM hallucination vs structured API)
+  
+- [ ] **X/Twitter thread:** "We built the first supplement safety MCP server. Here's why LLMs can't do this alone."
+  - Tag: @AnthropicAI, @LangChainAI, MCP community accounts
+  - Include screenshot of Claude Desktop using TruthStack tools
+
+- [ ] **LinkedIn post:** Same angle, targeting health tech founders and VCs
+
+**Target: 3-5 posts published by end of week 2**
+
+---
+
+## Category 5: Community Infiltration
+
+Join where health AI builders already hang out.
+
+- [ ] **Health AI Discord servers** — Search Disboard for health AI communities
+- [ ] **LangChain Discord** — #showcase or #tools channel
+- [ ] **Anthropic Discord** — #mcp-servers channel (if exists)
+- [ ] **Digital health Slack groups** — Rock Health, Health 2.0, etc.
+- [ ] **Product Hunt upcoming** — Set up the PH page now, schedule for weeks 8-10
+
+**Target: 3 communities joined, at least 1 meaningful post in each**
+
+---
+
+## Tracking
+
+| Quest | Status | Date Completed | Notes |
+|-------|--------|----------------|-------|
+| Official MCP Registry | | | |
+| GitHub MCP servers PR | | | |
+| Glama.ai | | | |
+| MCPServerHub | | | |
+| Awesome MCP lists | | | |
+| Smithery | | | |
+| GitHub example repo | | | |
+| LangChain example | | | |
+| CrewAI example | | | |
+| Blog post | | | |
+| dev.to post | | | |
+| Reddit post | | | |
+| HN Show HN | | | |
+| X thread | | | |
+| LinkedIn post | | | |
+| GitHub outreach (5-10) | | | |
+| Community joins (3+) | | | |
+
+---
+
+## Week 1 Target: 20 discovery touchpoints
+
+If you hit 20 places where a health AI builder can stumble onto TruthStack without 
+you doing cold outreach, you've given the flywheel its first real spin.
+
+## Phase 2 (Weeks 5-8): Adoption Quests
+Agents already using the API get nudged to:
+- Report unresolved compound names
+- Test edge cases and provide feedback
+- Share their integration publicly
+
+## Phase 3 (Weeks 9-12): Enrichment Quests  
+Agents contribute real data:
+- New aliases from user input
+- Label scan extractions
+- Stack patterns and outcomes
+- PubMed article summaries
+
+**Discovery first. Contribution follows usage.**

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TruthStack1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,172 @@
+# TruthStack MCP Server
+
+**The first supplement-drug interaction safety tool for AI agents.**
+
+TruthStack provides structured, evidence-based supplement safety intelligence via the [Model Context Protocol](https://modelcontextprotocol.io). Instead of relying on LLM training data that hallucinates safety information, your agent calls TruthStack for deterministic, cited risk assessments.
+
+## Why This Exists
+
+LLMs confidently say "ashwagandha is generally safe with sertraline." TruthStack's API returns **MODERATE RISK** with 25 FDA adverse event reports and CYP3A4 pathway conflict data. That gap kills people.
+
+## 5 Tools
+
+| Tool | What It Does | When to Use |
+|------|-------------|-------------|
+| `check_interactions` | Supplements + medications → risk level, FAERS signals, CYP conflicts | User mentions supplements + meds together |
+| `search_compounds` | Fuzzy name search (584 aliases, handles misspellings/brands) | Need to resolve messy input ("mag gly", "KSM-66") |
+| `get_compound_info` | Full compound profile + all interactions | Deep dive on a specific supplement |
+| `explain_interaction` | Human-readable WHY — mechanism, severity, evidence summary | Need to explain risk to a user |
+| `get_evidence` | Raw evidence: FAERS counts, CYP data, research grades, label warnings | Need to cite sources or provide provenance |
+
+## Data Sources
+
+- **FDA FAERS** — 805 adverse event signals from real-world pharmacovigilance
+- **FDA Drug Labels** — CYP450 pathways, contraindications, botanical warnings
+- **PubMed/ClinicalTrials.gov** — 220 research findings with evidence grading
+- **584 compound aliases** — misspellings, brand names, abbreviations, product forms
+
+## Quick Start
+
+### 1. Get API Key
+
+Contact [chris@truthstack.co](mailto:chris@truthstack.co) or visit [truthstack.co](https://truthstack.co)
+
+### 2. Install
+
+```bash
+git clone https://github.com/truthstack/truthstack-mcp.git
+cd truthstack-mcp
+npm install
+```
+
+### 3. Configure Claude Desktop
+
+Edit `~/.claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "truthstack": {
+      "command": "node",
+      "args": ["/path/to/truthstack-mcp/server.js"],
+      "env": {
+        "VAULT_API_URL": "https://api.truthstack.co",
+        "VAULT_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop. You'll see TruthStack tools available in the tool picker.
+
+### 4. Test It
+
+Ask Claude: *"I take ashwagandha, fish oil, and magnesium with sertraline. Is this safe?"*
+
+Claude will call `check_interactions` and return a structured risk assessment with FDA adverse event data.
+
+## LangChain Integration
+
+```python
+from langchain_community.tools import MCPTool
+
+# If using MCP adapter
+truthstack = MCPTool(server_path="./server.js", env={
+    "VAULT_API_URL": "https://api.truthstack.co",
+    "VAULT_API_KEY": "your-key"
+})
+
+# Or call the REST API directly
+import requests
+
+response = requests.post(
+    "https://api.truthstack.co/api/interactions/check",
+    headers={"X-API-Key": "your-key"},
+    json={
+        "supplements": ["ashwagandha", "fish oil", "magnesium"],
+        "medications": ["sertraline"]
+    }
+)
+print(response.json())
+```
+
+## REST API Fallback
+
+Every MCP tool maps to a REST endpoint:
+
+| MCP Tool | REST Endpoint |
+|----------|---------------|
+| `check_interactions` | `POST /api/interactions/check` |
+| `search_compounds` | `GET /api/compounds/search?q={query}` |
+| `get_compound_info` | `GET /api/compounds/{id}` + `GET /api/compounds/{id}/interactions` |
+| `explain_interaction` | Composite (search + interactions + drug profile) |
+| `get_evidence` | Composite (search + interactions + drug profile) |
+
+Base URL: `https://api.truthstack.co`
+Auth: `X-API-Key` header
+
+## Example Response
+
+```
+User: "Is ashwagandha safe with sertraline?"
+
+→ check_interactions({
+    supplements: ["ashwagandha"],
+    medications: ["sertraline"]
+  })
+
+→ {
+    "risk_level": "MODERATE",
+    "drug_interactions": [{
+      "supplement": "ashwagandha",
+      "drug": "sertraline",
+      "severity": "MODERATE",
+      "source": "FDA FAERS",
+      "report_count": 25,
+      "description": "Pharmacovigilance signal — 25 serious adverse events reported"
+    }],
+    "cyp_pathway_conflicts": [{
+      "drug": "sertraline",
+      "supplement": "ashwagandha",
+      "shared_cyp_pathways": ["CYP3A4"]
+    }]
+  }
+```
+
+Compare to raw LLM: *"Ashwagandha is generally considered safe and may complement sertraline for anxiety."*
+
+## System Message Template
+
+If you're building a health agent, add this to your system prompt:
+
+```
+You have access to TruthStack supplement safety tools. ALWAYS use check_interactions 
+before confirming any supplement is safe with a medication. Never rely on your training 
+data for drug-supplement interaction safety — use the structured API instead.
+
+When reporting results:
+- State the risk level clearly (CRITICAL/HIGH/MODERATE/LOW)
+- Mention specific FAERS adverse event counts when available
+- Note CYP pathway conflicts
+- Always recommend consulting a healthcare provider for MODERATE+ risks
+- Use explain_interaction when users ask "why is this risky?"
+- Use get_evidence when users want to see the sources
+```
+
+## Contributing
+
+We're looking for:
+- **Integration partners** — building a health AI agent? Get free API access.
+- **Compound contributions** — know of missing supplement aliases or interactions? Open an issue.
+- **Framework examples** — help us add examples for CrewAI, AutoGen, LlamaIndex.
+
+## License
+
+MIT
+
+## Contact
+
+- **API access**: [chris@truthstack.co](mailto:chris@truthstack.co)
+- **Website**: [truthstack.co](https://truthstack.co)
+- **API docs**: [api.truthstack.co](https://api.truthstack.co)

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "truthstack-mcp",
+  "version": "2.1.0",
+  "description": "TruthStack MCP Server \u2014 Supplement-drug interaction safety intelligence for AI agents",
+  "type": "module",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.22.0"
+  },
+  "keywords": [
+    "mcp",
+    "supplements",
+    "drug-interactions",
+    "health",
+    "safety",
+    "ai-agents",
+    "truthstack"
+  ],
+  "author": "TruthStack Inc.",
+  "license": "MIT",
+  "bin": {
+    "truthstack-mcp": "./server.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TruthStack1/truthstack-mcp.git"
+  },
+  "homepage": "https://api.truthstack.co"
+}

package/server.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+const VAULT_API_URL = process.env.VAULT_API_URL || "https://api.truthstack.co";
+const VAULT_API_KEY = process.env.VAULT_API_KEY;
+if (!VAULT_API_KEY) { console.error("ERROR: VAULT_API_KEY required"); process.exit(1); }
+
+async function vaultFetch(path, options = {}) {
+  const r = await fetch(`${VAULT_API_URL}${path}`, { ...options, headers: { "X-API-Key": VAULT_API_KEY, "Content-Type": "application/json", ...options.headers } });
+  if (!r.ok) { const t = await r.text(); throw new Error(`Vault API error ${r.status}: ${t}`); }
+  return r.json();
+}
+async function searchCompounds(q, limit = 10) { return vaultFetch(`/api/compounds/search?q=${encodeURIComponent(q)}&limit=${limit}`); }
+async function getCompound(id) { return vaultFetch(`/api/compounds/${encodeURIComponent(id)}`); }
+async function getCompoundInteractions(id) { return vaultFetch(`/api/compounds/${encodeURIComponent(id)}/interactions`); }
+async function checkInteractions(supps, meds) { return vaultFetch("/api/interactions/check", { method: "POST", body: JSON.stringify({ supplements: supps, medications: meds }) }); }
+async function getDrugProfile(id) { return vaultFetch(`/api/drugs/${encodeURIComponent(id)}`); }
+
+async function buildExplanation(supplementName, drugName) {
+  const sr = await searchCompounds(supplementName, 1);
+  const compound = sr?.results?.[0];
+  if (!compound) return { supplement: supplementName, drug: drugName, explanation: `Could not resolve "${supplementName}".`, severity: "UNKNOWN", confidence: "low" };
+  const compoundId = compound.compound_id;
+  const interactions = await getCompoundInteractions(compoundId);
+  const di = (interactions?.interactions || []).filter(i => i.target_id?.toLowerCase().includes(drugName.toLowerCase()) || i.target_name?.toLowerCase().includes(drugName.toLowerCase()));
+  let drugProfile = null;
+  try { drugProfile = await getDrugProfile(drugName.toLowerCase().replace(/\s+/g, "_")); } catch(e) {}
+  if (di.length === 0 && !drugProfile) return { supplement: supplementName, drug: drugName, resolved_compound: compoundId, explanation: `No known interactions found between ${compound.name} and ${drugName}. This does not guarantee safety.`, severity: "LOW", confidence: "low", evidence_count: 0 };
+  const faers = di.filter(i => i.source_origin === "OPENFDA");
+  const research = di.filter(i => i.source_origin !== "OPENFDA");
+  const totalFaers = faers.reduce((s, f) => s + (f.metadata?.report_count || 0), 0);
+  let severity = "LOW";
+  const sevs = di.map(i => i.severity);
+  if (sevs.includes("CRITICAL")) severity = "CRITICAL";
+  else if (sevs.includes("HIGH") || sevs.includes("MAJOR")) severity = "HIGH";
+  else if (sevs.includes("MODERATE")) severity = "MODERATE";
+  let cypMech = "";
+  if (drugProfile?.profile?.cyp_pathways) {
+    const cyps = drugProfile.profile.cyp_pathways;
+    const allDrug = [...(cyps.metabolized_by||[]),...(cyps.inhibits||[]),...(cyps.induces||[])];
+    const cd = await getCompound(compoundId);
+    const compCyps = cd?.compound?.data?.cyp_pathways || [];
+    const shared = [...new Set(allDrug.filter(c => compCyps.includes(c)))];
+    if (shared.length > 0) cypMech = `Shared CYP450 pathway(s): ${shared.join(", ")}. ${compound.name} may alter how ${drugName} is metabolized.`;
+  }
+  const parts = [`Interaction between ${compound.name} and ${drugName}:`, `Severity: ${severity}`];
+  if (totalFaers > 0) parts.push(`FDA Adverse Event Reports: ${totalFaers} serious report(s) in FAERS.`);
+  if (cypMech) parts.push(`Mechanism: ${cypMech}`);
+  const mechs = research.map(i => i.mechanism || i.description).filter(Boolean);
+  if (mechs.length > 0) parts.push(`Research: ${mechs.join(". ")}`);
+  const recs = [...new Set(di.map(i => i.recommendation).filter(Boolean))];
+  if (recs.length > 0) parts.push(`Recommendation: ${recs.join(". ")}`);
+  return { supplement: supplementName, drug: drugName, resolved_compound: compoundId, compound_name: compound.name, severity, explanation: parts.join("\n\n"), confidence: totalFaers > 10 ? "high" : totalFaers > 0 ? "medium" : "low", evidence_count: di.length, faers_report_count: totalFaers, has_cyp_conflict: cypMech !== "" };
+}
+
+async function buildEvidence(supplementName, drugName) {
+  const sr = await searchCompounds(supplementName, 1);
+  const compound = sr?.results?.[0];
+  if (!compound) return { supplement: supplementName, drug: drugName, evidence_items: [], error: `Could not resolve "${supplementName}".` };
+  const compoundId = compound.compound_id;
+  const interactions = await getCompoundInteractions(compoundId);
+  const di = (interactions?.interactions || []).filter(i => i.target_id?.toLowerCase().includes(drugName.toLowerCase()) || i.target_name?.toLowerCase().includes(drugName.toLowerCase()));
+  let drugProfile = null;
+  try { drugProfile = await getDrugProfile(drugName.toLowerCase().replace(/\s+/g, "_")); } catch(e) {}
+  const items = [];
+  for (const s of di.filter(i => i.source_origin === "OPENFDA")) {
+    items.push({ type: "FAERS_SIGNAL", source: "FDA FAERS", description: `${s.metadata?.report_count || 0} serious adverse event reports`, severity: s.severity, report_count: s.metadata?.report_count || 0, signal_score: s.combined_confidence, caveat: "FAERS reports are voluntary and do not prove causation." });
+  }
+  for (const f of di.filter(i => i.source_origin !== "OPENFDA")) {
+    items.push({ type: "RESEARCH_FINDING", source: f.source_origin || "Research", description: f.mechanism || f.description || "Interaction documented", severity: f.severity, evidence_grade: f.evidence_grade || "not_graded", recommendation: f.recommendation || null });
+  }
+  if (drugProfile?.profile?.cyp_pathways) {
+    const cyps = drugProfile.profile.cyp_pathways;
+    const cd = await getCompound(compoundId);
+    const compCyps = cd?.compound?.data?.cyp_pathways || [];
+    const allDrug = [...(cyps.metabolized_by||[]),...(cyps.inhibits||[]),...(cyps.induces||[])];
+    const shared = [...new Set(allDrug.filter(c => compCyps.includes(c)))];
+    if (shared.length > 0) items.push({ type: "CYP_PATHWAY_CONFLICT", source: "FDA drug label + compound data", shared_pathways: shared, clinical_significance: "Shared CYP pathways may alter drug metabolism." });
+  }
+  return { supplement: supplementName, drug: drugName, resolved_compound: compoundId, compound_name: compound.name, evidence_items: items, total_evidence_count: items.length, evidence_types: [...new Set(items.map(e => e.type))] };
+}
+
+const server = new Server({ name: "truthstack", version: "2.1.0" }, { capabilities: { tools: {} } });
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    { name: "check_interactions", description: "Check if supplements are safe with medications. Returns risk level, FDA adverse event data, CYP450 conflicts. Use when user mentions supplements + meds.", inputSchema: { type: "object", properties: { supplements: { type: "array", items: { type: "string" }, description: "Supplement names (handles brands, abbreviations, misspellings)" }, medications: { type: "array", items: { type: "string" }, description: "Medication names (generic or brand)" } }, required: ["supplements", "medications"] } },
+    { name: "search_compounds", description: "Fuzzy search for supplement compounds. 584 aliases across 95 compounds. Resolves misspellings, brands, abbreviations.", inputSchema: { type: "object", properties: { query: { type: "string", description: "Search query" }, limit: { type: "number", description: "Max results (default 5)" } }, required: ["query"] } },
+    { name: "get_compound_info", description: "Get detailed compound profile with interactions, research findings, and aliases.", inputSchema: { type: "object", properties: { compound_id: { type: "string", description: "Compound ID from search_compounds" } }, required: ["compound_id"] } },
+    { name: "explain_interaction", description: "Human-readable explanation of WHY an interaction is risky. Returns mechanism, severity, evidence summary.", inputSchema: { type: "object", properties: { supplement: { type: "string", description: "Supplement name" }, drug: { type: "string", description: "Drug name" } }, required: ["supplement", "drug"] } },
+    { name: "get_evidence", description: "Raw evidence bundle: FAERS counts, CYP data, research grades, label warnings. For citing sources.", inputSchema: { type: "object", properties: { supplement: { type: "string", description: "Supplement name" }, drug: { type: "string", description: "Drug name" } }, required: ["supplement", "drug"] } },
+    { name: "get_safety_signals", description: "Get FDA adverse event safety signals (CAERS) for a supplement. Returns PRR analysis, signal strength, category alerts for hepatic/cardiac/bleeding/renal risks.", inputSchema: { type: "object", properties: { compound: { type: "string", description: "Supplement name (e.g. turmeric, kava, green_tea_extract)" } }, required: ["compound"] } },
+  ]
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+  try {
+    let result;
+    switch (name) {
+      case "check_interactions":
+        if (!args.supplements || !args.medications) return { content: [{ type: "text", text: JSON.stringify({ error: "Provide 'supplements' (array) and 'medications' (array)", example: { supplements: ["ashwagandha"], medications: ["sertraline"] } }) }], isError: true };
+        result = await checkInteractions(args.supplements, args.medications);
+        break;
+      case "search_compounds":
+        if (!args.query) return { content: [{ type: "text", text: JSON.stringify({ error: "Provide 'query' string" }) }], isError: true };
+        result = await searchCompounds(args.query, args.limit || 5);
+        break;
+      case "get_compound_info":
+        if (!args.compound_id) return { content: [{ type: "text", text: JSON.stringify({ error: "Provide 'compound_id'" }) }], isError: true };
+        const [comp, ints] = await Promise.all([getCompound(args.compound_id), getCompoundInteractions(args.compound_id)]);
+        result = { ...comp, interactions: ints?.interactions || [] };
+        break;
+      case "explain_interaction":
+        if (!args.supplement || !args.drug) return { content: [{ type: "text", text: JSON.stringify({ error: "Provide 'supplement' and 'drug'" }) }], isError: true };
+        result = await buildExplanation(args.supplement, args.drug);
+        break;
+      case "get_evidence":
+        if (!args.supplement || !args.drug) return { content: [{ type: "text", text: JSON.stringify({ error: "Provide 'supplement' and 'drug'" }) }], isError: true };
+        result = await buildEvidence(args.supplement, args.drug);
+        break;
+      case "get_safety_signals":
+        if (!args.compound) return { content: [{ type: "text", text: JSON.stringify({ error: "Provide compound string" }) }], isError: true };
+        result = await vaultFetch("/api/safety/profile/" + encodeURIComponent(args.compound));
+        break;
+      default:
+        return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (error) {
+    return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("TruthStack MCP Server v2 running (6 tools, stdio transport)");
+}
+main().catch(e => { console.error("Fatal:", e); process.exit(1); });