MCPs
Catalysis Hub MCP Server

Catalysis Hub MCP Server

MCP-compliant server for accessing catalysis research data via GraphQL.

Stars

Forks

Watchers

Issues

Catalysis Hub MCP Server provides a Model Context Protocol interface to the Catalysis Hub's GraphQL API, enabling seamless programmatic access to catalyst research datasets. It allows users to execute flexible and complex GraphQL queries to retrieve reaction, material, and publication data. The server supports robust error handling, parameterized queries, and is designed for interoperability with AI agents in scientific workflows.

Key Features

Model Context Protocol (MCP) standard compliance

Direct execution of GraphQL queries

Comprehensive coverage of catalytic reactions, materials, and publications

Supports parameterized and complex queries

Standard input/output transport following MCP specifications

Robust error handling for connectivity and query execution

Easy integration with Python using httpx

Server configuration customization

Flexible data fetching including fragments and variables

Programmatic access tailored for AI agent workflows

Use Cases

Automating retrieval of catalytic reaction data for machine learning pipelines

Integrating catalysis data into computational chemistry workflows

Accessing material properties and structures in materials informatics research

Programmatically querying research publications and related metadata

Supporting AI agent-driven scientific literature mining

Enabling data-driven catalyst discovery and optimization

Facilitating large-scale benchmarking with direct GraphQL access

Developing custom analytics or dashboards for catalysis research

Accelerating data ingestion in scientific knowledge graphs

Enhancing reproducibility by standardized data access in computational experiments

README

Catalysis Hub MCP Server

A Model Context Protocol (MCP) server interface to Catalysis Hub's GraphQL API, enabling programmatic access to catalysis research data through flexible GraphQL queries.

Key Features

Direct GraphQL Access: Execute any valid GraphQL query against Catalysis Hub's API
Comprehensive Data Access:
- Catalytic reactions (equations, conditions, catalysts)
- Material systems (structures, properties, descriptors)
- Research publications (titles, DOIs, authors)
- Surface reaction data (adsorption energies, binding sites)
MCP Standard Compliance: Implements the Model Context Protocol for AI-agent interoperability
Flexible Query Support: Execute complex queries with variables parameterization
Error Handling: Robust error reporting for API connectivity and query execution

License and Citation

This project is available under the MIT License with an Academic Citation Requirement. This means you can freely use, modify, and distribute the code, but any academic or scientific publication that uses this software must provide appropriate attribution.

For academic/research use:

If you use this software in a research project that leads to a publication, presentation, or report, you must cite this work according to the format provided in CITATION.md.

For commercial/non-academic use:

Commercial and non-academic use follows the standard MIT License terms without the citation requirement.

By using this software, you agree to these terms. See LICENSE.md for the complete license text.

Implementation Details

Server Configuration (matches claude_desktop_config.json):

json

{
  "command": "/Users/quentincody/.env/bin/python3",
  "args": ["/Users/quentincody/catalysishub-mcp-server/catalysishub_mcp_server.py"],
  "options": {
    "cwd": "/Users/quentincody/catalysishub-mcp-server"
  }
}

Core Dependency: httpx for asynchronous HTTP requests
Transport: Standard input/output communication following MCP specifications

Setup & Installation

Clone the repository:

bash

git clone <repository_url>
cd catalysishub-mcp-server

Install dependencies:
bash
```
pip install -r requirements.txt
```

Verify installation:

bash

python3 catalysishub_mcp_server.py --version
# Should output: catalysishub-mcp-server 0.1.0

Usage Examples

Basic Query Execution

python

from mcp.client import MCPClient

async with MCPClient("catalysishub") as hub:
    result = await hub.catalysishub_graphql(
        query="""{
            reactions(first: 5) {
                edges {
                    node {
                        id
                        Equation
                        Temperature
                    }
                }
            }
        }"""
    )
    print(json.loads(result))

Parameterized Query with Variables

python

variables = {
    "materialId": "mp-1234",
    "firstResults": 5
}

response = await hub.catalysishub_graphql(
    query="""query GetMaterial($materialId: String!, $firstResults: Int!) {
        systems(uniqueId: $materialId) {
            edges {
                node {
                    energy
                    Cifdata
                    relatedReactions(first: $firstResults) {
                        edges {
                            node {
                                id
                                Equation
                            }
                        }
                    }
                }
            }
        }
    }""",
    variables=variables
)

Query Optimization Tips

Use GraphQL Fragments:

graphql

fragment ReactionDetails on Reaction {
    id
    Equation
    ActivationEnergy
    Catalyst {
        formula
        surface
    }
}

query {
    reactions(first: 10) {
        edges {
            node {
                ...ReactionDetails
            }
        }
    }
}

Batch Related Queries:

graphql

query BatchQuery {
    reactions: reactions(first: 5) { edges { node { id Equation } } }
    materials: systems(first: 5) { edges { node { formula energy } } }
}

Response Structure

Successful responses follow this structure:

json

