ReviewWebsite.com - MCP Server

This project provides a Model Context Protocol (MCP) server that connects AI assistants to ReviewWebsite.com API to create and manage website reviews, extract data, convert URLs to markdown, and more.

<a href="https://glama.ai/mcp/servers/@mrgoonie/reviewwebsite-mcp-server"> <img width="380" height="200" src="https://glama.ai/mcp/servers/@mrgoonie/reviewwebsite-mcp-server/badge" alt="ReviewWebsite Server MCP server" /> </a>

• Github
• NPM

Available Features

• Create, read, update, and delete website reviews
• Get available AI models
• Convert URLs to Markdown using AI
• Extract structured data from URLs using AI
• Scrape URLs and extract content
• Extract links from websites
• Summarize URLs and websites using AI
• SEO insights (keyword ideas, keyword difficulty, traffic analysis, backlinks)
• Customize AI models and parameters
• Control wait behavior and timing

ReviewWeb.site

• Website
• API Docs
• API Swagger Config
• Create your API key here

Supported Transports

• "stdio" transport - Default transport for CLI usage
• "Streamable HTTP" transport - For web-based clients
  • Implement auth ("Authorization" headers with Bearer <token>)
• "sse" transport (Deprecated)
• Write tests

How to use

CLI

# Get available AI models
npm run dev:cli -- get-ai-models --api-key "your-api-key"

# Create a new review
npm run dev:cli -- create-review --url "https://example.com" --instructions "Review this website" --api-key "your-api-key"

# Get a specific review by ID
npm run dev:cli -- get-review --review-id "review-id" --api-key "your-api-key"

# List all reviews
npm run dev:cli -- list-reviews --page 1 --limit 10 --api-key "your-api-key"

# Update a review
npm run dev:cli -- update-review --review-id "review-id" --url "https://example.com" --instructions "Updated instructions" --api-key "your-api-key"

# Delete a review
npm run dev:cli -- delete-review --review-id "review-id" --api-key "your-api-key"

# Convert URL to Markdown
npm run dev:cli -- convert-to-markdown --url "https://example.com" --model "gpt-4o" --api-key "your-api-key"

# Extract structured data from URL
npm run dev:cli -- extract-data --url "https://example.com" --instructions "Extract product information" --api-key "your-api-key"

# Scrape URL
npm run dev:cli -- scrape-url --url "https://example.com" --api-key "your-api-key"

# Extract links from URL
npm run dev:cli -- extract-links --url "https://example.com" --type "all" --api-key "your-api-key"

# Summarize URL
npm run dev:cli -- summarize-url --url "https://example.com" --model "gpt-4o" --api-key "your-api-key"

# Get keyword ideas for SEO
npm run dev:cli -- seo-keyword-ideas --keyword "digital marketing" --country "us" --search-engine "Google" --api-key "your-api-key"

# Check keyword difficulty
npm run dev:cli -- seo-keyword-difficulty --keyword "digital marketing" --country "us" --api-key "your-api-key"

# Analyze website traffic
npm run dev:cli -- seo-traffic --domain-or-url "example.com" --mode "subdomains" --country "us" --api-key "your-api-key"

# Get backlinks for a domain
npm run dev:cli -- seo-backlinks --domain "example.com" --api-key "your-api-key"

MCP Setup

For local configuration with stdio transport:

{
  "mcpServers": {
    "reviewwebsite": {
      "command": "node",
      "args": ["/path/to/reviewwebsite-mcp-server/dist/index.js"],
      "transportType": "stdio"
    }
  }
}

For remote HTTP configuration:

{
  "mcpServers": {
    "reviewwebsite": {
      "type": "http",
      "url": "http://localhost:8080/mcp"
    }
  }
}

Environment Variables for HTTP Transport:

You can configure the HTTP server using these environment variables:

• MCP_HTTP_HOST: The host to bind to (default: 127.0.0.1)
• MCP_HTTP_PORT: The port to listen on (default: 8080)
• MCP_HTTP_PATH: The endpoint path (default: /mcp)

---

Source Code Overview

What is MCP?

Model Context Protocol (MCP) is an open standard that allows AI systems to securely and contextually connect with external tools and data sources.

This boilerplate implements the MCP specification with a clean, layered architecture that can be extended to build custom MCP servers for any API or data source.

Why Use This Boilerplate?

