oak-longevity-mcp-server
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@oak-longevity-mcp-serverCheck interactions between rapamycin and simvastatin"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
oak-longevity-mcp-server
An MCP server for longevity & metabolic medicine — a medication catalog, evidence-based dosing protocols, contraindication screening, drug-interaction checks, required baseline labs, ongoing monitoring plans, FDA/compounding regulatory status, and patient-intake pathway suggestions across 35 compounds.
Built for Oak Longevity Institute by Keith Schmidt, MD — a telemedicine longevity practice in Illinois. This server makes the practice's clinical reference data available to any MCP client (Claude Desktop, Claude Code, or your own agent), and is structured for a free/premium monetization model.
⚠️ Clinical decision-support, not medical advice. All output must be reviewed by a licensed clinician. Many longevity compounds here are used off-label, are compounded, or are investigational/not FDA-approved. Dosing, contraindication, interaction, lab, and regulatory data change frequently — always verify against current primary literature, FDA/DEA resources, and your state board of pharmacy.
What it does
Tool | Tier | Description |
| Free | Full medication catalog grouped by category, with ids, drug class, and DEA/Rx schedule. |
| Free | Mechanism, formulations, who it's for / not for, and schedule for one medication. |
| Free | FDA approval status, DEA schedule, 503A/503B compounding considerations, approved uses, off-label notes. |
| Premium | Evidence-based dosing: route, start, titration, maintenance, max, evidence grade, pearls — by indication. |
| Premium | Recommended baseline labs/assessments before prescribing, grouped by panel with rationale. |
| Premium | Ongoing monitoring schedule — what to check, interval, and action/threshold. |
| Premium | Screens a medication against a patient profile (age, sex, conditions, meds) → PASS / FLAG / REJECT with the triggering findings. |
| Premium | Pairwise interaction warnings across a medication list, ranked by severity, with mechanism + management. |
| Premium | Maps a patient's symptoms/goals to suggested treatment pathways with first-line + adjunct medications and workup. |
The eight categories: Weight Management, Peptide Therapy, Hormone Optimization, Longevity & Metabolic, Sexual Health, Immune & Inflammation, Hair Restoration, Dermatology.
Every tool accepts a medication as a name, id, or brand/alias (e.g. "Tirzepatide", "tirzepatide", "Mounjaro", or "copper peptide" → GHK-Cu). Unrecognized queries return "did you mean" suggestions.
Compounds covered
Semaglutide · Tirzepatide · Liraglutide · Naltrexone/Bupropion · BPC-157 · Sermorelin · CJC-1295/Ipamorelin · Ipamorelin · Tesamorelin · Thymosin Beta-4 (TB-500) · Testosterone (cypionate & cream) · Estradiol · Progesterone · DHEA · Anastrozole · Pregnenolone · hCG · NAD+ · Metformin · Rapamycin · Berberine · Resveratrol · NMN · PT-141 · Oxytocin · Tadalafil · Sildenafil · Thymosin Alpha-1 · Glutathione · Low-Dose Naltrexone · Finasteride · Oral Minoxidil · GHK-Cu · Tretinoin.
Related MCP server: MediLinkAI
Install & build
git clone <repo> longevity-mcp-server
cd longevity-mcp-server
npm install
npm run build # compile TypeScript → dist/ and copy data
npm run smoke # end-to-end test (optional)The clinical data ships as JSON in src/data/ and is copied into dist/data/ at build.
Use with Claude Desktop
Add to claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"oak-longevity": {
"command": "node",
"args": ["/absolute/path/to/longevity-mcp-server/dist/index.js"],
"env": { "LONGEVITY_LICENSE_KEY": "OAK-XXXX-XXXX-XXXX" }
}
}
}Restart Claude Desktop. You can then ask things like:
"List the peptide therapy options."
"What's the dosing protocol for tirzepatide for weight loss?"
"Can I prescribe tadalafil to a 60-year-old man taking nitroglycerin?"
"Check interactions between rapamycin, simvastatin, and clarithromycin."
"What baseline labs do I need before starting testosterone?"
"A patient reports fatigue, low libido, and wants to lose weight — what pathways fit?"
See examples/claude_desktop_config.json for an npx variant.
Use with Claude Code
claude mcp add oak-longevity -- node /absolute/path/to/longevity-mcp-server/dist/index.jsInspect locally
npm run inspect # opens the MCP Inspector against the stdio serverRemote hosting (HTTP / SSE)
The same tools are served over Streamable HTTP for remote deployment (MCPize, a VPS, or serverless):
npm run build
PORT=3000 node dist/http.js
# → POST http://localhost:3000/mcp (GET /health for a liveness check)The HTTP transport is stateless and multi-tenant: the per-customer license key is read from a request header, so a single deployment can serve many customers.
X-Oak-License: OAK-XXXX-XXXX-XXXX (preferred)
Authorization: Bearer OAK-XXXX-XXXX-XXXX (also accepted)Monetization & licensing
The server has a built-in free / premium split designed to be wired to a billing provider (Stripe, MCPize) with minimal change.
Free tier:
get_medication_list,get_medication_details,get_fda_status— the catalog and regulatory reference.Premium tier: the clinical decision-support engine — dosing protocols, baseline labs, monitoring plans, contraindication screening, drug-interaction checks, and intake pathway suggestions.
Premium tools remain discoverable (they appear in tools/list so clients can advertise the upgrade), but calling one without a valid entitlement returns an upgrade prompt instead of data.
Entitlement resolution
Configured via environment variables (stdio) or request headers (HTTP):
Variable | Purpose |
| The customer's license key. |
| Force |
| Comma-separated allowlist of keys treated as valid premium (manual provisioning / testing). |
| Optional HTTP endpoint for remote key verification. When set, keys are validated against this service instead of locally. |
A locally-issued key matches the format OAK-XXXX-XXXX-XXXX. For production, point LONGEVITY_LICENSE_VERIFY_URL at your billing webhook; it should accept { "key": "..." } and return { "valid": true, "tier": "premium", "expiresAt": "..." }.
The verification layer lives entirely in src/licensing.ts behind a LicenseProvider interface — swap the implementation without touching any tool.
Project structure
longevity-mcp-server/
├── src/
│ ├── index.ts # stdio entry point (Claude Desktop / Code)
│ ├── http.ts # Streamable HTTP entry point (remote hosting)
│ ├── server.ts # builds the MCP server + tier gating
│ ├── licensing.ts # free/premium entitlement (pluggable)
│ ├── data.ts # data loading + medication resolver
│ ├── types.ts # clinical data types
│ ├── tools/ # one file per MCP tool (9 tools)
│ └── data/ # clinical data (JSON)
│ ├── categories.json
│ ├── medications.json
│ ├── dosing.json
│ ├── contraindications.json
│ ├── interactions.json
│ ├── labs.json
│ ├── fda.json
│ └── pathways.json
├── scripts/
│ ├── copy-assets.mjs # copy JSON into dist/ at build
│ └── smoke-test.mjs # end-to-end MCP client/server test
├── examples/
│ └── claude_desktop_config.json
├── package.json
├── tsconfig.json
├── LICENSE
└── README.mdData model
The clinical data is hand-curated from standard pharmacology references and longevity-medicine practice (Endocrine Society / Menopause Society / ISSWSH guidance, FDA labeling and shortage/bulk-substance lists, and the peer-reviewed literature for off-label and investigational compounds). Each dataset is keyed by medication id:
medications.json — class, mechanism, formulations, candidate profile, schedule.
dosing.json — per-indication route / start / titration / maintenance / max / evidence grade.
contraindications.json — boxed warnings, absolute & relative contraindications (with machine-matchable condition keywords), cautions, pregnancy.
interactions.json — per-drug interaction rules (severity, effect, management).
labs.json — baseline panels and ongoing monitoring schedule.
fda.json — approval status, schedule, 503A/503B compounding considerations, approved uses, references.
pathways.json — 15 intake pathways mapping symptoms/goals → first-line + adjunct medications.
Because regulatory status (especially FDA drug-shortage listings and 503A bulk-substance eligibility for peptides) shifts frequently, treat
get_fda_statusoutput as a starting point and confirm against the current FDA database before compounding.
License
MIT © 2026 Keith Schmidt, MD — Oak Longevity Institute
The clinical reference content is provided for educational and decision-support purposes only and does not constitute medical advice. See the disclaimer in LICENSE.
Available Tools
9 toolscheck_contraindicationsScreen Patient for ContraindicationsARead-only
Given a medication and a patient profile (age, sex, conditions, current medications), screens against absolute and relative contraindications and known drug interactions and returns an overall verdict — PASS, FLAG (proceed with caution / address first), or REJECT (do not prescribe) — with the specific triggering findings and clinical notes. PREMIUM tier.
| Name | Required | Description | Default |
|---|---|---|---|
| age | No | Patient age in years. | |
| sex | No | Patient sex (e.g. "male", "female"). | |
| conditions | No | Patient conditions / history (e.g. ["prostate cancer", "hematocrit 55%"]). A comma-separated string is also accepted. | |
| medication | Yes | Medication name, id, or brand/alias to screen. | |
| currentMedications | No | Current medications (e.g. ["warfarin", "nitroglycerin"]). A comma-separated string is also accepted. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description is consistent with the readOnlyHint annotation, indicating a non-destructive screening operation. It adds behavioral context by detailing the output format (verdict and findings) and noting the PREMIUM tier, which implies access or cost considerations. No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that conveys all essential information efficiently. It is front-loaded with the key purpose and output. While concise, it could be slightly streamlined, but overall it is well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 5 parameters and no output schema, the description adequately explains the return values (verdict, triggering findings, clinical notes). It also implies the need for patient profile data. However, it lacks details on error handling or edge cases, which would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All 5 parameters have descriptions in the schema (100% coverage). The description adds semantic value by explaining how these parameters are used (screening against absolute/relative contraindications and drug interactions), which goes beyond the schema's basic definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: given a medication and patient profile, it screens for contraindications and interactions, returning a verdict (PASS, FLAG, REJECT) with specific findings and clinical notes. This distinguishes it from siblings like get_medication_details or check_drug_interactions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'PREMIUM tier' but does not explicitly specify when to use this tool versus alternatives such as check_drug_interactions. No guidance on exclusions or prerequisites is provided, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_drug_interactionsCheck Drug InteractionsARead-only
Given a list of medications (catalog drugs and/or outside agents like "warfarin", "nitrates", "insulin"), returns pairwise interaction warnings ranked by severity (contraindicated > major > moderate > minor), each with the mechanism/effect and management. PREMIUM tier.
| Name | Required | Description | Default |
|---|---|---|---|
| medications | Yes | List of medications to check against each other. A comma-separated string is also accepted. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only (readOnlyHint=true). Description adds output details (severity ranking, mechanism, management) without contradicting annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with key purpose, no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one parameter and no output schema, the description adequately explains input and output structure. Could hint at what 'management' includes but is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameters with good descriptions. The description adds context about accepting both catalog drugs and outside agents, enhancing usability.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('returns'), resource ('pairwise interaction warnings'), and distinguishes from siblings like 'check_contraindications' by specifying severity ranking and input flexibility.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description says when to use ('given a list of medications'), but does not explicitly exclude alternatives like 'check_contraindications'. However, the context implies this is for general interaction checks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_dosing_protocolGet Evidence-Based Dosing ProtocolARead-only
Given a medication (and optionally an indication), returns evidence-based dosing: route, starting dose, titration schedule, maintenance range, maximum, evidence grade, and clinical pearls. When an indication is supplied, returns the best-matching protocol; otherwise returns all indications for the medication. PREMIUM tier.
| Name | Required | Description | Default |
|---|---|---|---|
| indication | No | Optional indication to narrow the protocol (e.g. "weight management", "TRT", "longevity"). | |
| medication | Yes | Medication name, id, or brand/alias. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so no contradiction. Description adds value by listing the specific outputs (route, starting dose, etc.), providing transparency beyond the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Very concise: three sentences front-load the purpose and key outputs. No fluff, every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, description fully explains return values (list of fields) and behavior with/without indication. Sufficient for a simple read tool with two parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear parameter descriptions. Description reinforces the optional nature of indication and explains the different behavior (best-matching vs all indications), adding meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool returns evidence-based dosing for a medication, listing specific output fields like route, dose, etc. It distinguishes from siblings such as get_medication_list or get_medication_details by focusing solely on dosing protocols.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description explains when to use the indication parameter versus not, but does not explicitly compare to alternative tools. However, sibling names are distinct enough that the tool's purpose is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_fda_statusGet FDA / Compounding Regulatory StatusARead-only
Given a compound (name, id, or brand/alias), returns its current FDA approval status, DEA/Rx schedule, compounding pathway (503A/503B, shortage-list and bulk-substance considerations), FDA-approved uses, an off-label note, and reference pointers. Essential for compliant compounded-medication practice. FREE tier.
| Name | Required | Description | Default |
|---|---|---|---|
| compound | Yes | Compound/medication name, id, or brand/alias. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true. The description adds value by enumerating the returned data (approval status, schedule, pathway, uses, off-label note), giving the agent a clear picture of output beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences cover input, output, and importance. No extraneous details; each word serves a purpose. Properly front-loaded for quick consumption.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no output schema, the description lists all major output categories. 'Reference pointers' is slightly vague, but overall it provides enough context for appropriate use among siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a clear parameter description. The description reinforces the acceptable input types (name, id, brand/alias) but adds little beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description specifies the action: given a compound identifier, returns FDA status, DEA schedule, compounding pathway, and other regulatory info. It clearly distinguishes from siblings like get_medication_list or get_dosing_protocol by focusing on regulatory/compliance data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'Essential for compliant compounded-medication practice' clearly indicates when to use (for regulatory compliance). While it doesn't explicitly exclude other tools, the sibling names and unique purpose provide sufficient context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_medication_detailsGet Medication DetailsARead-only
Given a medication name, id, or brand/alias (e.g. "tirzepatide", "Ozempic", "copper peptide"), returns its drug class, mechanism of action, available formulations, who it is for (candidate profile), who it is NOT for (at-a-glance cautions), and DEA/Rx schedule. FREE tier.
| Name | Required | Description | Default |
|---|---|---|---|
| medication | Yes | Medication name, id, or brand/alias. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the description's addition of return fields and 'FREE tier' provides useful behavioral context beyond the annotation. No contradictions. Could mention any rate limits or response size, but not necessary for a simple query.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. The first sentence lists all return fields in a clear, scannable format, and the second adds the 'FREE tier' note. Perfectly concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no output schema, the description adequately covers the return values (drug class, MOA, formulations, etc.). It mentions 'at-a-glance cautions' to set expectations. Could be improved by noting the response structure or whether results are paginated, but not critical.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description covers the parameter (100% coverage), but the tool description adds examples (e.g., 'tirzepatide', 'Ozempic') and clarifies that the input can be a name, id, or alias, which enhances understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the verb 'returns' and specifies the resource: drug class, mechanism of action, formulations, candidate profile, cautions, and schedule. This distinguishes it from sibling tools like get_medication_list (list) or get_dosing_protocol (specific aspect).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool should be used when comprehensive medication details are needed, but it does not explicitly state when not to use it or mention alternative sibling tools for specific aspects (e.g., check_contraindications for deeper contraindications).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_medication_listList Longevity MedicationsARead-only
Returns the full catalog of longevity & metabolic medications, grouped by category (Weight Management, Peptide Therapy, Hormone Optimization, Longevity & Metabolic, Sexual Health, Immune & Inflammation, Hair Restoration, Dermatology). Each entry includes the medication id (used by other tools), display name, drug class, and DEA/Rx schedule. Optionally filter by a category id or name. FREE tier.
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | Optional category filter (id like "peptide-therapy" or label like "Hormone Optimization"). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations indicating read-only, the description adds behavioral details: results are grouped by category, each entry includes fields like id and schedule, filtering is optional, and it is available on the FREE tier. No safety concerns disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, each adding value: purpose, output format, and optional filter with FREE tier. No wasted words; front-loaded with the main action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list tool with simple parameters and many siblings, the description covers the essential aspects: what is returned, filtering, and the fact that the id is used by other tools. Could benefit from mentioning if pagination exists, but not critical.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 100% of parameters with clear descriptions. The description repeats the filtering option without adding new meaning beyond what the schema already provides, so baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns the full catalog of medications grouped by category, with specific fields included. It distinguishes from sibling tools by focusing on list retrieval, while others handle details, FDA status, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the description (filtering by category), but no explicit guidance on when to use this tool versus alternatives like get_medication_details. No when-not or exclusions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_monitoring_planGet Ongoing Monitoring PlanARead-only
Given a medication, returns the ongoing monitoring requirements once therapy has started — what to check, at what interval, and the action/threshold for each. Use to build a follow-up schedule. PREMIUM tier.
| Name | Required | Description | Default |
|---|---|---|---|
| medication | Yes | Medication name, id, or brand/alias. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the agent knows it's a safe read. The description adds the 'PREMIUM tier' label, which indicates access or rate limit considerations. No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with core purpose, followed by usage hint and tier. Every sentence adds value with no redundancy. Efficient and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description fully covers purpose, usage context, and a behavioral note (tier). It is complete enough for an agent to select and invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage for the single parameter ('medication'), so the schema already explains what it accepts. The tool description's phrase 'Given a medication' adds no new semantics beyond the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('returns') and the resource ('ongoing monitoring requirements'), specifying the context ('once therapy has started') and what it includes ('what to check, at what interval, threshold'). This distinguishes it from sibling tools like get_required_labs, which likely cover pre-therapy labs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states the use case ('build a follow-up schedule') and implies when to use (after therapy starts). It does not explicitly say when not to use or name alternatives, but the sibling context and the phrase 'once therapy has started' provide implicit differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_required_labsGet Required Baseline LabsARead-only
Given a medication, returns the recommended baseline labs/assessments to obtain BEFORE prescribing — grouped into panels with the clinical rationale for each. Use to build a pre-treatment workup. PREMIUM tier.
| Name | Required | Description | Default |
|---|---|---|---|
| medication | Yes | Medication name, id, or brand/alias. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the agent knows it's a safe read. The description adds value by describing the output structure (grouped panels with clinical rationale) and noting the PREMIUM tier, which implies access limitations. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The three-sentence description is front-loaded with the core function, then usage context, then tier. Every sentence adds value with no fluff, making it highly efficient for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and read-only annotations, the description covers the key aspects: what it returns (baseline labs grouped with rationale), when to use (pre-treatment workup), and tier. It could be improved by specifying the expected output format more explicitly, but it's largely complete without an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'medication' is fully described in the schema (name, id, or alias) with 100% coverage. The description adds no new semantic details about the parameter beyond the schema, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns recommended baseline labs/assessments to obtain before prescribing a medication, grouped into panels with clinical rationale. This verb+resource combination is specific and distinguishes it from siblings like get_monitoring_plan (ongoing monitoring) and check_contraindications.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use to build a pre-treatment workup' and emphasizes 'BEFORE prescribing', providing clear context for when to use. However, it does not explicitly state when not to use it or point to alternatives, though the sibling list and phrasing imply differentiation from post-prescription tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
screen_patient_intakeScreen Patient Intake → Suggested PathwaysARead-only
Given a patient’s symptoms and/or goals (free text or a list — e.g. "fatigue, low libido, want to lose weight"), suggests the most relevant longevity treatment pathways, each with first-line and adjunct medications, a suggested workup, and key things to avoid. Use to triage an intake. PREMIUM tier.
| Name | Required | Description | Default |
|---|---|---|---|
| goals | No | Optional explicit list of goals/symptoms. Combined with `symptoms` if both given. | |
| symptoms | No | Patient symptoms and/or goals as free text (e.g. "tired, low sex drive, brain fog"). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, but description adds behavioral context: the output includes first-line/adjunct medications, workup, and things to avoid. This goes beyond what annotations provide, giving a clear picture of the tool's results and non-destructive nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. First sentence defines purpose and provides an illustrative example. Second sentence provides usage directive and tier. Front-loaded with key information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately explains the return value (pathways with medications, workup, avoid list). Both input parameters are covered, and the tool's role in triage is clear. Missing details like pagination or limit but acceptable for a screening tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and schema descriptions are clear. Description adds an example ('fatigue, low libido, want to lose weight') and notes combination behavior, providing marginal extra value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool's purpose: given symptoms/goals, suggests longevity treatment pathways. It distinguishes from sibling tools which focus on specific medication details, FDA status, dosing, etc. The verb 'suggests' and resource 'treatment pathways' are specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use to triage an intake' and mentions it is PREMIUM tier, which indicates when to use. Lacks explicit exclusions or alternatives, but the context of siblings (e.g., get_medication_list) implies this is the initial screening step, not a detail lookup.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
9 tool updates
v1.0.0- First observed
check_contraindications - First observed
check_drug_interactions - First observed
get_dosing_protocol - First observed
get_fda_status - First observed
get_medication_details - First observed
get_medication_list - First observed
get_monitoring_plan - First observed
get_required_labs - First observed
screen_patient_intake
TDQS
Each tool targets a distinct aspect of medication management (listing, details, FDA status, dosing, labs, monitoring, contraindications, interactions, patient intake). There is no overlap, making it easy for an agent to select the correct tool.
All tools use a consistent snake_case verb_noun pattern (e.g., get_medication_list, check_contraindications, screen_patient_intake). The naming is uniform and predictable across the entire set.
With 9 tools, the server is well-scoped for its purpose of longevity medication decision support. Each tool serves a clear function without redundancy, and the count is neither too sparse nor overly large.
The tools cover a comprehensive clinical workflow: catalog browsing, detailed info, regulatory status, dosing, pre-treatment labs, monitoring, contraindications, drug interactions, and patient intake triage. There are no obvious gaps for an informational MCP server.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Hosted MCP server for the Healthie EHR & telehealth API: patients, appointments, charting, tasks.
MCP gateway federating 22 biomedical MCP servers behind one endpoint: gnomAD, ClinVar, HPO, VEP.
MCP server for medicare-coverage
MCP server for secureFlows: token-free URL builders and integration-linting tools for AI agents.
Related MCP Servers
- AlicenseAqualityCmaintenanceAn MCP server that connects AI assistants to OpenEMR instances to manage patient records, clinical trends, and medication safety. It provides 17 tools for tasks such as patient search, drug interaction checks, and generating comprehensive health trajectories and visit preparations.17MIT
- AlicenseNot gradedqualityDmaintenanceClinical decision-support MCP server that lets AI agents reason over live FHIR patient data for medication review, appointment scheduling, and care gap identification.6,297MIT
- AlicenseAqualityBmaintenanceEvidence-based supplement recommendation MCP server covering 17 supplements and 40+ conditions with medication interaction checking and form quality classification.577MIT
- FlicenseBqualityBmaintenanceAn MCP server that provides AI-assisted clinical decision support for medication safety, integrating trusted biomedical sources to detect drug interactions and suggest therapeutic alternatives.51-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Goingparabolic/oak-longevity-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server