MCP App Store
by KeenEthics
DrugBank icon

DrugBank MCP Server for Claude and ChatGPT

By DrugBank

Overview

Make faster, defensible calls on drugs, targets, and pipelines without leaving Claude. DrugBank brings trusted biopharma intelligence directly into your workflow. With DrugBank every answer is grounded in a deeply connected Knowledge Graph that links scientific and commercial data, giving you traceable and deterministic results. An active DrugBank account is required. Existing Biopharma OS customers can connect directly, with no additional purchase. With the DrugBank connector, you can: - Evaluate drug assets: mechanisms of action, approval status, indications, and molecular properties. - Explore target landscapes: every drug interacting with a target, its action type, and trial volume (GLP-1R agonists, BTK inhibitors, and the like). - Track clinical pipelines: query trials by phase, sponsor, recruitment status, and intervention across areas like MASH, Alzheimer's, and oncology. - Build competitive snapshots: compare approved drugs, investigational compounds, and pipeline depth by mechanism. - Spot opportunities: Surface partnership and licensing signals, grounded in source-linked data. DrugBank is read-only and makes no changes to your data. It exposes four tools: list_drugbank_skills (lists the available usage guides), get_drugbank_skill (loads usage guidance), explore_schema (returns the data schema for building queries), and run_query (runs a query and returns structured results).

How to connect

  1. Claude: Open the DrugBank listing in the Claude connectors directory and choose Connect. Claude listing DrugBank exposes 4 tools here.
  2. ChatGPT: Open the DrugBank listing in the ChatGPT app directory and choose Connect. ChatGPT listing DrugBank exposes 27 tools here.

Tools

add_note_block

ChatGPT
Append a narrative note block to the end of a project. Use it for section headings and prose. Writes blocks of kind "note". Every factual claim must come from data you retrieved in this session, and the text is not refreshed, so date-stamp time-sensitive claims. If the prose cites figures, the data belongs in a data block: add it first with add_data_block, check your sentences against the response it returns, then name it here in source_block_ids. The note is then flagged for review whenever that data moves. A note takes no queries of its own. Block ids come from get_project or an earlier tool result. Every block kind and its write tools are in the projects://guide/blocks resource.

adopt_fetch

ChatGPT
Accept a fetch a monitor found, making it what the block presents. Call this only after you have put the changes to the user and they said to go ahead — a monitor never adopts on its own, and reading pending_changes does not accept anything. Pass the fetch_revision that pending_changes reported as to_fetch_revision, not "the latest": a check can append again in between, and adopting a fetch nobody has seen is the one thing this must not do. On a monitored block this also moves the baseline, so whatever the user just accepted will not be reported again.

build_landscape

ChatGPT
Build a landscape as a new project in one call, from a stored recipe. Use this whenever the user asks for a landscape one of the recipes below covers. Resolve each target to its UniProtKB accession and any condition to its DrugBank condition ID first, and tell the user which ones you used — a condition name can match many records. The server runs every query in the recipe and writes each section as a block, in the recipe's order, so the same inputs always build the same project. Do not add blocks of your own to it unless the user asks. Nothing is created if any query fails. Returns the project and each section's response, so you can describe the landscape without reading the blocks back. Recipes: - target (inputs: uniprotkb_accession): The landscape around one drug target, e.g. "show me the landscape for GLP1R": the target itself, every drug that acts on it, what those drugs do to it, the approved ones and their indications, and their trials. - targets_condition (inputs: uniprotkb_accessions, condition): The landscape where one or more drug targets meet a condition, e.g. "GLP1R and GIPR in obesity": the targets, what the condition expands to, every drug acting on any of the targets and investigated for the condition, what they do to the targets, and their trials — for the condition, and in all.

create_project

ChatGPT
Create an empty project and return its uuid, which every other project tool takes. Set a specific title up front so the user watching the page sees what is being built. The project is owned by your organization, not by you personally.

