Biolab MCP Server

"AI agents querying biological databases leave no audit trail. Six months later, nobody can answer: what exact query returned this result, when, and was that paper peer-reviewed at the time? Biolab solves that."

A dual-implementation (Python + Go) MCP server that sits between AI agents and biological/scientific databases (PubMed, Europe PMC, ClinicalTrials.gov, bioRxiv/medRxiv). Every query is intercepted, logged with full retrieval context, and returns a retrieval_id that calling systems store alongside their reasoning traces — creating an end-to-end auditable chain from conclusion back to raw source.

New to MCP? It's a small, open standard (built by Anthropic) that lets an AI assistant — Claude, ChatGPT, Cursor, etc. — call out to external tools during a conversation. Add Biolab as an MCP server and any of those assistants gains four new abilities: searching PubMed, Europe PMC, ClinicalTrials.gov, and bioRxiv/medRxiv, with every single result permanently logged so it can be checked later.

Use It Now — No Install

A hosted instance is running at https://srikarjy025-biolab-mcp.hf.space/mcp. Point your client at it and you're done — nothing to install, nothing to run locally, nothing to sign up for.

Claude Code:

claude mcp add --transport http biolab https://srikarjy025-biolab-mcp.hf.space/mcp

Claude Desktop / Cursor — add this to your MCP config file:

{
  "mcpServers": {
    "biolab": {
      "url": "https://srikarjy025-biolab-mcp.hf.space/mcp"
    }
  }
}

(Add "headers": {"Authorization": "Bearer <your key>"} alongside "url" once you have a key — see the rate-limit note below.)

That's it — search_pubmed, search_europepmc, search_clinicaltrials, search_biorxiv, and get_retrieval are now available as tools your assistant can call. Every retrieval is written to a hash-chained audit trail you can inspect later (see Audit Trail Schema below).

Also listed on the official MCP Registry and Smithery if you'd rather discover/install it from there.

A note on rate limits. The hosted server is shared and stays open — no signup required for casual use — but callers with no API key share one small, low-throughput budget (1 req/s to PubMed) so no single anonymous user can starve everyone else. If you're doing more than a handful of queries, ask for a key (below) and you get your own isolated, higher budget instead.

Getting a key:

Authorization: Bearer <your key>

Add that header in your client's MCP config (Claude Code: claude mcp add --transport http biolab <url> --header "Authorization: Bearer <key>"). Keys are issued with biolab keys create <label> — see Managing API Keys below if you're running your own instance; otherwise ask the maintainer for one.

Want to run your own copy instead (local dev, your own storage, self-hosting)? Keep reading.

The Problem

A drug discovery team uses an AI agent to research gene targets. The agent queries PubMed 200 times over three days and surfaces a paper claiming gene X is upregulated in pancreatic cancer. A scientist makes a decision based on that. Six months later, during FDA submission:

• What exact query returned that paper?
• What date was it retrieved?
• Was it peer-reviewed at retrieval time, or a preprint published later?
• Did the agent summarize it accurately, or hallucinate details?

Without Biolab, nobody can answer any of those questions. The retrieval is invisible.

What Biolab Does

Biolab is an interception and logging layer, not a retrieval layer. It doesn't interpret evidence, rank it, or summarize it — it records what happened, verbatim, so an agent's claim can always be traced back to an unforgeable original.

Your AI Agent
    ↓  MCP tool call (e.g. search_pubmed)
Biolab MCP Server
    ↓  HTTP
Source API (PubMed, Europe PMC, ClinicalTrials.gov, bioRxiv/medRxiv)
    ↓  paper
Biolab writes a hash-chained retrieval record to the audit database
    ↓  paper + retrieval_id
Back to your agent

The agent gets the paper it asked for. Biolab gets a permanent, queryable, tamper-evident record of exactly what happened.

Sources Supported

All sources share a single audit database (SQLite locally, or Turso — a hosted, SQLite-compatible database — in production) with one source-agnostic schema.

Build It Yourself

You don't need to know Python or Go to get this running locally — just follow these steps in order. All commands are run in a terminal.

Prerequisites

