This guide explains how to use the NerdCabalMCP server with Claude Code and Claude Desktop. NerdCabalMCP provides 17 specialized AI agents that assist with research, security, design, finance, operations, and enterprise IP protection.
This MCP server also includes Paper2Agent, a multi-agent AI system that automatically transforms research papers into interactive AI agents with minimal human input.
# Clone the repository
git clone https://github.com/Tuesdaythe13th/NerdCabalMCP.git
cd NerdCabalMCP/mcp-server
# Install dependencies
npm install
# Build the TypeScript code
npm run build
Add the following to your Claude Desktop configuration file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
{
"mcpServers": {
"nerdcabal": {
"command": "node",
"args": [
"/absolute/path/to/NerdCabalMCP/mcp-server/dist/index.js"
],
"env": {
"LOG_LEVEL": "info"
}
}
}
}
Important: Replace /absolute/path/to/ with the actual absolute path on your system.
Completely quit and reopen Claude Desktop for the changes to take effect.
In Claude Desktop:
@ to see available toolsnerdcabal toolsYou should see tools like:
llm-rubric-architectexperimental-designerbudget-agentcreative-directorTool: ip_analytics
Analyzes intellectual property patterns, portfolio valuation, and competitive scanning.
Example usage:
@nerdcabal Use ip_analytics to analyze copyright infringement patterns
for the last 90 days in portfolio PORT-001.
Tool: compliance_check
Validates GDPR, DMCA, EU Copyright Directive, and AI Act compliance.
Example usage:
@nerdcabal Use compliance_check to validate GDPR compliance for a system
that processes personal data with consent.
Tool: archival_system
Stores IP infringement evidence with cryptographic integrity using SHA-256 chain hashing.
Example usage:
@nerdcabal Use archival_system to store evidence of copyright infringement
from https://example.com/infringement.jpg for case CASE-2026-001.
Tool: llm-rubric-architect
Creates comprehensive evaluation rubrics for AI systems.
Example usage:
@nerdcabal Use llm-rubric-architect to create a rubric for evaluating
chatbot responses. Include accuracy, helpfulness, safety, and tone on a 1-5 scale.
Tool: experimental-designer
Designs controlled experiments with proper methodology and power analysis.
Example usage:
@nerdcabal Use experimental-designer to design an A/B test.
Hypothesis: Chain-of-thought prompting improves accuracy on math problems.
Sample size: 1000. Metric: accuracy.
Tool: forensic-analyst
Detects hallucinations and errors in LLM outputs using DSMMD taxonomy.
Example usage:
@nerdcabal Use forensic-analyst to analyze this transcript for hallucinations:
[paste transcript here]
Tool: budget-agent
Creates budgets for grants, investor pitches, and project planning.
Example usage:
@nerdcabal Use budget-agent to create an NSF grant budget for an AI research project.
Funding target: $500,000. Timeline: 18 months.
Tool: comptroller-agent
Analyzes the Iron Triangle (Speed âź· Cost âź· Quality) trade-offs.
Example usage:
@nerdcabal Use comptroller-agent to analyze trade-offs for building a new feature
in 2 weeks with $10,000 budget and production-quality requirements.
Tool: administrator-agent
Designs organizational structures, SOPs, and team configurations.
Example usage:
@nerdcabal Use administrator-agent to design an org chart for a distributed AI team
with 15 people across US East, US West, EU, and Asia timezones.
Tool: ciso-agent
Performs STRIDE threat modeling and security audits.
Example usage:
@nerdcabal Use ciso-agent to perform a STRIDE threat model for an LLM API
with components: API gateway, model inference, user database.
Tool: mlflow-agent
Generates MLflow queries for experiment tracking.
Example usage:
@nerdcabal Use mlflow-agent to create a query that finds the top 10 model runs
with highest accuracy from the last 30 days.
Tool: dataset-builder
Creates ML training datasets in SFT, DPO, or RLHF formats.
Example usage:
@nerdcabal Use dataset-builder to create a supervised fine-tuning dataset
for teaching Python code generation. Include 5 examples in HuggingFace format.
Tool: visual-inspector
Generates FiftyOne scripts for dataset visualization and quality analysis.
Example usage:
@nerdcabal Use visual-inspector to create a FiftyOne visualization script
for CIFAR-10 to find mislabeled images.
Tool: creative-director
Creates design systems, color palettes, and UI/UX specifications.
Example usage:
@nerdcabal Use creative-director to create a cyberpunk brutalist design system
with colors: black, white, red. Components: buttons, cards, navigation. Output: CSS.
Tool: orchestrator
Coordinates multi-agent workflows using ADK patterns (Sequential, Parallel, Loop, Coordinator).
Example usage:
@nerdcabal Use orchestrator to create a sequential workflow:
1. experimental-designer creates an experiment
2. budget-agent creates a budget
3. administrator-agent designs the team
The Paper2Agent system converts research papers into interactive MCP tools.
Custom Claude Agents (in .claude/agents/):
tutorial-scanner - Identifies tutorial materials in codebasestutorial-executor - Executes notebooks to generate outputstutorial-tool-extractor-implementor - Extracts reusable functionstest-verifier-improver - Creates and validates testsenvironment-python-manager - Manages Python environmentsbenchmark-extractor, benchmark-judge, benchmark-reviewer, benchmark-solver - Benchmark processingPaper2Agent is integrated into NerdCabalMCP and uses specialized agents for converting research papers to tools.
<project_dir>/
├── src/
│ ├── <repo_name>_mcp.py # Generated MCP server
│ └── tools/ # Extracted tools from tutorials
├── <repo_name>-env/ # Isolated Python environment
├── repo/<repo_name>/ # Cloned repository
├── reports/ # Analysis reports
├── tests/ # Generated test suites
└── notebooks/ # Executed tutorials
Model Context Protocol (MCP) is a standardized protocol for connecting AI models with external tools and data sources. Paper2Agent generates MCP servers using FastMCP that expose research paper functionality as callable tools.
Paper2Agent generates MCP servers with the following structure:
from fastmcp import FastMCP
from tools.example_tool import example_mcp
# Define the MCP server
mcp = FastMCP(name="ResearchPaper")
# Mount the tools
mcp.mount(example_mcp)
# Run the MCP server
if __name__ == "__main__":
mcp.run(transport="http", host="127.0.0.1", port=8003)
cd <working_dir>
fastmcp install claude-code <project_dir>/src/<repo_name>_mcp.py \
--python <project_dir>/<repo_name>-env/bin/python
bash launch_remote_mcp.sh \
--working_dir <working_dir> \
--mcp_name <mcp_name> \
--mcp_url <remote_mcp_url>
Example:
bash launch_remote_mcp.sh \
--working_dir analysis_dir \
--mcp_name alphagenome \
--mcp_url https://Paper2Agent-alphagenome-mcp.hf.space
# List installed MCP servers
claude mcp list
# Or inside Claude Code
\mcp
Each tool extracted by Paper2Agent follows this standardized format:
from fastmcp import FastMCP
from typing import Annotated, Literal
# Create MCP instance for the tool module
tool_mcp = FastMCP(name="tool_name")
@tool_mcp.tool
def example_tool(
required_param: Annotated[str, "Description of required parameter"],
optional_param: Annotated[str | None, "Description of optional parameter"] = None,
enum_param: Annotated[Literal["option1", "option2"], "Parameter with fixed options"] = "option1",
bool_param: Annotated[bool, "Boolean flag description"] = True,
) -> dict:
"""
Brief description of what the tool does.
"""
# Tool implementation
# Return standardized format
return {
"message": "Description of what was done",
"reference": "https://github.com/repo/tutorial.ipynb",
"artifacts": [
{
"description": "Output file description",
"path": "/absolute/path/to/output.csv"
}
]
}
All Paper2Agent tools return a standardized dictionary with:
@score_batch_mcp.tool
def score_batch_variants(
api_key: Annotated[str, "API key for the AlphaGenome model"],
vcf_file: Annotated[str | None, "Path to VCF/TSV/CSV file with columns: variant_id, CHROM, POS, REF, ALT"] = None,
organism: Annotated[Literal["human", "mouse"], "Organism to score against"] = "human",
sequence_length: Annotated[Literal["2KB", "16KB", "100KB", "500KB", "1MB"], "Context window"] = "1MB",
score_rna_seq: Annotated[bool, "Include RNA-seq signal prediction"] = True,
score_atac: Annotated[bool, "Include ATAC"] = True,
out_prefix: Annotated[str | None, "Output file prefix"] = None,
) -> dict:
"""
Score genetic variants in batch across multiple regulatory modalities using AlphaGenome.
"""
# Implementation details...
return {
"message": f"Scored {len(vcf)} variants and saved results table",
"reference": "https://github.com/AlphaPOP/blob/main/score_batch.ipynb",
"artifacts": [
{
"description": "Variant scores results table",
"path": str(download_path.resolve())
}
]
}
When the MCP server is connected to Claude Code, tools are automatically discovered and can be called:
User: Analyze heart gene expression data with AlphaGenome MCP to identify the
causal gene for the variant chr11:116837649:T>G, associated with
Hypoalphalipoproteinemia.
Claude Code will:
score_batch_variants)cd Paper2Agent
bash Paper2Agent.sh \
--project_dir <PROJECT_DIR> \
--github_url <GITHUB_URL>
# Process specific tutorials only
bash Paper2Agent.sh \
--project_dir <PROJECT_DIR> \
--github_url <GITHUB_URL> \
--tutorials <TUTORIALS_URL or TUTORIALS_TITLE>
# With API key for private repositories
bash Paper2Agent.sh \
--project_dir <PROJECT_DIR> \
--github_url <GITHUB_URL> \
--api <API_KEY>
bash Paper2Agent.sh \
--project_dir AlphaGenome_Agent \
--github_url https://github.com/google-deepmind/alphagenome \
--api <ALPHAGENOME_API_KEY>
bash Paper2Agent.sh \
--project_dir Scanpy_Agent \
--github_url https://github.com/scverse/scanpy \
--tutorials "Preprocessing and clustering"
Pre-built MCP servers hosted on Hugging Face:
Paper2Agent uses specialized agents for different pipeline stages:
Each agent is invoked automatically during the Paper2Agent pipeline.
Paper2Agent tools use Python type hints with Annotated for documentation:
Annotated[str, "Description"]Annotated[str | None, "Description"] = NoneAnnotated[Literal["opt1", "opt2"], "Description"]Annotated[bool, "Description"] = TrueAnnotated[int, "Description"]Annotated[float, "Description"]PROJECT_ROOT/tmp/outputs/{TOOL_NAME}_INPUT_DIR{TOOL_NAME}_OUTPUT_DIR\mcp in Claude Code to confirm server is loadedPaper2Agent includes automated testing and quality checks:
Located in reports/coverage/:
coverage.xml - CI/CD formatcoverage.json - Machine-readable formatcoverage_summary.txt - Quick metricscoverage_report.md - Detailed analysishtmlcov/ - Interactive HTML dashboardLocated in reports/quality/pylint/:
pylint_report.txt - Full analysispylint_scores.txt - Per-file scorespylint_issues.md - Issues breakdownreports/coverage_and_quality_report.md provides comprehensive metrics for all generated tools.
pip install fastmcp# Clone repository
git clone https://github.com/jmiao24/Paper2Agent.git
cd Paper2Agent
# Install dependencies
pip install fastmcp
# Install and configure Claude Code
npm install -g @anthropic-ai/claude-code
claude
@misc{miao2025paper2agent,
title={Paper2Agent: Reimagining Research Papers As Interactive and Reliable AI Agents},
author={Jiacheng Miao and Joe R. Davis and Jonathan K. Pritchard and James Zou},
year={2025},
eprint={2509.06917},
archivePrefix={arXiv},
primaryClass={cs.AI},
url={https://arxiv.org/abs/2509.06917},
}
Every agent follows this simple pattern:
@nerdcabal Use [agent-name] to [describe task]
You can chain multiple agents together:
@nerdcabal Let's plan a complete research project:
1. Use experimental-designer to design an A/B test for prompt engineering
2. Use budget-agent to create a 6-month budget for $200k
3. Use administrator-agent to design a team of 5 people
4. Use ciso-agent to identify security risks
Claude will execute each agent sequentially, passing context between them.
In Claude Code or Claude Desktop:
Type @ to see all available tools
Look for tools starting with the nerdcabal prefix
Or use the MCP command:
\mcp
See the comprehensive TESTING.md guide for:
Try this in Claude Desktop:
@nerdcabal Use llm-rubric-architect to create a simple rubric for
evaluating AI assistants on helpfulness and accuracy. Use a 1-3 scale.
If you get a well-formatted rubric back, your MCP is working perfectly!
~/Library/Application Support/Claude/claude_desktop_config.json%APPDATA%\Claude\claude_desktop_config.json~/.config/Claude/claude_desktop_config.json"args": ["/Users/yourname/NerdCabalMCP/mcp-server/dist/index.js"]
NOT:
"args": ["~/NerdCabalMCP/mcp-server/dist/index.js"] // ❌ Won't work
# macOS
tail -f ~/Library/Logs/Claude/mcp*.log
# Linux
tail -f ~/.config/Claude/logs/mcp*.log
cd mcp-server
npm run build
node dist/index.js
Should output: MCP server running on stdio
node --version # Should be v18.0.0 or higher
"env": {
"LOG_LEVEL": "debug"
}
Built with ❤️ by TUESDAY and the OG NerdCabal
WE RESPECT THE RULES OF THE SEA.