delete_monitor

ChatGPT
Delete a block's monitor, permanently. The block stays, along with its query and everything that query has returned — those are the record of what the data was, and they outlive the watching. What goes is the monitor itself and its history: when it was created, when it last succeeded, and its failure count. Monitoring the block again creates a new monitor with no history, which reports its health as never_verified until a check succeeds. Prefer update_monitor with paused when the user means "not for now"; this is for when they want the monitor gone.

explore_schema

ChatGPT
Return SDL snippets for named GraphQL types from the bundled MCP endpoint schema (graphql-core print_type). Call before run_query whenever you add or change nested fields: same field names can have different arguments on different parent types (verify per type). Do not infer structure from similar type names— only SDL for each exact type counts (include wrapper types you traverse). Prefer one call with every type you will select under (e.g. ["McpQuery", "Condition", "DecodedConditionDrugs", "DrugConnection"]). After a GraphQL error, load the parent object type of the failing field and fix arguments/subfields from SDL—do not guess. Args: types: Type names to include, e.g. ["Drug", "Condition"]. Omit or pass an empty list to get only the root query type `McpQuery`. Unknown names are called out in comments; output order matches the request order.

get_block

ChatGPT
Read one block, including the GraphQL response it is presenting. get_project returns every block but no responses, because a project's worth of them would not fit — so this is how you read the data itself once get_project has told you which block holds it. A very large response is returned in full, so ask for the block you actually need rather than every block in turn. Pass fetch_revision to read another of the block's stored fetches instead of the one it presents: a held change waiting to be applied, or the fetch a dependent was built against.

get_drugbank_skill

ChatGPT
Load DrugBank skill content: primary instructions, named companions, or a topic by resource name. Prefer skill://using-drugbank-mcp/... resources when the client supports them; this tool returns the same text. Call before your first DrugBank GraphQL query for routing and best practices. Args: resource: Defaults to the primary skill. Use "_manifest" for JSON listing all skill files (paths, sizes, and front matter metadata for markdown). Use "mcp-graphql-schema" for the full endpoint SDL file (same source as explore_schema). Other values match the skill package (e.g. api-reference, searching-and-lookups, drug-filters, graphql-entity-types). Hyphens and underscores are equivalent for file-backed resources.

get_project

ChatGPT
Return a project in full: its blocks in order, each with block_id, kind, chrome (title, accent, width), config, data, and derivation — plus, for table blocks, the GraphQL query and variables behind the embed so you can fetch the same rows through the GraphQL MCP. Call this before revising a project, and again as a final review. It is also all you need to pick up a project from an earlier session of your own: derivation says how each block's data was produced. The access section says who owns the project, what the user may do with it (your_access: owner, editor, or viewer), and who else can open it. Reachable for projects the user created and projects shared with them; anything else answers the same way as a uuid that does not exist.

list_drugbank_skills

ChatGPT
List every DrugBank skill guide that get_drugbank_skill can return, as JSON: each entry's resource (the value to pass to get_drugbank_skill), file path, size, and front matter (name and description). Use it to find the guide for a topic before loading it.

list_monitors

ChatGPT
List the monitors on projects you created, with what each one covers and whether it is healthy. Read covers back to the user when they ask what is being watched — it is the sentence the monitor was saved under. Note trustworthy_silence: a monitor that has never been successfully checked has not yet earned being believed when it reports nothing, so do not tell the user "nothing has changed" on the strength of one that says never_verified.

list_project_access

ChatGPT
Show who owns a project, what the user may do with it, and who else can open it — each entry naming either a colleague or the whole organization, with the level they hold. Anybody who can read the project can see this; only its owner can change it, with share_project and unshare_project. Cheaper than get_project when the question is about access rather than contents.

list_projects

