ReviewWebsite MCP Server
ReviewWebsite.com - MCP-Server
Dieses Projekt bietet einen Model Context Protocol (MCP)-Server, der KI-Assistenten mit der ReviewWebsite.com -API verbindet, um Website-Bewertungen zu erstellen und zu verwalten, Daten zu extrahieren, URLs in Markdown zu konvertieren und mehr.
Verfügbare Funktionen
[x] Website-Bewertungen erstellen, lesen, aktualisieren und löschen
[x] Verfügbare KI-Modelle abrufen
[x] URLs mithilfe von KI in Markdown konvertieren
[x] Extrahieren Sie mithilfe von KI strukturierte Daten aus URLs
[x] URLs scrapen und Inhalte extrahieren
[x] Links von Websites extrahieren
[x] URLs und Websites mithilfe von KI zusammenfassen
[x] SEO-Einblicke (Keyword-Ideen, Keyword-Schwierigkeit, Verkehrsanalyse, Backlinks)
[x] KI-Modelle und Parameter anpassen
[x] Warteverhalten und -zeitpunkt steuern
ReviewWeb.site
Erstellen Sie hier Ihren API-Schlüssel
Related MCP server: WebforAI Text Extractor
Unterstützte Transporte
[x] "stdio" -Transport - Standardtransport für die CLI-Nutzung
[x]"Streamable HTTP" -Transport - Für webbasierte Clients
[ ] Implementieren Sie Auth ("Authorization"-Header mit
Bearer <token>)
[ ]
"sse"-Transport(Veraltet)[ ] Tests schreiben
Anwendung
Befehlszeilenschnittstelle (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-Einrichtung
Für die lokale Konfiguration mit stdio-Transport:
{
"mcpServers": {
"reviewwebsite": {
"command": "node",
"args": ["/path/to/reviewwebsite-mcp-server/dist/index.js"],
"transportType": "stdio"
}
}
}Für die Remote-HTTP-Konfiguration:
{
"mcpServers": {
"reviewwebsite": {
"type": "http",
"url": "http://localhost:8080/mcp"
}
}
}Umgebungsvariablen für den HTTP-Transport:
Sie können den HTTP-Server mit diesen Umgebungsvariablen konfigurieren:
MCP_HTTP_HOST: Der Host, an den die Verbindung hergestellt werden soll (Standard:127.0.0.1)MCP_HTTP_PORT: Der Port, auf dem gewartet werden soll (Standard:8080)MCP_HTTP_PATH: Der Endpunktpfad (Standard:/mcp)
Quellcodeübersicht
Was ist MCP?
Model Context Protocol (MCP) ist ein offener Standard, der es KI-Systemen ermöglicht, sich sicher und kontextbezogen mit externen Tools und Datenquellen zu verbinden.
Dieses Boilerplate implementiert die MCP-Spezifikation mit einer sauberen, geschichteten Architektur, die erweitert werden kann, um benutzerdefinierte MCP-Server für jede API oder Datenquelle zu erstellen.
Warum diesen Standardtext verwenden?
Produktionsreife Architektur : Folgt dem gleichen Muster wie veröffentlichte MCP-Server, mit klarer Trennung zwischen CLI, Tools, Controllern und Diensten.
Typsicherheit : Erstellt mit TypeScript für verbesserte Entwicklererfahrung, Codequalität und Wartbarkeit.
Funktionierendes Beispiel : Enthält ein vollständig implementiertes IP-Lookup-Tool, das das komplette Muster von der CLI- bis zur API-Integration demonstriert.
Testframework : Wird mit einer Testinfrastruktur für Unit- und CLI-Integrationstests geliefert, einschließlich Abdeckungsberichten.
Entwicklungstools : Enthält ESLint, Prettier, TypeScript und andere hochwertige Tools, die für die MCP-Serverentwicklung vorkonfiguriert sind.
Erste Schritte
Voraussetzungen
Node.js (>=18.x): Herunterladen
Git : Zur Versionskontrolle
Schritt 1: Klonen und installieren
# Clone the repository
git clone https://github.com/mrgoonie/reviewwebsite-mcp-server.git
cd reviewwebsite-mcp-server
# Install dependencies
npm installSchritt 2: Entwicklungsserver ausführen
Starten Sie den Server im Entwicklungsmodus mit stdio-Transport (Standard):
npm run dev:serverOder mit dem Streamable HTTP-Transport:
npm run dev:server:httpDadurch wird der MCP-Server mit Hot-Reloading gestartet und der MCP Inspector unter http://localhost:5173 aktiviert.
⚙️ Proxyserver lauscht auf Port 6277 🔍 MCP Inspector ist unter http://127.0.0.1:6274 aktiv
Bei Verwendung des HTTP-Transports ist der Server standardmäßig unter http://127.0.0.1:8080/mcp verfügbar.
Schritt 3: Testen Sie die ReviewWebsite-API-Tools
Verwenden Sie die ReviewWebsite-API-Tools über die 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"Architektur
Dieser Standardtext folgt einem klaren, geschichteten Architekturmuster, das Belange trennt und die Wartbarkeit fördert.
Projektstruktur
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 pointEbenen und Verantwortlichkeiten
CLI-Schicht ( src/cli/*.cli.ts )
Zweck : Definieren Sie Befehlszeilenschnittstellen, die Argumente analysieren und Controller aufrufen
Benennung : Dateien sollten
<feature>.cli.tsheißenTesten : CLI-Integrationstests in
<feature>.cli.test.ts
Tools-Ebene ( src/tools/*.tool.ts )
Zweck : Definieren Sie MCP-Tools mit Schemata und Beschreibungen für KI-Assistenten
Benennung : Dateien sollten
<feature>.tool.tsmit Typen in<feature>.types.tsbenannt werdenMuster : Jedes Tool sollte zod zur Argumentvalidierung verwenden
Controller-Ebene ( src/controllers/*.controller.ts )
Zweck : Implementieren Sie Geschäftslogik, behandeln Sie Fehler und formatieren Sie Antworten
Benennung : Dateien sollten
<feature>.controller.tsheißenMuster : Sollte standardisierte
ControllerResponseObjekte zurückgeben
Serviceebene ( src/services/*.service.ts )
Zweck : Interaktion mit externen APIs oder Datenquellen
Benennung : Dateien sollten
<feature>.service.tsheißenMuster : Reine API-Interaktionen mit minimaler Logik
Utils-Ebene ( src/utils/*.util.ts )
Zweck : Bereitstellung gemeinsamer Funktionen für die gesamte Anwendung
Wichtige Dienstprogramme :
logger.util.ts: Strukturiertes Protokollierenerror.util.ts: Fehlerbehandlung und Standardisierungformatter.util.ts: Markdown-Formatierungshilfen
Entwicklungshandbuch
Entwicklungsskripte
# 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]Testen
# Run all tests
npm test
# Run specific tests
npm test -- src/path/to/test.ts
# Generate test coverage report
npm run test:coverageCodequalität
# Lint code
npm run lint
# Format code with Prettier
npm run format
# Check types
npm run typecheckErstellen benutzerdefinierter Tools
Befolgen Sie diese Schritte, um dem Server Ihre eigenen Tools hinzuzufügen:
1. Service-Layer definieren
Erstellen Sie einen neuen Dienst in src/services/ um mit Ihrer externen API zu interagieren:
// 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. Controller erstellen
Fügen Sie einen Controller in src/controllers/ hinzu, um die Geschäftslogik zu handhaben:
// 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. Implementieren Sie das MCP-Tool
Erstellen Sie eine Tooldefinition in 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. CLI-Unterstützung hinzufügen
Erstellen Sie einen CLI-Befehl in 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. Komponenten registrieren
Aktualisieren Sie die Einstiegspunkte, um Ihre neuen Komponenten zu registrieren:
// 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);Debugging-Tools
MCP-Inspektor
Greifen Sie auf den visuellen MCP-Inspektor zu, um Ihre Tools zu testen und Anforderungs-/Antwortdetails anzuzeigen:
Führen Sie
npm run dev:serverÖffnen Sie http://localhost:5173 in Ihrem Browser
Testen Sie Ihre Tools und zeigen Sie Protokolle direkt in der Benutzeroberfläche an
Serverprotokolle
Aktivieren Sie Debug-Protokolle für die Entwicklung:
# Set environment variable
DEBUG=true npm run dev:server
# Or configure in ~/.mcp/configs.jsonVeröffentlichen Ihres MCP-Servers
Wenn Sie bereit sind, Ihren benutzerdefinierten MCP-Server zu veröffentlichen:
Aktualisieren Sie package.json mit Ihren Details
Aktualisieren Sie README.md mit Ihrer Tool-Dokumentation
Erstellen Sie das Projekt:
npm run buildTesten Sie den Produktionsbuild:
npm run start:serverAuf npm veröffentlichen:
npm publish
Lizenz
{
"reviewwebsite": {
"environments": {
"DEBUG": "true",
"REVIEWWEBSITE_API_KEY": "your-api-key-here"
}
}
}Hinweis: Aus Gründen der Abwärtskompatibilität erkennt der Server auch Konfigurationen mit dem vollständigen Paketnamen ( reviewwebsite-mcp-server ) oder dem Paketnamen ohne Gültigkeitsbereich ( reviewwebsite-mcp-server ), wenn der reviewwebsite Schlüssel nicht gefunden wird. Für neue Konfigurationen wird jedoch die Verwendung des kurzen reviewwebsite -Schlüssels empfohlen.
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