registry-mcp by slolab - MCP Server

Registry MCP

A Model Context Protocol (MCP) server for assisting users in registering their MCP servers, knowledge graph components, and other biomedical tools to the BioContextAI registry.

🚀 Quick Start

To use this MCP server to submit your project to the BioContext registry, simply ask your AI assistant:

"Help me submit this project to the BioContext registry"

The MCP will automatically:

Analyze your project - Extract metadata from your project files
Generate YAML - Create a schema.org-compatible specification
Validate - Check the specification against registry requirements
Request confirmation - Ask you to review before submission
Submit - Send your project to the registry (after your confirmation)

Prerequisites

Install the MCP server in your AI assistant
Have your project ready with a pyproject.toml, README.md, or similar metadata files

Overview

The Registry MCP provides a comprehensive set of tools to help users create, validate, and submit schema.org-compatible YAML specifications to the BioContextAI registry. It follows the same pattern as the biocypher-mcp repository, providing structured guidance and automation for registry submissions.

Features

Core Functionality

Project Analysis: Automatically extract metadata from existing project files (pyproject.toml, README.md, etc.)
YAML Generation: Create schema.org-compatible YAML specifications from user input
Validation: Validate submissions against the registry schema with detailed feedback
API Submission: Submit validated specifications to the registry REST API
Troubleshooting: Comprehensive guidance and error resolution

Available Tools

Registry Submission Tools

analyze_project_directory_tool - Analyze project directory to extract metadata
generate_yaml_template_tool - Generate YAML template from metadata
validate_yaml_specification_tool - Validate YAML against registry schema
submit_to_registry_tool - Request submission (requires user confirmation)
confirm_and_submit_to_registry_tool - Actually submit after user confirmation
get_registry_schema_tool - Get the complete registry schema

Guidance and Troubleshooting Tools

get_registry_workflow_guidance_tool - Get step-by-step submission workflow
get_example_submissions_tool - Get example YAML submissions
get_troubleshooting_guide_tool - Get comprehensive troubleshooting guide
get_field_guidance_tool - Get detailed guidance for specific fields

Installation

# Clone the repository
git clone https://github.com/slolab/registry-mcp.git
cd registry-mcp

# Install dependencies
uv sync

# Run the MCP server
uv run registry_mcp

# Or test the installation
uv run registry_mcp --version
uv run registry_mcp --help

Usage

Basic Workflow

Analyze your project:

# Use the MCP tool to analyze your project directory
result = analyze_project_directory_tool(".")

Generate YAML template:

# Create YAML from your metadata
yaml_content = generate_yaml_template_tool({
    "identifier": "your-username/your-repo",
    "name": "Your MCP Server",
    "description": "Description of your MCP server",
    # ... other metadata
})

Validate specification:

# Validate the YAML
validation_result = validate_yaml_specification_tool(yaml_content)

Submit to registry (with file-based confirmation):

# First, create YAML file and request confirmation
# Specify project_path to save meta.yaml in the project directory
submission_request = submit_to_registry_tool(yaml_content, project_path=".")

# The tool will create a YAML file and return confirmation request
if submission_request.get("requires_confirmation"):
    print(submission_request["confirmation_message"])
    yaml_file_path = submission_request["yaml_file"]
    
    # User must explicitly confirm before actual submission
    # After user confirms, call:
    submission_result = confirm_and_submit_to_registry_tool(yaml_file_path)

File-Based User Confirmation Workflow

The registry submission process now uses a robust file-based confirmation system to prevent accidental submissions:

YAML File Creation: submit_to_registry_tool() validates the YAML and creates a meta.yaml file with user_confirmed: false in the specified project directory (defaults to current directory)
User Review: The tool displays submission details and asks for confirmation
User Decision: User must explicitly confirm with "Yes, submit to registry" or "Confirm submission"
Confirmation Update: confirm_and_submit_to_registry_tool() sets user_confirmed: true and performs the submission
Status Checking: check_yaml_file_status_tool() allows checking the current status of any YAML file

