How to Use the Harvard ClinicalTrials MCP in LangChain

Q: How does LangChain track tool execution costs for Harvard ClinicalTrials?

Every tool call, such as retrieving trial history via getstudytimeline, is tracked as a separate run in LangSmith. You can monitor the exact input parameters, output JSON size, and execution duration of each individual tool execution.

Build multi-step clinical research pipelines in LangChain with live trial data from the Harvard ClinicalTrials MCP Server.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Harvard ClinicalTrials MCP to LangChain

Create your Vinkius account to connect Harvard ClinicalTrials to LangChain and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Harvard ClinicalTrials with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain trial searches into reasoning pipelines

Pass outputs directly from one tool to the next inside your LangChain runs. Your agent can run `search_by_condition` to find active studies, extract the sponsoring institutions, and immediately feed those into `search_by_sponsor` to map out the competitive field. This eliminates manual data passing and lets your agent build structured research profiles on the fly. You get complete observability over these multi-step chains. Use LangSmith to trace the exact latency, token costs, and raw payloads of tools like `get_study` and `get_study_results`. This exposes exactly why your agent selected a specific trial or phase without guessing.

Build autonomous research agents with this MCP Server

Give your LangChain agents the ability to decide which clinical database tools to call based on user queries. An agent can start with a broad query using `search_studies`, evaluate the status fields, and then pivot to `search_recruiting` or `search_completed` to narrow down the target cohort. You write the prompt, and the agent handles the branching logic. This setup uses the standard LangChain MCP adapters to expose all sixteen trial-hunting tools as native runnable components. Your agents can easily combine the Harvard ClinicalTrials MCP Server with external vector databases or document loaders in a single execution graph.

Target specific patient populations programmatically

Filter trials using highly specific patient and study parameters without writing custom API wrappers. Your chains can run `search_pediatric` to find youth-focused studies or `search_rare_diseases` to isolate orphan drug investigations. The tools return structured JSON payloads that map cleanly to your schema definitions. For geographic targeting, the `search_by_location` tool lets your agent filter trials near specific research hubs. You can combine this with `search_fda_regulated` to ensure your pipeline only analyzes studies subject to strict regulatory oversight.

Setup guide

Set up Harvard ClinicalTrials MCP in LangChain

Prerequisites

Python 3.10+ installed
langchain-mcp-adapters + langgraph packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install langchain-mcp-adapters langgraph langchain-openai. The MCP adapters package converts MCP tools into native LangChain BaseTool objects.
2

Connect via HTTP transport
Use MultiServerMCPClient with "transport": "http" pointing to your Vinkius endpoint. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Create a ReAct agent
Pass the discovered tools to create_react_agent() from LangGraph. The agent automatically routes Harvard ClinicalTrials tool calls through the MCP protocol.
4

Run with any LLM
Swap ChatOpenAI for ChatAnthropic, ChatGoogleGenerativeAI, or any LangChain-compatible model. The MCP tools work identically across all providers.

agent.py

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

async with MultiServerMCPClient({
    "harvard-clinicaltrials-mcp": {
        "transport": "http",
        "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp",
    }
}) as client:
    tools = client.get_tools()

    agent = create_react_agent(
        ChatOpenAI(model="gpt-4o"),
        tools,
    )
    result = await agent.ainvoke({
        "messages": "List recent Harvard ClinicalTrials transactions"
    })
    print(result["messages"][-1].content)

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by ClinicalTrials.gov. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Harvard ClinicalTrials now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Harvard ClinicalTrials MCP in LangChain

You should implement standard LangChain retry runnables or rate-limiting middleware in your execution chain. This prevents your agent from hitting API thresholds when making rapid, nested calls to tools like `search_by_condition` and `get_study`.

Yes. You can pass the tools returned by the MCP client alongside database tools or web search tools to your LangChain agent helper. This allows an agent to research a drug via `search_by_intervention` and then query your internal database for chemical structures.

Every tool call, such as retrieving trial history via `get_study_timeline`, is tracked as a separate run in LangSmith. You can monitor the exact input parameters, output JSON size, and execution duration of each individual tool execution.

You can target any phase from early feasibility to post-market surveillance. Use `search_by_phase` with values like PHASE1 or PHASE3 to target specific study scales, or analyze completed phase results using `get_study_results`.

The server only queries publicly available, non-proprietary clinical trial registries and study protocols. No patient-identifying health records or private medical histories are ever accessed, stored, or transmitted through the Vinkius MCP connection.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript