Dimensions Research Database MCP Server: AI Agents Access 150M+ Scientific Publications & Patents

By Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

In the rapidly evolving landscape of scientific research and artificial intelligence, the ability to seamlessly access and analyze vast amounts of data is paramount. The Dimensions Research Database MCP Server represents a monumental leap forward in this domain, providing AI agents with direct, programmatic access to over 150 million scientific publications, patents, clinical trials, and grants. By leveraging the Model Context Protocol (MCP), developers can empower tools like Claude Desktop and Cursor with unparalleled research capabilities. Explore more in our MCP Directory.

The Dawn of Agentic Science

Agentic science refers to the integration of autonomous AI agents into the scientific research process. These agents can perform comprehensive literature reviews, identify emerging trends, and synthesize complex data from disparate sources. The Dimensions API offers a wealth of information, but historically, integrating this data into AI workflows required custom, fragile scripts. The introduction of the Model Context Protocol changes this paradigm by providing a standardized, secure method for connecting Large Language Models (LLMs) to external data sources.

Why Dimensions?

Dimensions is a dynamic, linked research data platform that connects grants, publications, citations, alternative metrics, clinical trials, patents, and policy documents. This interconnectedness allows researchers to trace the entire lifecycle of a scientific discovery, from initial funding to real-world application. For an AI agent, this linked data is a treasure trove of context, enabling it to answer complex, multi-faceted queries that would be impossible with isolated datasets.

Learn how to orchestrate these agents in our Workflows section.

Building the Dimensions MCP Server in TypeScript

To bridge the gap between AI models and the Dimensions database, we will build an MCP server in TypeScript. This server will expose specific tools that the LLM can invoke to perform searches and retrieve detailed information.

Prerequisites

Before you begin, ensure you have the following installed:

• Node.js (v18 or higher)
• npm or yarn
• A valid Dimensions API key

Setting up the Project

Initialize a new TypeScript project and install the necessary dependencies, including the official MCP SDK.

mkdir dimensions-mcp-server
cd dimensions-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk axios
npm install -D typescript @types/node
npx tsc --init

Implementing the Server

Below is the core implementation of our Dimensions MCP server. It defines a tool for searching publications and handles the communication with the Dimensions API.

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import axios from "axios";

const server = new Server(
  {
    name: "dimensions-research-mcp",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

const DIMENSIONS_API_URL = "https://app.dimensions.ai/api/dsl/v2";
const API_KEY = process.env.DIMENSIONS_API_KEY;

if (!API_KEY) {
  console.error("DIMENSIONS_API_KEY environment variable is required");
  process.exit(1);
}

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "search_publications",
        description: "Search the Dimensions database for scientific publications.",
        inputSchema: {
          type: "object",
          properties: {
            query: {
              type: "string",
              description: "The search query (e.g., 'machine learning AND climate change')",
            },
            limit: {
              type: "number",
              description: "Maximum number of results to return (default: 10, max: 50)",
              default: 10
            }
          },
          required: ["query"],
        },
      },
    ],
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "search_publications") {
    const query = request.params.arguments?.query as string;
    const limit = (request.params.arguments?.limit as number) || 10;

    try {
      const response = await axios.post(
        DIMENSIONS_API_URL,
        `search publications in title_abstract_only for "${query}" return publications[id+title+year+journal] limit ${limit}`,
        {
          headers: {
            Authorization: `Bearer ${API_KEY}`,
            "Content-Type": "application/json",
          },
        }
      );

      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(response.data, null, 2),
          },
        ],
      };
    } catch (error: any) {
      return {
        content: [
          {
            type: "text",
            text: `Error fetching data from Dimensions: ${error.message}`,
          },
        ],
        isError: true,
      };
    }
  }
  throw new Error(`Tool not found: ${request.params.name}`);
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.log("Dimensions MCP Server running on stdio");
}

main().catch(console.error);

The InputSchema Definition

Notice the inputSchema in the search_publications tool definition. This JSON Schema is critical; it tells the LLM exactly what arguments the tool expects and what formats they should take. In this case, it requires a query string and accepts an optional limit number. This explicit contract is what makes MCP so powerful and reliable.

Configuring mcpServers for Claude Desktop

To use this newly minted MCP server with Claude Desktop, you must configure your claude_desktop_config.json file. This tells Claude how to execute your server and what environment variables to provide.

{
  "mcpServers": {
    "dimensions": {
      "command": "node",
      "args": ["/absolute/path/to/dimensions-mcp-server/dist/index.js"],
      "env": {
        "DIMENSIONS_API_KEY": "your_dimensions_api_key_here"
      }
    }
  }
}

After updating the configuration and restarting Claude Desktop, you can immediately begin asking Claude to search for recent papers on specific topics, and it will autonomously use the Dimensions API to fulfill your request.

Advanced Tooling: Patents and Clinical Trials

While publications are essential, Dimensions truly shines when linking disparate data types. You can expand your MCP server by adding tools for searching patents and clinical trials.

// Example addition to the ListToolsRequestSchema handler
{
  name: "search_patents",
  description: "Search the Dimensions database for patents.",
  inputSchema: {
    type: "object",
    properties: {
      query: {
        type: "string",
        description: "Keywords to search within patent titles and abstracts",
      }
    },
    required: ["query"],
  },
}

By providing a suite of specialized tools, the AI agent can formulate complex research strategies, first finding relevant publications, then finding related patents, and finally checking if any connected clinical trials are underway.

OAuth 2.0 Security Guide for Enterprise Deployments

For enterprise environments, hardcoding API keys is unacceptable. Implementing OAuth 2.0 is crucial for secure, identity-aware access to the Dimensions API.

The OAuth Flow

1. Client Registration: Register your MCP Server application with the Dimensions API portal to obtain a client_id and client_secret.
2. Authorization Request: When a user attempts to use the Dimensions tool, the MCP server directs them to the Dimensions authorization endpoint.
3. Consent: The user logs into Dimensions and grants the MCP server permission to access their data.
4. Token Exchange: The server receives an authorization code and exchanges it for an access token and a refresh token.
5. API Requests: The MCP server uses the access token in the Authorization: Bearer <token> header for all subsequent API requests.

Implementing this flow within an MCP server running on stdio can be challenging because it requires an out-of-band communication channel (like a browser) to handle the user consent. For local desktop clients, a common pattern is to launch a local HTTP server temporarily to receive the OAuth callback.

For more robust security practices, check out the official OAuth 2.0 documentation (External Resource).

Expanding Agentic Workflows

Imagine combining the Dimensions MCP Server with other tools. An agent could:

1. Use the Dimensions tool to find the top 5 papers on a new battery technology.
2. Use a GitHub MCP server to search for open-source code repositories implementing those algorithms.
3. Use a Slack MCP server to summarize the findings and notify the research team.

This composability is the true promise of the Model Context Protocol. It transforms LLMs from isolated conversational bots into powerful orchestrators of external systems.

Conclusion

The Dimensions Research Database MCP Server is a prime example of how connecting AI to high-quality, structured data can dramatically accelerate research and innovation. By following this guide, you have the foundation to build sophisticated AI research assistants capable of navigating the complex world of scientific literature, patents, and clinical trials. As the MCP ecosystem grows, these agentic workflows will become increasingly central to scientific discovery.

Stay tuned for more deep dives into cutting-edge MCP integrations on Daily AI World.