{
    "data": { /* Query results */ },
    "extensions": {
        "responseMetadata": {
            "requestDuration": 145,
            "apiVersion": "2024-06"
        }
    }
}

Error responses include detailed diagnostics:

json

{
    "errors": [{
        "message": "Cannot query field 'invalidField' on type 'Reaction'",
        "locations": [{"line": 5, "column": 21}],
        "path": ["query", "reactions", "edges", "node", "invalidField"]
    }]
}

Troubleshooting

Common Issues:

HTTP Request Error: Verify network connectivity to api.catalysis-hub.org
JSON Decode Error: Check query syntax using Catalysis Hub's GraphQL Playground
Timeout Errors: Add timeout parameter to complex queries

Acknowledgements

This project builds on the Model Context Protocol (MCP) framework and is designed to interface with the Catalysis Hub database, a comprehensive resource for catalysis research data.

Star History

Repository Owner

QuentinCody

User

Repository Details

Language Python

Default Branch main

Size 19 KB

Contributors 1

License Other

MCP Verified Nov 12, 2025

Programming Languages

Python

100%

Related MCPs

Discover similar Model Context Protocol servers

GitHub GraphQL MCP Server

A Model Context Protocol server for executing arbitrary GraphQL queries on GitHub's API.

GitHub GraphQL MCP Server is a Model Context Protocol (MCP) server that enables interaction with GitHub's GraphQL API. It allows users to execute any GraphQL queries and mutations against GitHub, supporting variable injection and error handling. The server is designed to integrate with Claude for Desktop, providing tooling for AI environments to access or manipulate GitHub data. Detailed documentation and configuration examples are provided for rapid setup and use.

⭐ 9
MCP
QuentinCody/github-graphql-mcp-server

mcp-graphql

Enables LLMs to interact dynamically with GraphQL APIs via Model Context Protocol.

mcp-graphql provides a Model Context Protocol (MCP) server that allows large language models to discover and interact with GraphQL APIs. The implementation facilitates schema introspection, exposes the GraphQL schema as a resource, and enables secure query and mutation execution based on configuration. It supports configuration through environment variables, automated or manual installation options, and offers flexibility in using local or remote schema files. By default, mutation operations are disabled for security, but can be enabled if required.

⭐ 319
MCP
blurrah/mcp-graphql

MLB API MCP Server

A Model Context Protocol server for seamless MLB data access through AI applications.

MLB API MCP Server provides comprehensive access to MLB statistics and baseball data via a FastMCP-based interface. It exposes a range of MLB functionalities—including live game data, player statistics, team information, and advanced metrics—as MCP tools accessible by AI workflows. Compatible with MCP-enabled AI clients, it enables structured, schema-validated querying and integrations for baseball data.

⭐ 33
MCP
guillochon/mlb-api-mcp

TeslaMate MCP Server

Query your TeslaMate data using the Model Context Protocol

TeslaMate MCP Server implements the Model Context Protocol to enable AI assistants and clients to securely access and query Tesla vehicle data, statistics, and analytics from a TeslaMate PostgreSQL database. The server exposes a suite of tools for retrieving vehicle status, driving history, charging sessions, battery health, and more using standardized MCP endpoints. It supports local and Docker deployments, includes bearer token authentication, and is intended for integration with MCP-compatible AI systems like Claude Desktop.

⭐ 106
MCP
cobanov/teslamate-mcp

Shopify Storefront MCP Server

Seamless Shopify Storefront API access for AI assistants via Model Context Protocol

Enables AI assistants to interact with Shopify store data through standardized MCP tools. Offers endpoints for product discovery, inventory management, GraphQL queries, cart operations, and comprehensive customer data manipulation. Designed for easy integration with MCP-compatible AI and automated token handling. Simplifies secure connection to Shopify's Storefront API with minimal configuration.

⭐ 5
MCP
QuentinCody/shopify-storefront-mcp-server

mcp-graphql-forge

Configuration-driven MCP server exposing modular GraphQL queries as tools.

mcp-graphql-forge provides a lightweight, easily configurable Model Context Protocol (MCP) server that transforms any GraphQL endpoint into a set of modular API tools. Tools, defined in YAML, specify GraphQL queries and parameters to enable curated interactions via a standardized protocol. Written in Go, it emphasizes modularity, security, and extensibility without requiring code changes, and offers ready-to-run binaries for all major platforms.

⭐ 3
MCP
UnitVectorY-Labs/mcp-graphql-forge

View all Alternatives

Didn't find tool you were looking for?

Search AI Tools

Catalysis Hub MCP Server

Key Features

Use Cases

README

Catalysis Hub MCP Server

Key Features

License and Citation

For academic/research use:

For commercial/non-academic use:

Implementation Details

Setup & Installation

Usage Examples

Basic Query Execution

Parameterized Query with Variables

Query Optimization Tips

Response Structure

Troubleshooting

Acknowledgements

Star History

Repository Owner

Repository Details

Programming Languages

Tags

Related MCPs