ChatGPT
List projects, most recently updated first, with block_count, status, and your_access — the level the user holds on each one: owner, editor, or viewer. A project is an ordered document of blocks — markdown, live Table Builder embeds, charts, and entity cards. Call get_project for a project's full contents before revising it. Defaults to the projects the user created; pass scope 'shared_with_me' for the ones colleagues have shared with them, whether by name or with their whole organization. A project that has not been shared is visible only to whoever made it, so one the user expects and neither scope shows was most likely built by somebody else rather than deleted.

mark_block_reviewed

ChatGPT
Confirm that a block flagged needs_review still holds against what its sources present now, without changing it. Call this only after the user has looked at what changed and said the block is still right — confirming is their judgement, not yours. To change the block instead, rewrite it with update_note_block or update_data_block, which clears the flag too. Send every source in the block's sources list with the presenting_revision the user reviewed: if one has moved since, this is refused rather than vouching for data nobody saw. A source that was removed is dropped from the block.

monitor_block

ChatGPT
Watch a block that already exists, so the user is told when the data behind it changes. Only a data block that fetched its own data can be monitored, the same as in the app: a check re-runs its queries and compares the responses. Derived data (a data block built from another) and notes can't be monitored directly — they are flagged needs_review when what they were built from changes — so asking for one is refused with the data blocks to watch instead; tell the user why and offer to watch those. Older retired kinds (chart, table, card) are refused too. Use create_monitor instead when there is no block yet and the user is asking to watch a query they just ran. The block's intent is what the user will be shown as the description of what is being watched, so set it first with a sentence THEY can check against what they asked for if it does not already say one. When a change is found, the user accepts the new fetch with adopt_fetch.

move_block

ChatGPT
Move a block to a new position in the project (0 is the top). Entity cards render in their own pinned grid at the top regardless of position, so moving one changes its order within that grid only.

pending_changes

ChatGPT
What a monitor has found and is waiting on: the difference between the fetch a block is presenting and the newest one stored for it. Read this when list_monitors shows a pending_fetch_revision, or when the user asks what changed. It answers from what the checker already stored, so it makes no query and costs nothing to call twice — do NOT re-run the query yourself to work out what moved. Tell the user what changed in the terms label uses, then adopt_fetch when they want the block brought up to date. Nothing is written until they do: reading this does not accept anything. To compare two fetches already stored — what moved in a source since a block was built from it, as a review prompt names them — pass from_fetch_revision and to_fetch_revision. Each query lists up to 50 changes; when omitted_changes is more than 0, call again with offset to read the next ones. unlisted_changes counts changes past the 500 kept per query, which no offset reaches: tell the user how many there are, and if they need them, read both fetches with get_block, passing from_fetch_revision and then to_fetch_revision as its fetch_revision.

plan_recipe

ChatGPT
Return the stored GraphQL queries behind a landscape recipe, filled in for the inputs you give, as an ordered list of sections. Nothing is run or stored. To build a landscape, use build_landscape instead, which runs these same queries and writes the project in one call. Use this when the user wants to see what a landscape would query, or when a landscape has to be built step by step — for example to narrow a section down with the user first. Then call add_data_block for each section with status 'ready', in order, with its title, intent and queries exactly as returned: the same queries on every run is what makes the landscape reproducible. A section with status 'needs_previous' takes its variables from the response of an earlier section, named in depends_on: fill them in as its needs field says, and pass that section's block in source_block_ids so the block is flagged when it changes. If that response leaves nothing to run, write its empty_note as a note block instead, with the same source_block_ids. A section with status 'not_defined' has no query yet: say so rather than writing one. Recipes: - target (inputs: uniprotkb_accession): The landscape around one drug target, e.g. "show me the landscape for GLP1R": the target itself, every drug that acts on it, what those drugs do to it, the approved ones and their indications, and their trials. - targets_condition (inputs: uniprotkb_accessions, condition): The landscape where one or more drug targets meet a condition, e.g. "GLP1R and GIPR in obesity": the targets, what the condition expands to, every drug acting on any of the targets and investigated for the condition, what they do to the targets, and their trials — for the condition, and in all.

