ReviewWebsite MCP Server
ReviewWebsite.com - Servidor MCP
Este proyecto proporciona un servidor de Protocolo de Contexto de Modelo (MCP) que conecta a los asistentes de IA con la API de ReviewWebsite.com para crear y administrar reseñas de sitios web, extraer datos, convertir URL a Markdown y más.
Funciones disponibles
[x] Crear, leer, actualizar y eliminar reseñas de sitios web
[x] Obtenga modelos de IA disponibles
[x] Convertir URL a Markdown usando IA
[x] Extraer datos estructurados de URL mediante IA
[x] Extraer URL y contenido
[x] Extraer enlaces de sitios web
[x] Resumir URL y sitios web usando IA
[x] Información SEO (ideas de palabras clave, dificultad de palabras clave, análisis de tráfico, vínculos de retroceso)
[x] Personalizar modelos y parámetros de IA
[x] Controlar el comportamiento y el tiempo de espera
ReviewWeb.site
Crea tu clave API aquí
Related MCP server: WebforAI Text Extractor
Transportes soportados
[x] Transporte "stdio" : transporte predeterminado para el uso de CLI
[x] Transporte"HTTP transmitible" : para clientes web
[ ] Implementar autenticación (encabezados "Autorización" con
Bearer <token>)
[ ]
transporte "sse"(Obsoleto)[ ] Escribir pruebas
Cómo utilizar
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"Configuración de MCP
Para la configuración local con transporte stdio:
{
"mcpServers": {
"reviewwebsite": {
"command": "node",
"args": ["/path/to/reviewwebsite-mcp-server/dist/index.js"],
"transportType": "stdio"
}
}
}Para la configuración HTTP remota:
{
"mcpServers": {
"reviewwebsite": {
"type": "http",
"url": "http://localhost:8080/mcp"
}
}
}Variables de entorno para el transporte HTTP:
Puede configurar el servidor HTTP utilizando estas variables de entorno:
MCP_HTTP_HOST: El host al que vincularse (predeterminado:127.0.0.1)MCP_HTTP_PORT: El puerto para escuchar (predeterminado:8080)MCP_HTTP_PATH: La ruta del punto final (predeterminado:/mcp)
Descripción general del código fuente
¿Qué es MCP?
El Protocolo de Contexto de Modelo (MCP) es un estándar abierto que permite a los sistemas de IA conectarse de forma segura y contextual con herramientas y fuentes de datos externas.
Esta plantilla implementa la especificación MCP con una arquitectura limpia y en capas que puede ampliarse para crear servidores MCP personalizados para cualquier API o fuente de datos.
¿Por qué utilizar este texto estándar?
Arquitectura lista para producción : sigue el mismo patrón utilizado en los servidores MCP publicados, con una clara separación entre CLI, herramientas, controladores y servicios.
Seguridad de tipos : creado con TypeScript para mejorar la experiencia del desarrollador, la calidad del código y la facilidad de mantenimiento.
Ejemplo de trabajo : incluye una herramienta de búsqueda de IP completamente implementada que demuestra el patrón completo desde la CLI hasta la integración de API.
Marco de pruebas : incluye infraestructura de pruebas para pruebas de integración unitarias y CLI, incluidos informes de cobertura.
Herramientas de desarrollo : incluye ESLint, Prettier, TypeScript y otras herramientas de calidad preconfiguradas para el desarrollo de servidores MCP.
Empezando
Prerrequisitos
Node.js (>=18.x): Descargar
Git : para el control de versiones
Paso 1: Clonar e instalar
# Clone the repository
git clone https://github.com/mrgoonie/reviewwebsite-mcp-server.git
cd reviewwebsite-mcp-server
# Install dependencies
npm installPaso 2: Ejecutar el servidor de desarrollo
Inicie el servidor en modo de desarrollo con el transporte stdio (predeterminado):
npm run dev:serverO con el transporte HTTP Streamable:
npm run dev:server:httpEsto inicia el servidor MCP con recarga activa y habilita el Inspector MCP en http://localhost:5173 .
⚙️ El servidor proxy escucha en el puerto 6277 🔍 MCP Inspector está en funcionamiento en http://127.0.0.1:6274
Al utilizar el transporte HTTP, el servidor estará disponible en http://127.0.0.1:8080/mcp de forma predeterminada.
Paso 3: Pruebe las herramientas de la API de ReviewWebsite
Utilice las herramientas de la API de ReviewWebsite a través de 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"Arquitectura
Este modelo sigue un patrón de arquitectura limpio y en capas que separa las preocupaciones y promueve la capacidad de mantenimiento.
Estructura del proyecto
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 pointCapas y responsabilidades
Capa CLI ( src/cli/*.cli.ts )
Propósito : Definir interfaces de línea de comandos que analizan argumentos y llaman a controladores.
Nombre : Los archivos deben llamarse
<feature>.cli.tsPruebas : pruebas de integración de CLI en
<feature>.cli.test.ts
Capa de herramientas ( src/tools/*.tool.ts )
Propósito : Definir herramientas MCP con esquemas y descripciones para asistentes de IA.
Nombre : Los archivos deben llamarse
<feature>.tool.tscon tipos en<feature>.types.tsPatrón : Cada herramienta debe usar zod para la validación de argumentos
Capa de controladores ( src/controllers/*.controller.ts )
Propósito : Implementar lógica empresarial, manejar errores y dar formato a respuestas.
Nombre : Los archivos deben llamarse
<feature>.controller.tsPatrón : Debe devolver objetos
ControllerResponseestandarizados
Capa de servicios ( src/services/*.service.ts )
Propósito : Interactuar con API externas o fuentes de datos
Nombre : Los archivos deben llamarse
<feature>.service.tsPatrón : Interacciones de API puras con lógica mínima
Capa de utilidades ( src/utils/*.util.ts )
Propósito : Proporcionar funcionalidad compartida en toda la aplicación.
Utilidades clave :
logger.util.ts: Registro estructuradoerror.util.ts: Manejo de errores y estandarizaciónformatter.util.ts: ayudantes de formato Markdown
Guía de desarrollo
Scripts de desarrollo
# 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]Pruebas
# Run all tests
npm test
# Run specific tests
npm test -- src/path/to/test.ts
# Generate test coverage report
npm run test:coverageCalidad del código
# Lint code
npm run lint
# Format code with Prettier
npm run format
# Check types
npm run typecheckCreación de herramientas personalizadas
Siga estos pasos para agregar sus propias herramientas al servidor:
1. Definir la capa de servicio
Cree un nuevo servicio en src/services/ para interactuar con su API externa:
// 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 data' };
}2. Crear controlador
Agregue un controlador en src/controllers/ para manejar la lógica empresarial:
// src/controllers/example.controller.ts
import { Logger } from '../utils/logger.util.js';
import * as exampleService from '../services/example.service.js';
import { formatMarkdown } from '../utils/formatter.util.js';
import { handleControllerError } from '../utils/error-handler.util.js';
import { ControllerResponse } from '../types/common.types.js';
const logger = Logger.forContext('controllers/example.controller.ts');
export interface GetDataOptions {
param?: string;
}
export async function getData(
options: GetDataOptions = {},
): Promise<ControllerResponse> {
try {
logger.debug('Getting data with options', options);
const data = await exampleService.getData(options.param || 'default');
const content = formatMarkdown(data);
return { content };
} catch (error) {
throw handleControllerError(error, {
entityType: 'ExampleData',
operation: 'getData',
source: 'controllers/example.controller.ts',
});
}
}3. Implementar la herramienta MCP
Crea una definición de herramienta en src/tools/ :
// src/tools/example.tool.ts
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';
import { Logger } from '../utils/logger.util.js';
import { formatErrorForMcpTool } from '../utils/error.util.js';
import * as exampleController from '../controllers/example.controller.js';
const logger = Logger.forContext('tools/example.tool.ts');
const GetDataArgs = z.object({
param: z.string().optional().describe('Optional parameter'),
});
type GetDataArgsType = z.infer<typeof GetDataArgs>;
async function handleGetData(args: GetDataArgsType) {
try {
logger.debug('Tool get_data called', args);
const result = await exampleController.getData({
param: args.param,
});
return {
content: [{ type: 'text' as const, text: result.content }],
};
} catch (error) {
logger.error('Tool get_data failed', error);
return formatErrorForMcpTool(error);
}
}
export function register(server: McpServer) {
server.tool(
'get_data',
`Gets data from the example API, optionally using \`param\`.
Use this to fetch example data. Returns formatted data as Markdown.`,
GetDataArgs.shape,
handleGetData,
);
}4. Agregar compatibilidad con CLI
Cree un comando CLI en src/cli/ :
// src/cli/example.cli.ts
import { program } from 'commander';
import { Logger } from '../utils/logger.util.js';
import * as exampleController from '../controllers/example.controller.js';
import { handleCliError } from '../utils/error-handler.util.js';
const logger = Logger.forContext('cli/example.cli.ts');
program
.command('get-data')
.description('Get example data')
.option('--param <value>', 'Optional parameter')
.action(async (options) => {
try {
logger.debug('CLI get-data called', options);
const result = await exampleController.getData({
param: options.param,
});
console.log(result.content);
} catch (error) {
handleCliError(error);
}
});5. Registrar componentes
Actualice los puntos de entrada para registrar sus nuevos componentes:
// In src/cli/index.ts
import '../cli/example.cli.js';
// In src/index.ts (for the tool)
import exampleTool from './tools/example.tool.js';
// Then in registerTools function:
exampleTool.register(server);Herramientas de depuración
Inspector de MCP
Acceda al Inspector visual de MCP para probar sus herramientas y ver los detalles de la solicitud/respuesta:
Ejecutar
npm run dev:serverAbra http://localhost:5173 en su navegador
Pruebe sus herramientas y vea los registros directamente en la interfaz de usuario
Registros del servidor
Habilitar registros de depuración para el desarrollo:
# Set environment variable
DEBUG=true npm run dev:server
# Or configure in ~/.mcp/configs.jsonPublicación de su servidor MCP
Cuando esté listo para publicar su servidor MCP personalizado:
Actualice package.json con sus datos
Actualice README.md con la documentación de su herramienta
Construya el proyecto:
npm run buildPruebe la compilación de producción:
npm run start:serverPublicar en npm:
npm publish
Licencia
{
"reviewwebsite": {
"environments": {
"DEBUG": "true",
"REVIEWWEBSITE_API_KEY": "your-api-key-here"
}
}
}Nota: Para compatibilidad con versiones anteriores, el servidor también reconocerá las configuraciones con el nombre completo del paquete ( reviewwebsite-mcp-server ) o con el nombre sin ámbito ( reviewwebsite-mcp-server ) si no se encuentra la clave reviewwebsite . Sin embargo, se recomienda usar la clave reviewwebsite corta para las nuevas configuraciones.
Available Tools
16 toolsconvert_multiple_to_markdownB
Convert multiple URLs to Markdown using AI via ReviewWeb.site API. Turn multiple web pages into LLM-friendly content.
Inputs: urls (required), model, instructions, delayAfterLoad, +3 more.
convert_to_markdownB
Convert a URL to Markdown using AI via ReviewWeb.site API. Turn a web page into LLM-friendly content.
Inputs: url (required), model, instructions, delayAfterLoad, +2 more.
extract_dataB
Extract structured data (JSON) from a web page URL using AI via ReviewWeb.site API.
Inputs: url (required), instructions (required), jsonTemplate (required), systemPrompt, +5 more.
extract_data_multipleB
Extract structured data (JSON) from multiple web page URLs using AI via ReviewWeb.site API.
Inputs: urls (required), instructions (required), jsonTemplate (required), systemPrompt, +4 more.
extract_linksC
Extract all links from a HTML content of web page URL using ReviewWeb.site API.
Inputs: url (required), type, maxLinks, delayAfterLoad, +4 more.
html_to_screenshotB
Convert HTML content to a screenshot image using ReviewWeb.site API. Renders raw HTML string via headless browser and returns screenshot as hosted URL or image data.
Inputs: html (required), viewport_width, viewport_height, full_page, +5 more.
scrape_urlC
Scrape a URL and return HTML content using ReviewWeb.site API.
Inputs: url (required), delayAfterLoad, api_key.
seo_backlinksB
Get backlinks for a domain using ReviewWeb.site API.
Inputs: domain (required), api_key.
seo_keyword_difficultyC
Get keyword difficulty for a keyword using ReviewWeb.site API.
Inputs: keyword (required), country, api_key.
seo_keyword_ideasB
Get keyword ideas for a keyword using ReviewWeb.site API.
Inputs: keyword (required), country, searchEngine, api_key.
seo_trafficC
Check traffic for a domain or URL using ReviewWeb.site API.
Inputs: domainOrUrl (required), mode, country, api_key.
summarize_multiple_urlsC
Summarize multiple web page URLs using AI via ReviewWeb.site API.
Inputs: urls (required), instructions, systemPrompt, model, +6 more.
summarize_urlB
Summarize a web page URL using AI via ReviewWeb.site API.
Inputs: url (required), instructions, systemPrompt, model, +5 more.
summarize_websiteC
Summarize a website (and its internal links) using AI via ReviewWeb.site API.
Inputs: url (required), instructions, systemPrompt, model, +6 more.
url_get_after_redirectsC
Get URL after redirects using ReviewWeb.site API.
Inputs: url (required), api_key.
url_is_aliveC
Check if a URL is alive using ReviewWeb.site API.
Inputs: url (required), timeout, proxyUrl, api_key.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 16 tools
Tools are mostly distinct in purpose, but some overlap exists (e.g., convert_to_markdown and extract_data both take URLs and produce AI-generated content). However, descriptions clarify the output format (markdown vs JSON), so ambiguity is low.
Naming conventions vary: some tools use 'convert_', 'extract_', 'summarize_', while SEO tools prefix with 'seo_' and URL tools with 'url_'. This grouping is helpful but not fully uniform across the set.
With 16 tools, the server covers a broad range of web page analysis features (scraping, AI conversion, SEO, URL utilities). The number is slightly above the typical 3-15 range but justified by the breadth of functionality.
The tool surface covers major web page operations: scraping, AI summarization, data extraction, SEO metrics, and URL checks. Minor gaps include no tool for batch extraction of links or more granular customization, but core workflows are supported.
Maintenance
Related MCP Connectors
MCP server that lets AI assistants use all OneSchema features exposed via the public API.
Turn any public website into an MCP server for agents to search, read and navigate.
Build, edit, host, and publish websites from AI assistants. Setup: https://mcp.orivox.org/
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
Related MCP Servers
- AlicenseBqualityDmaintenanceMCP server that enables LLMs to interact with Tripadvisor API, supporting location data, reviews, and photos through standardized MCP interfaces564MIT
- AlicenseNot gradedqualityNot gradedmaintenanceAn MCP server that extracts clean, structured Markdown content from web page URLs using the WebforAI library. It simplifies feeding web content into AI models by removing HTML noise and intelligently processing tables and links.-
- FlicenseNot gradedqualityDmaintenanceA locally-hosted MCP server that provides AI assistants with advanced web crawling capabilities, including structured data extraction, deep site crawling, and page screenshots. It enables users to convert single or multiple URLs into clean Markdown content for processing by LLMs without requiring external API keys for basic features.-
- AlicenseAqualityBmaintenanceAn MCP server that enables AI assistants to fetch web content in multiple formats (HTML, JSON, text, Markdown) with intelligent content extraction, chunk management, and browser automation support.6165 npm15MIT