# University Research MCP (`red.cars/university-research-mcp`) Actor

Generate institutional reports, researcher profiles, patent landscapes, and funding analysis from 8 academic databases for university tech transfer and VC workflows.

- **URL**: https://apify.com/red.cars/university-research-mcp.md
- **Developed by:** [AutomateLab](https://apify.com/red.cars) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 institution reports

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## University Research MCP Server

Generate institutional reports, researcher profiles, patent landscapes, and funding analysis from 8 academic databases for university tech transfer and VC workflows. No API keys required.

### What This MCP Does

The University Research MCP server wraps five academic research capabilities into one unified interface:
- **institution_report** — Full intelligence brief on any university or research institution with commercialization scoring (0-100) and investment verdict (ACQUIRE_NOW | PARTNER | MONITOR | TOO_EARLY | PASS)
- **researcher_profile** — Top 10 researchers at an institution with publication counts, citation metrics, and ORCID data
- **patent_landscape** — Patent filings from USPTO and EPO with filing status, claims, and technology classification
- **funding_analysis** — Grant breakdown by agency (NIH, NSF, DOD) with funding amounts and project descriptions
- **benchmark_institutions** — Compare 2-5 institutions across all scoring dimensions

### Why AI Agents Need This

University tech transfer offices, VC analysts, and corporate development teams need structured research intelligence on academic institutions. University Research MCP aggregates OpenAlex, arXiv, USPTO, EPO, NIH Reporter, Grants.gov, and ORCID into one call — what would otherwise require 8 separate API integrations and weeks of normalization work.

### Quick Start

1. Connect via MCP protocol to `mcp.apify.com`
2. Call `institution_report` with an institution name
3. Receive full report with composite scores, verdict, and signal explanations

### MCP Tools

#### institution_report

**Purpose:** Full intelligence brief on any university or research institution with commercialization scoring.

**Input:**
```json
{
  "institution": "string (required)",
  "field": "string (optional)",
  "department": "string (optional)"
}
````

**Output:** Full report with compositeScore (0-100), verdict (ACQUIRE\_NOW|PARTNER|MONITOR|TOO\_EARLY|PASS), recommendations, allSignals, scoring breakdown, dataSource counts, and top publications/patents/grants/researchers/preprints.

**When to call:** Tech transfer evaluation, VC due diligence, academic partnership assessment, investment research.

#### researcher\_profile

**Purpose:** Top 10 researchers at an institution with metrics.

**Input:**

```json
{
  "institution": "string (required)",
  "field": "string (optional)"
}
```

**Output:** Array of researchers with name, ORCID, works\_count, cited\_by\_count, h\_index.

#### patent\_landscape

**Purpose:** Top patents from USPTO and EPO for an institution or field.

**Input:**

```json
{
  "institution": "string (required)",
  "field": "string (optional)"
}
```

**Output:** Array of patents with patent\_number, title, filing\_date, status, claims, technology\_classification, inventors.

#### funding\_analysis

**Purpose:** Grant funding breakdown by agency for an institution.

**Input:**

```json
{
  "institution": "string (required)",
  "field": "string (optional)"
}
```

**Output:** Grants array with agency, amount, title, PI, institution, and totals by agency.

#### benchmark\_institutions

**Purpose:** Compare 2-5 institutions across all scoring dimensions.

**Input:**

```json
{
  "institutions": ["string"] (required, 2-5),
  "field": "string (optional)"
}
```

**Output:** Comparisons with rank, compositeScore, scoring breakdown per dimension, and recommended\_actions.

### Data Sources

- **OpenAlex** — 250M+ academic works, research institutions
- **arXiv** — 2.4M+ STEM preprints
- **USPTO** — US patent filings
- **EPO** — European patents
- **NIH Reporter** — Grant funding
- **Grants.gov** — Federal grant opportunities
- **ORCID** — Researcher profiles

### Pricing (Pay-Per-Event)

| Event | Price |
|-------|-------|
| institution\_report | $0.10 |
| researcher\_profile | $0.05 |
| patent\_landscape | $0.05 |
| funding\_analysis | $0.05 |
| benchmark\_institutions | $0.15 |
| apify-actor-start | $0.00005 |

### Verdict System

| Composite Score | Verdict |
|-----------------|---------|
| 75+ | ACQUIRE\_NOW |
| 55-74 | PARTNER |
| 35-54 | MONITOR |
| 15-34 | TOO\_EARLY |
| <15 | PASS |

**Overrides:**

- WORLD\_CLASS lab + commercialization ≥60 → ACQUIRE\_NOW
- TRL ≥6 + weak lab <30 → MONITOR

### Scoring Models (4)

#### Commercialization Readiness (30% weight)

- Pub-to-patent conversion ratio (max 30 pts)
- Patent recency 2024+ (max 25 pts)
- Grant funding log10 formula (max 25 pts)
- TRL keyword scanning (max 20 pts)

#### Research Hotspot Detection (20% weight)

- ArXiv preprint velocity (max 30 pts)
- Citation density (max 30 pts)
- Researcher density (max 20 pts)
- Cross-source confirmation (max 20 pts)

#### Lab Intelligence Profiling (25% weight)

- PI productivity (max 30 pts)
- Grant portfolio diversity (max 25 pts)
- IP volume (max 25 pts)
- Publication breadth (max 20 pts)

#### Technology Maturity Assessment (25% weight)

- Weighted TRL average (max 35 pts)
- Patent grant ratio (max 25 pts)
- Landmark papers 100+ citations (max 20 pts)
- SBIR/STTR signals (max 20 pts)

### Use Cases

1. **Corporate Development/M\&A** — Rank academic spinout targets by composite score
2. **Venture Capital** — Evaluate founding labs for deep tech investments
3. **Technology Licensing** — Find institutions with 30%+ conversion ratios
4. **Government Science Agencies** — Map institutional strengths for grant allocation
5. **University Benchmarking** — Compare commercialization performance vs. peers

### Limitations

- Patent data requires Google Patents API (not included in v1.0)
- ORCID coverage is opt-in — unregistered researchers invisible
- USPTO/EPO data lags 12-18 months
- Grants.gov = opportunities, NIH = historical awards

### Related MCPs

- **academic-research-mcp** — General academic paper search, citations, author profiles
- **web-intelligence-mcp** — Website reading and contact extraction
- **company-intelligence-mcp** — Company enrichment and sanctions screening
- **email-intelligence-mcp** — Email finding and verification

### Connect

- **Apify:** https://apify.com/university-research-mcp
- **GitHub:** https://github.com/red-cars-io/university-research-mcp
- **MCP Endpoint:** `https://university-research-mcp.apify.actor/mcp`

# Actor input Schema

## `tool` (type: `string`):

MCP tool to call

## `params` (type: `object`):

Tool parameters as JSON object

## Actor input object example

```json
{
  "tool": "institution_report",
  "params": {
    "institution": "MIT",
    "field": "quantum computing"
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "tool": "institution_report",
    "params": {
        "institution": "MIT",
        "field": "quantum computing"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("red.cars/university-research-mcp").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "tool": "institution_report",
    "params": {
        "institution": "MIT",
        "field": "quantum computing",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("red.cars/university-research-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "tool": "institution_report",
  "params": {
    "institution": "MIT",
    "field": "quantum computing"
  }
}' |
apify call red.cars/university-research-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=red.cars/university-research-mcp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "University Research MCP",
        "description": "Generate institutional reports, researcher profiles, patent landscapes, and funding analysis from 8 academic databases for university tech transfer and VC workflows.",
        "version": "1.0",
        "x-build-id": "XKBgLABtw42PKtR62"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/red.cars~university-research-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-red.cars-university-research-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/red.cars~university-research-mcp/runs": {
            "post": {
                "operationId": "runs-sync-red.cars-university-research-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/red.cars~university-research-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-red.cars-university-research-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "tool": {
                        "title": "Tool Name",
                        "enum": [
                            "institution_report",
                            "researcher_profile",
                            "patent_landscape",
                            "funding_analysis",
                            "benchmark_institutions"
                        ],
                        "type": "string",
                        "description": "MCP tool to call"
                    },
                    "params": {
                        "title": "Parameters (JSON)",
                        "type": "object",
                        "description": "Tool parameters as JSON object"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```