• Python 3.11 or newer — check with python3 --version. Get it from python.org if you don't have it.
• Git — to download (clone) the code. Check with git --version.

That's genuinely it for the Python path — no database server to install, no API keys required (PubMed works anonymously, just at a lower rate limit).

1. Get the code

git clone https://github.com/srikarjy/biolab-mcp-server.git
cd biolab-mcp-server

2. Install it

python3 -m venv .venv          # creates an isolated Python environment
source .venv/bin/activate      # on Windows: .venv\Scripts\activate
pip install -e ".[dev]"        # installs the package + test tools

3. Try it

biolab demo --query "BRCA1 pancreatic cancer"

This searches PubMed for real, stores every result in a local biolab.db file (created automatically, no setup needed), and prints back the retrieval_id for each paper — the same ID an AI agent would get back over MCP.

4. Run the test suite (optional, confirms everything works)

pytest tests/ -v

Most tests hit the real PubMed/Europe PMC/ClinicalTrials.gov APIs on purpose (no mocking) — that's a deliberate project rule, not a bug, so a slow test run is normal.

5. Run it as an MCP server (what an AI agent actually connects to)

python -m biolab.server

This starts an HTTP server on http://localhost:8000/mcp — point Claude Desktop, Claude Code, or Cursor at that URL exactly like in Use It Now, just with localhost:8000 instead of the hosted URL.

6. Build the Docker image (optional)

If you'd rather not install Python locally at all:

docker build -f space/Dockerfile -t biolab-mcp .
docker run -p 8000:8000 biolab-mcp

(Storage defaults to an ephemeral file inside the container unless you set TURSO_DATABASE_URL/TURSO_AUTH_TOKEN — see Environment Variables below.)

Prefer a pre-built release?

pipx install biolab-mcp      # or: pip install biolab-mcp

# Or the Go binary, no Python required at all:
curl -L https://github.com/srikarjy/biolab-mcp-server/releases/latest/download/biolab_darwin_arm64.tar.gz | tar xz
./biolab search "BRCA1 pancreatic cancer" --max 3

Usage

CLI (Scientist-Friendly)

# Search PubMed
biolab search "BRCA1 pancreatic cancer" --max 5

# Search Europe PMC
biolab search-europepmc "BRCA1 pancreatic cancer" --max 5

# Search ClinicalTrials.gov
biolab search-clinicaltrials "pancreatic cancer" --max 5

# List bioRxiv preprints (no free-text search - API limitation)
biolab search-biorxiv neuroscience --max 10
biolab search-biorxiv all --server medrxiv --max 10

# Retrieve full audit record
biolab get <retrieval_id>

# List recent retrievals
biolab list --source pubmed --limit 10

# Export for analysis
biolab export evidence.jsonl --source clinicaltrials

# Run demo
biolab demo --query "BRCA1 pancreatic cancer"

MCP Tools (Agent-Friendly)

// Search any source
{"name": "search_pubmed", "arguments": {"query": "BRCA1 pancreatic cancer", "agent_id": "aletheia:advocate", "max_results": 5}}
{"name": "search_europepmc", "arguments": {"query": "BRCA1 pancreatic cancer", "agent_id": "aletheia:advocate", "max_results": 5}}
{"name": "search_clinicaltrials", "arguments": {"query": "pancreatic cancer", "agent_id": "aletheia:advocate", "max_results": 5}}
{"name": "search_biorxiv", "arguments": {"category": "neuroscience", "agent_id": "aletheia:advocate", "max_results": 5, "server": "biorxiv"}}

// Retrieve full audit record (works for ALL sources)
{"name": "get_retrieval", "arguments": {"retrieval_id": "uuid-from-search"}}

Python API

from biolab.pubmed_client import search_and_fetch
from biolab.retrieval_log import write_retrieval, get_retrieval
from biolab.db import connect

conn = connect("biolab.db")
papers = search_and_fetch("BRCA1 pancreatic cancer", 3)
for p in papers:
    record = write_retrieval(conn, query="...", pmid=p.pmid, ...)
    print(record.retrieval_id)

Managing API Keys