• Production-Ready Architecture: Follows the same pattern used in published MCP servers, with clear separation between CLI, tools, controllers, and services.

• Type Safety: Built with TypeScript for improved developer experience, code quality, and maintainability.

• Working Example: Includes a fully implemented IP lookup tool demonstrating the complete pattern from CLI to API integration.

• Testing Framework: Comes with testing infrastructure for both unit and CLI integration tests, including coverage reporting.

• Development Tooling: Includes ESLint, Prettier, TypeScript, and other quality tools preconfigured for MCP server development.

---

Getting Started

Prerequisites

• Node.js (>=18.x): Download
• Git: For version control

---

Step 1: Clone and Install

# Clone the repository
git clone https://github.com/mrgoonie/reviewwebsite-mcp-server.git
cd reviewwebsite-mcp-server

# Install dependencies
npm install

---

Step 2: Run Development Server

Start the server in development mode with stdio transport (default):

npm run dev:server

Or with the Streamable HTTP transport:

npm run dev:server:http

This starts the MCP server with hot-reloading and enables the MCP Inspector at http://localhost:5173.

⚙️ Proxy server listening on port 6277 🔍 MCP Inspector is up and running at http://127.0.0.1:6274

When using HTTP transport, the server will be available at http://127.0.0.1:8080/mcp by default.

---

Step 3: Test the ReviewWebsite API Tools

Use the ReviewWebsite API tools via CLI:

# Get available AI models
npm run dev:cli -- get-ai-models --api-key "your-api-key"

# Create a review
npm run dev:cli -- create-review --url "https://example.com" --instructions "Review this website" --api-key "your-api-key"

# Convert URL to Markdown
npm run dev:cli -- convert-to-markdown --url "https://example.com" --model "gpt-4o" --api-key "your-api-key"

---

Architecture

This boilerplate follows a clean, layered architecture pattern that separates concerns and promotes maintainability.

Project Structure

src/
├── cli/              # Command-line interfaces
├── controllers/      # Business logic
├── resources/        # MCP resources: expose data and content from your servers to LLMs
├── services/         # External API interactions
├── tools/            # MCP tool definitions
├── types/            # Type definitions
├── utils/            # Shared utilities
└── index.ts          # Entry point

Layers and Responsibilities

CLI Layer (src/cli/*.cli.ts)

• Purpose: Define command-line interfaces that parse arguments and call controllers
• Naming: Files should be named <feature>.cli.ts
• Testing: CLI integration tests in <feature>.cli.test.ts

Tools Layer (src/tools/*.tool.ts)

• Purpose: Define MCP tools with schemas and descriptions for AI assistants
• Naming: Files should be named <feature>.tool.ts with types in <feature>.types.ts
• Pattern: Each tool should use zod for argument validation

Controllers Layer (src/controllers/*.controller.ts)

• Purpose: Implement business logic, handle errors, and format responses
• Naming: Files should be named <feature>.controller.ts
• Pattern: Should return standardized ControllerResponse objects

Services Layer (src/services/*.service.ts)

• Purpose: Interact with external APIs or data sources
• Naming: Files should be named <feature>.service.ts
• Pattern: Pure API interactions with minimal logic

Utils Layer (src/utils/*.util.ts)

• Purpose: Provide shared functionality across the application
• Key Utils:
  • logger.util.ts: Structured logging
  • error.util.ts: Error handling and standardization
  • formatter.util.ts: Markdown formatting helpers

---

Development Guide

Development Scripts

# Start server in development mode (hot-reload & inspector)
npm run dev:server

# Run CLI in development mode
npm run dev:cli -- [command] [args]

# Build the project
npm run build

# Start server in production mode
npm run start:server

# Run CLI in production mode
npm run start:cli -- [command] [args]

Testing

# Run all tests
npm test

# Run specific tests
npm test -- src/path/to/test.ts

# Generate test coverage report
npm run test:coverage

Code Quality

# Lint code
npm run lint

# Format code with Prettier
npm run format

# Check types
npm run typecheck

---

Building Custom Tools

Follow these steps to add your own tools to the server:

1. Define Service Layer

Create a new service in src/services/ to interact with your external API:

// src/services/example.service.ts
import { Logger } from '../utils/logger.util.js';

const logger = Logger.forContext('services/example.service.ts');

export async function getData(param: string): Promise<any> {
	logger.debug('Getting data', { param });
	// API interaction code here
	return { result: 'example d

---