refresh_data_block

ChatGPT
Re-run the queries a data block already stores and present what comes back. Writes blocks of kind "data". Takes no query: the stored one is re-run as written, with the variables it was stored with, so a refresh cannot change what the block covers. To ask a different question use update_data_block. On a MONITORED block this moves the baseline — anything that changed since the revision on show is absorbed rather than reported, because a person asking for data now is a deliberate act; if the user wants to SEE what moved, read pending_changes first. Earlier fetches are kept. Block ids come from get_project or an earlier tool result. Every block kind and its write tools are in the projects://guide/blocks resource.

remove_block

ChatGPT
Remove a block from a project. There is no undo — restyle or rewrite in place when that is what the user meant. Removing a MONITORED block also deletes the monitor, so the user stops being told when that data changes, and takes every recorded fetch and cached diff with it: that is refused unless you pass confirm_monitor_loss, so put the consequence to the user first. To stop watching but keep the block and its history, use delete_monitor instead. Removing a table block also deletes the project-owned saved search behind it, which no other block or saved item can reference.

restyle_block

ChatGPT
Change a block's chrome — header title, accent colour, and/or column width — without touching its body. This is the "make that card's header blue" or "put the chart beside the text" path. To get two components side by side, set the earlier one to two_thirds and the later one to one_third, and make sure they are consecutive (move_block if not).

run_query

ChatGPT
Execute a GraphQL query and return the results. Args: query: The GraphQL query string to execute variables: Optional JSON object containing query variables

set_project_status

ChatGPT
Mark where a project stands, which the page shows as a badge: generating while you are still building it, ready when it is presentable, failed if you had to give up part-way. Set generating before your first block and ready after your final review, so the user watching knows whether what they see is finished.

share_project

ChatGPT
Share a project with named colleagues or with the user's whole organization. Only the person who created a project can share it. viewer access lets somebody read the project and watch it change; editor access also lets them revise it. Sharing does not hand over a copy — everybody it is shared with reads the same project, which is the point of sharing rather than duplicating. Named colleagues are emailed a link; an organization-wide share is not announced. Sharing again at a level somebody already holds changes nothing. Each recipient needs a DrugBank OS account already, which means having signed in at least once. Pass every colleague you mean to share with in one call rather than calling once each: they all get the same level, and the reply says which addresses worked and which did not.

unshare_project

ChatGPT
Stop sharing a project with a named colleague, or with the user's whole organization. Only the person who created a project can change who sees it. Revoking an organization-wide share does not touch grants made to people by name, and revoking one person's access does not touch the organization-wide one — somebody may still reach the project through the other. Call list_project_access to see what is in place before removing anything.

update_monitor

ChatGPT
Pause or resume a monitor, or change how often it is checked. Pausing is what a user means by "stop telling me about this for now" — it keeps the monitor and everything it has captured, and simply stops it being checked. Use delete_monitor only when they want it gone. A new cadence takes effect from its next slot rather than checking at once. Send state, cadence or both. To change WHAT is watched, the scope is the block's query, so that is a change to the block rather than to the monitor.

update_note_block

ChatGPT
Replace the text of an existing note block. This is a full replacement, not a patch. Writes blocks of kind "note". A rewrite is the note written against what its sources present NOW, so it clears needs_review: rewrite from the data they present, not from memory. source_block_ids replaces the data blocks it was written from; omit it to keep them. Block ids come from get_project or an earlier tool result. Every block kind and its write tools are in the projects://guide/blocks resource.

update_project_overview

ChatGPT
Set a project's title and/or one-line description. Both are the project's own overview, not any block's header — use restyle_block for a block title. The change appears immediately on an open project page.

explore_schema

Claude

get_drugbank_skill

Claude

list_drugbank_skills

Claude

run_query

Claude

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/drugbank"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/drugbank)