Important: The meta.yaml file will be created in the specified project directory. Use the project_path parameter to ensure it's saved in the correct location.

This ensures users have full control over when their MCP servers are submitted to the public registry, with a persistent record of the confirmation state.

Example YAML Structure

Based on the BioCypher MCP example:

"@context": https://schema.org
"@type": SoftwareApplication
"@id": https://github.com/your-username/your-mcp

identifier: your-username/your-mcp

name: Your MCP Server Name

description: >
  A detailed description of your MCP server's functionality,
  use cases, and target audience.

codeRepository: https://github.com/your-username/your-mcp

url: https://your-mcp.example.com  # Optional

softwareHelp:
  "@type": CreativeWork
  url: https://your-mcp.example.com/docs
  name: Your MCP Documentation

maintainer:
  - "@type": Person
    name: Your Name
    identifier: "GitHub: your-username"
    url: https://github.com/your-username

license: https://spdx.org/licenses/MIT.html

applicationCategory: HealthApplication

keywords:
  - keyword1
  - keyword2
  - keyword3

operatingSystem:
  - Cross-platform

programmingLanguage:
  - Python

featureList:
  - Feature 1
  - Feature 2
  - Feature 3

user_confirmed: false  # Set to true only after user confirmation

Schema Requirements

The registry uses a schema.org-compatible specification with the following required fields:

Required Fields

@context: Must be "https://schema.org"
@type: Must be "SoftwareApplication"
@id: Unique identifier URI (typically GitHub URL)
identifier: Repository identifier in format "owner/repository"
name: Component name (1-100 characters)
description: Detailed description (10-1000 characters)
codeRepository: Repository URL (GitHub, GitLab, Bitbucket, or Codeberg)
maintainer: Maintainer information (Person or Organization)
license: SPDX license URL
applicationCategory: Application type
keywords: 1-10 relevant keywords
programmingLanguage: Programming languages used

Optional Fields

url: Remote hosting URL
softwareHelp: Documentation/help resource
featureList: List of features/capabilities
operatingSystem: Supported operating systems
user_confirmed: User confirmation flag (boolean, defaults to false)

Registry Schema

The registry follows a strict JSON schema for validation. You can retrieve the complete schema using:

schema = get_registry_schema_tool()

Troubleshooting

Common Issues

Invalid identifier format: Use "owner/repository" format
Missing required fields: Ensure all required fields are present
Invalid license format: Use SPDX format (https://spdx.org/licenses/LICENSE.html)
Unsupported repository: Use GitHub, GitLab, Bitbucket, or Codeberg

Getting Help

Use the troubleshooting tools for detailed guidance:

# Get comprehensive troubleshooting guide
troubleshooting = get_troubleshooting_guide_tool()

# Get guidance for specific fields
field_help = get_field_guidance_tool("identifier")

# Get workflow guidance
workflow = get_registry_workflow_guidance_tool()

Development

Running Tests

# Run the test suite
uv run python test_registry_mcp.py

Project Structure

src/registry_mcp/
├── __init__.py
├── main.py              # CLI entry point
├── mcp.py               # MCP server configuration
└── tools/
    ├── __init__.py
    ├── _greet.py        # Example tool
    ├── registry_submission.py  # Core submission tools
    └── registry_guidance.py    # Guidance and troubleshooting

Contributing

Fork the repository
Create a feature branch
Make your changes
Add tests if applicable
Submit a pull request

License

This project is licensed under the MIT License - see the file for details.

Related Projects

BioCypher MCP - MCP server for BioCypher workflows
BioContextAI Registry - The registry this MCP submits to
Model Context Protocol - The MCP specification

Support

For issues and questions:

Create an issue on GitHub
Check the troubleshooting guide
Review the example submissions
Use the field guidance tools