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

Webseite
API-Dokumente
API Swagger-Konfiguration
Erstellen Sie hier Ihren API-Schlüssel

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 install

Schritt 2: Entwicklungsserver ausführen

Starten Sie den Server im Entwicklungsmodus mit stdio-Transport (Standard):

npm run dev:server

Oder mit dem Streamable HTTP-Transport:

npm run dev:server:http

Dadurch 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 point

Ebenen und Verantwortlichkeiten

CLI-Schicht ( `src/cli/*.cli.ts` )

Zweck : Definieren Sie Befehlszeilenschnittstellen, die Argumente analysieren und Controller aufrufen
Benennung : Dateien sollten <feature>.cli.ts heißen
Testen : 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.ts mit Typen in <feature>.types.ts benannt werden
Muster : 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.ts heißen
Muster : Sollte standardisierte ControllerResponse Objekte zurückgeben

Serviceebene ( `src/services/*.service.ts` )

Zweck : Interaktion mit externen APIs oder Datenquellen
Benennung : Dateien sollten <feature>.service.ts heißen
Muster : 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 Protokollieren
- error.util.ts : Fehlerbehandlung und Standardisierung
- formatter.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:coverage

Codequalität

# Lint code
npm run lint

# Format code with Prettier
npm run format

# Check types
npm run typecheck

Erstellen 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.json

Verö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 build
Testen Sie den Produktionsbuild: npm run start:server
Auf npm veröffentlichen: npm publish

Lizenz

MIT-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.

Install Server

HTTP connection URL

security – no known vulnerabilities

license - permissive license

quality - confirmed to work

How are these scores calculated?

remote-capable server

The server can be hosted and run remotely because it primarily relies on remote services or has no dependency on the local environment.

Tools

View all tools

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 mit Webinhalten zu interagieren.

Related Resources

Reddit Discussion about this server

Related MCP Servers

SEO AI Assistant
ayushsinghvi92
-
security
F
license
-
quality
MCP server that enables AI assistants to perform SEO automation tasks including keyword research, SERP analysis, and competitor analysis through Google Ads API integration.
Last updated -
browser-mcp
djyde
-
security
F
license
-
quality
A MCP server that allows AI assistants to interact with the browser, including getting page content as markdown, modifying page styles, and searching browser history.
Last updated -
5
TypeScript
YouTube Toolbox
jikime
A
security
F
license
A
quality
An MCP server that provides AI assistants with powerful tools to interact with YouTube, including video searching, transcript extraction, comment retrieval, and more.
Last updated -
8
12
Python
Rini MCP Server
mori-mmmm
-
security
A
license
-
quality
A collection of custom MCP servers providing various AI-powered capabilities including web search, YouTube video analysis, GitHub repository analysis, reasoning, code generation/execution, and web crawling.
Last updated -
2
Python
MIT License

View all related MCP servers