Skip to main content
Glama

Olostep MCP Server

Docker Hub npm version Lizenz: ISC

Eine Implementierung eines Model Context Protocol (MCP) Servers, die sich in Olostep für Web-Scraping, Inhaltsextraktion und Suchfunktionen integriert. Um den Olostep MCP Server einzurichten, benötigen Sie einen API-Schlüssel. Sie erhalten den API-Schlüssel durch die Registrierung auf der Olostep-Website.

Funktionen

  • Website-Inhalte in HTML, Markdown, JSON oder Klartext scrapen (mit optionalen Parsern)

  • Parser-basierte Websuche mit strukturierten Ergebnissen

  • KI-Antworten mit Quellenangaben und optionalen JSON-formatierten Ausgaben

  • Batch-Scraping von bis zu 10.000 URLs

  • Autonomes Site-Crawling ausgehend von einer Start-URL

  • Website-URL-Erkennung und -Mapping (mit Include/Exclude-Filtern)

  • Länderspezifisches Request-Routing für geo-targetierte Inhalte

  • Konfigurierbare Wartezeiten für JavaScript-lastige Websites

  • Umfassende Fehlerbehandlung und Berichterstattung

  • Einfache API-Schlüssel-Konfiguration

Related MCP server: Parallel Task MCP

Installation

Es gibt mehrere Möglichkeiten, eine Verbindung zum Olostep MCP Server herzustellen. Wählen Sie diejenige, die am besten zu Ihrem Workflow passt.

☁️ Remote-Endpunkt (Empfohlen)

Der einfachste Weg — keine lokale Installation erforderlich. Verbinden Sie sich direkt mit unserem gehosteten MCP-Server:

https://mcp.olostep.com/mcp

Die Authentifizierung erfolgt über ein Bearer-Token im Authorization-Header unter Verwendung Ihres Olostep-API-Schlüssels. Siehe den Abschnitt Client-Setup weiter unten für Konfigurationsbeispiele.

🐳 Docker Hub

Ziehen Sie das offizielle Docker-Image und führen Sie es aus:

docker pull olostep/mcp-server

docker run -i --rm \
  -e OLOSTEP_API_KEY="your-api-key" \
  olostep/mcp-server

🔧 Lokaler Docker-Build

Wenn Sie das Image lieber selbst aus dem Quellcode erstellen möchten:

git clone https://github.com/olostep/olostep-mcp-server.git
cd olostep-mcp-server
npm install
npm run build
docker build -t olostep/mcp-server:local .

docker run -i --rm -e OLOSTEP_API_KEY="your-api-key" olostep/mcp-server:local

📦 npx

Führen Sie es ohne Installation mit npx aus:

env OLOSTEP_API_KEY=your-api-key npx -y olostep-mcp

Unter Windows (PowerShell):

$env:OLOSTEP_API_KEY = "your-api-key"; npx -y olostep-mcp

Unter Windows (CMD):

set OLOSTEP_API_KEY=your-api-key && npx -y olostep-mcp

Oder global installieren:

npm install -g olostep-mcp

Client-Setup

Cursor

Der einfachste Weg ist die Verwendung des Remote-Endpunkts. Erstellen oder bearbeiten Sie .cursor/mcp.json in Ihrem Projektstammverzeichnis:

{
  "mcpServers": {
    "olostep": {
      "url": "https://mcp.olostep.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY_HERE"
      }
    }
  }
}

Alternative (lokal): Gehen Sie zu Cursor-Einstellungen > Features > MCP Servers, klicken Sie auf "+ Add New MCP Server":

  • Name: olostep

  • Typ: command

  • Befehl: env OLOSTEP_API_KEY=your-api-key npx -y olostep-mcp

Claude Desktop

Fügen Sie dies zu Ihrer claude_desktop_config.json hinzu:

{
  "mcpServers": {
    "mcp-server-olostep": {
      "command": "npx",
      "args": ["-y", "olostep-mcp"],
      "env": {
        "OLOSTEP_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}

Alternative (Docker):

{
  "mcpServers": {
    "olostep": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "OLOSTEP_API_KEY=YOUR_API_KEY_HERE",
        "olostep/mcp-server"
      ]
    }
  }
}

Oder installieren Sie es über die Smithery CLI in Ihrem Geräteterminal:

npx -y @smithery/cli install @olostep/olostep-mcp-server --client claude

Claude Code

Fügen Sie den Remote-Endpunkt zu Ihrer Claude Code MCP-Konfiguration hinzu:

{
  "mcpServers": {
    "olostep": {
      "url": "https://mcp.olostep.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY_HERE"
      }
    }
  }
}

Alternative (lokal):

{
  "mcpServers": {
    "olostep": {
      "command": "npx",
      "args": ["-y", "olostep-mcp"],
      "env": {
        "OLOSTEP_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}

Windsurf

Fügen Sie dies zu Ihrer ./codeium/windsurf/model_config.json hinzu:

{
  "mcpServers": {
    "olostep": {
      "serverUrl": "https://mcp.olostep.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY_HERE"
      }
    }
  }
}

Alternative (lokal):

{
  "mcpServers": {
    "mcp-server-olostep": {
      "command": "npx",
      "args": ["-y", "olostep-mcp"],
      "env": {
        "OLOSTEP_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}

VS Code

Fügen Sie dies zu Ihrer .vscode/mcp.json hinzu:

{
  "servers": {
    "olostep": {
      "type": "http",
      "url": "https://mcp.olostep.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY_HERE"
      }
    }
  }
}

Alternative (lokal):

{
  "servers": {
    "olostep": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "olostep-mcp"],
      "env": {
        "OLOSTEP_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}

Metorial

Option 1: Ein-Klick-Installation (Empfohlen)

  1. Öffnen Sie das Metorial Dashboard

  2. Navigieren Sie zum Verzeichnis der MCP-Server

  3. Suchen Sie nach "Olostep"

  4. Klicken Sie auf "Install" und geben Sie Ihren API-Schlüssel ein

Option 2: Manuelle Konfiguration

Fügen Sie dies zu Ihrer Metorial MCP-Server-Konfiguration hinzu:

{
  "olostep": {
    "command": "npx",
    "args": ["-y", "olostep-mcp"],
    "env": {
      "OLOSTEP_API_KEY": "YOUR_API_KEY_HERE"
    }
  }
}

Die Olostep-Tools stehen dann in Ihren Metorial-KI-Chats zur Verfügung.

Konfiguration

Umgebungsvariablen

  • OLOSTEP_API_KEY: Ihr Olostep-API-Schlüssel (erforderlich)

  • ORBIT_KEY: Ein optionaler Schlüssel für die Verwendung von Orbit zum Routen von Anfragen.

Verfügbare Tools

1. Website scrapen (scrape_website)

Extrahieren Sie Inhalte von einer einzelnen URL. Unterstützt mehrere Formate und JavaScript-Rendering.

{
  "name": "scrape_website",
  "arguments": {
    "url_to_scrape": "https://example.com",
    "output_format": "markdown",
    "country": "US",
    "wait_before_scraping": 1000,
    "parser": "@olostep/amazon-product"
  }
}

Parameter:

  • url_to_scrape: Die URL der Website, die Sie scrapen möchten (erforderlich)

  • output_format: Wählen Sie das Format (html, markdown, json oder text) - Standard: markdown

  • country: Optionaler Ländercode (z. B. US, GB, CA) für standortspezifisches Scraping

  • wait_before_scraping: Wartezeit in Millisekunden vor dem Scraping (0-10000)

  • parser: Optionale Parser-ID für spezialisierte Extraktion

Antwort (Beispiel):

{
  "content": [
    {
      "type": "text",
      "text": "{\n  \"id\": \"scrp_...\",\n  \"url\": \"https://example.com\",\n  \"markdown_content\": \"# ...\",\n  \"html_content\": null,\n  \"json_content\": null,\n  \"text_content\": null,\n  \"status\": \"succeeded\",\n  \"timestamp\": \"2025-11-14T12:34:56Z\",\n  \"screenshot_hosted_url\": null,\n  \"page_metadata\": { }\n}"
    }
  ]
}

2. Websuche (search_web)

Durchsuchen Sie das Web nach einer bestimmten Anfrage und erhalten Sie strukturierte Ergebnisse (nicht-KI, Parser-basiert).

{
  "name": "search_web",
  "arguments": {
    "query": "your search query",
    "country": "US"
  }
}

Parameter:

  • query: Suchanfrage (erforderlich)

  • country: Optionaler Ländercode für lokalisierte Ergebnisse (Standard: US)

Antwort:

  • Strukturiertes JSON (als Text), das Parser-basierte Ergebnisse darstellt

3. Antworten (KI) (answers)

Durchsuchen Sie das Web und erhalten Sie KI-gestützte Antworten in der gewünschten JSON-Struktur, mit Quellen und Zitaten.

{
  "name": "answers",
  "arguments": {
    "task": "Who are the top 5 competitors to Acme Inc. in the EU?",
    "json": "Return a list of the top 5 competitors with name and homepage URL"
  }
}

Parameter:

  • task: Frage oder Aufgabe, die mithilfe von Webdaten beantwortet werden soll (erforderlich)

  • json: Optionales JSON-Schema/Objekt oder eine kurze Beschreibung der gewünschten Ausgabeform

Antwort beinhaltet:

  • answer_id, object, task, result (JSON, falls bereitgestellt), sources, created

4. Batch-Scraping von URLs (batch_scrape_urls)

Scrapen Sie bis zu 10.000 URLs gleichzeitig. Perfekt für die Datenextraktion im großen Maßstab.

{
  "name": "batch_scrape_urls",
  "arguments": {
    "urls_to_scrape": [
      {"url": "https://example.com/a", "custom_id": "a"},
      {"url": "https://example.com/b", "custom_id": "b"}
    ],
    "output_format": "markdown",
    "country": "US",
    "wait_before_scraping": 500,
    "parser": "@olostep/amazon-product"
  }
}

Antwort beinhaltet:

  • batch_id, status, total_urls, created_at, formats, country, parser, urls

5. Crawl erstellen (create_crawl)

Starten Sie einen asynchronen Crawl, der autonom ganze Websites durch das Folgen von Links entdeckt und scrapt. Gibt eine crawl_id zurück — der Crawl läuft im Hintergrund und gibt in dieser Antwort keine Inhalte zurück. Sie müssen dann get_crawl_results mit der crawl_id aufrufen, um den Status abzufragen und die gescrapten Seiten abzurufen (dasselbe Zwei-Schritte-Muster wie bei batch_scrape_urls + get_batch_results).

{
  "name": "create_crawl",
  "arguments": {
    "start_url": "https://example.com/docs",
    "max_pages": 25,
    "follow_links": true,
    "output_format": "markdown",
    "country": "US",
    "parser": "@olostep/doc-parser"
  }
}

Antwort beinhaltet:

  • crawl_id, object, status, start_url, max_pages, follow_links, created, formats, country, parser

Kombinieren Sie diesen Aufruf mit get_crawl_results — übergeben Sie keine crawl_id an get_batch_results (Crawls und Batches sind separate Ressourcen).

6. Map erstellen (create_map)

Erhalten Sie alle URLs auf einer Website. Extrahieren Sie alle URLs zur Erkennung und Analyse.

{
  "name": "create_map",
  "arguments": {
    "website_url": "https://example.com",
    "search_query": "blog",
    "top_n": 200,
    "include_url_patterns": ["/blog/**"],
    "exclude_url_patterns": ["/admin/**"]
  }
}

Antwort beinhaltet:

  • map_id, object, url, total_urls, urls, search_query, top_n

7. Webseiteninhalt abrufen (get_webpage_content)

Ruft Webseiteninhalte in sauberem Markdown-Format ab, mit Unterstützung für JavaScript-Rendering.

{
  "name": "get_webpage_content",
  "arguments": {
    "url_to_scrape": "https://example.com",
    "wait_before_scraping": 1000,
    "country": "US"
  }
}

Parameter:

  • url_to_scrape: Die URL der Webseite, die gescrapt werden soll (erforderlich)

  • wait_before_scraping: Zeit in Millisekunden, die vor dem Start des Scrapings gewartet werden soll (Standard: 0)

  • country: Wohnsitzland, von dem aus die Anfrage geladen werden soll (z. B. US, CA, GB) (optional)

Antwort:

{
  "content": [
    {
      "type": "text",
      "text": "# Example Website\n\nThis is the markdown content of the webpage..."
    }
  ]
}

8. Website-URLs abrufen (get_website_urls)

Suchen und rufen Sie relevante URLs von einer Website ab, sortiert nach Relevanz für Ihre Anfrage.

{
  "name": "get_website_urls",
  "arguments": {
    "url": "https://example.com",
    "search_query": "your search term"
  }
}

Parameter:

  • url: Die URL der Website, die gemappt werden soll (erforderlich)

  • search_query: Die Suchanfrage, nach der die URLs sortiert werden sollen (erforderlich)

Antwort:

{
  "content": [
    {
      "type": "text",
      "text": "Found 42 URLs matching your query:\n\nhttps://example.com/page1\nhttps://example.com/page2\n..."
    }
  ]
}

9. Batch-Ergebnisse abrufen (get_batch_results)

Ruft die Ergebnisse eines zuvor übermittelten Batch-Scraping-Jobs mithilfe seiner batch_id ab.

{
  "name": "get_batch_results",
  "arguments": {
    "batch_id": "batch_abc123"
  }
}

Parameter:

  • batch_id: Die von batch_scrape_urls zurückgegebene Batch-ID (erforderlich)

Antwort beinhaltet:

  • batch_id, status (processing oder completed), total_urls, completed_urls, items (Array von gescrapten Ergebnissen pro URL mit url, custom_id, markdown_content, html_content, json_content, text_content, status, page_metadata)

10. Crawl-Ergebnisse abrufen (get_crawl_results)

Ruft den Status und die gescrapten Seiten für einen asynchronen Crawl ab, der mit create_crawl gestartet wurde. Dies ist die erforderliche Ergänzung zu create_crawl — create_crawl startet nur den Job und gibt eine crawl_id zurück; dieses Tool ist der Weg, wie Sie die entdeckten Seiten und deren Inhalte tatsächlich abrufen.

{
  "name": "get_crawl_results",
  "arguments": {
    "crawl_id": "crawl_abc123",
    "formats": ["markdown"],
    "items_limit": 20,
    "cursor": 0
  }
}

Parameter:

  • crawl_id: Die von create_crawl zurückgegebene Crawl-ID (erforderlich)

  • formats: Array der Formate, die pro Seite abgerufen werden sollen — markdown, html, json, text (Standard: ["markdown"])

  • items_limit: Maximale Anzahl der Seiten, für die Inhalte abgerufen werden sollen, 1–100 (Standard: 20)

  • cursor: Paginierungs-Cursor für die Liste der entdeckten Seiten (Standard: 0)

  • search_query: Optionaler Filter, um Seiten nach Relevanz für eine Anfrage zu bewerten/auszuwählen

Antwort beinhaltet:

  • Während des Fortschritts: crawl_id, status (in_progress), pages_completed, pages_total und eine message, die Sie auffordert, in ca. 10 Sekunden erneut aufzurufen.

  • Nach Abschluss: crawl_id, status (completed), pages_returned, next_cursor, has_more und ein pages-Array, wobei jeder Eintrag url, custom_id und die angeforderten Inhaltsfelder (markdown_content, html_content, json_content, text_content) enthält.

Fehlerbehandlung

Der Server bietet eine robuste Fehlerbehandlung:

  • Detaillierte Fehlermeldungen bei API-Problemen

  • Meldung von Netzwerkfehlern

  • Behandlung von Authentifizierungsfehlern

  • Informationen zu Ratenbegrenzungen

Beispiel für eine Fehlerantwort:

{
  "isError": true,
  "content": [
    {
      "type": "text",
      "text": "Olostep API Error: 401 Unauthorized. Details: {\"error\":\"Invalid API key\"}"
    }
  ]
}

Distribution

Docker-Images

Der MCP-Server ist als Docker-Image verfügbar:

  • Docker Hub: [olostep/mcp-server](https://hub.docker.com/r/olostep/mcp-server)

  • Offizielles Docker MCP Registry: mcp/olostep (in Kürze verfügbar - erhöhte Sicherheit mit Signaturen & SBOMs)

  • GitHub Container Registry: ghcr.io/olostep/olostep-mcp-server

Docker Desktop MCP Toolkit

Der Olostep MCP Server wird dem offiziellen MCP Toolkit von Docker Desktop hinzugefügt, was bedeutet, dass Benutzer in der Lage sein werden:

  • Ihn in der MCP Toolkit-Benutzeroberfläche von Docker Desktop zu entdecken

  • Ihn mit einem Klick zu installieren

  • Ihn visuell zu konfigurieren

  • Ihn mit jedem MCP-kompatiblen Client (Claude Desktop, Cursor, etc.) zu verwenden

Status: Einreichung bei Docker MCP Registry läuft

Unterstützte Plattformen

  • linux/amd64

  • linux/arm64

Lokal bauen

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

# Build the image
npm install
npm run build
docker build -t olostep/mcp-server .

# Run locally
docker run -i --rm -e OLOSTEP_API_KEY="your-key" olostep/mcp-server

Lizenz

ISC-Lizenz

Available Tools

8 tools
answersAnswersA
Read-onlyIdempotent
Inspect

Use this when the user asks a factual question the live web can answer in a sentence or a few fields, such as a company's founding year, a CEO's name or a product's current price. Searches and reads the pages itself and returns the answer with its source URLs, optionally as a flat JSON object of the fields you list in json. For a list of items from one page (latest blog posts, a price table), call scrape_website on that page instead.

Inputs: task (required), json.

batch_scrape_urlsBatch Scrape URLsA
Read-only
Inspect

Use this when you have a known list of URLs to scrape, such as URLs from a CSV or from search results (up to 100k in one batch). Waits up to wait_for_completion_seconds (default 45) and returns the content if the batch finishes in that time. Larger batches usually take 5-8 min and return a batch_id: get their content with get_batch_results, a set at a time, passing next_cursor for the rest. For one or a few URLs, scrape_website is faster; to discover a site's pages, use create_crawl.

Inputs: urls, parser, country, output_format, +3 more.

create_crawlCreate CrawlA
Read-only
Inspect

Use this when you need the content of many pages from one website, such as a docs section or a blog: it follows links from a start URL and scrapes each page it finds, up to max_pages. Waits up to wait_for_completion_seconds (default 45) and returns the pages if the crawl finishes in that time; otherwise returns a crawl_id to pass to get_crawl_results (not get_batch_results). For a known list of URLs use batch_scrape_urls; for one page use scrape_website.

Inputs: url, parser, country, max_pages, +3 more.

create_mapCreate MapA
Read-onlyIdempotent
Inspect

Use this when you need the list of URLs on a website, not their content: to see a site's pages, find a section, or pick pages to scrape. Can rank URLs by search_query and filter them with glob patterns. Returns URLs only. To get the content of many pages from the site, use create_crawl.

Inputs: url, top_n, website_url, search_query, +2 more.

get_batch_resultsGet Batch ResultsA
Read-onlyIdempotent
Inspect

Use this to get the content of a batch started with batch_scrape_urls, using its batch_id. While the batch is in_progress it returns the status: call again in about 10 seconds. Once completed it returns each URL's url, title and content, up to items_limit per call; when has_more is true, pass next_cursor for the rest. Do not start a new batch to check on one that is still running.

Inputs: batch_id (required), cursor, formats, items_limit, +1 more.

get_crawl_resultsGet Crawl ResultsA
Read-onlyIdempotent
Inspect

Use this to get the pages of a crawl started with create_crawl, using its crawl_id. While the crawl is in_progress it returns the status: call again in about 10 seconds. Once completed it returns each page's url, title and content, up to items_limit per call; when has_more is true, pass next_cursor for the rest. Do not start a new crawl to check on one that is still running.

Inputs: crawl_id (required), cursor, formats, items_limit, +2 more.

scrape_websiteScrape WebsiteA
Read-onlyIdempotent
Inspect

Use this when you have a URL and need what is on the page. Returns the page as clean markdown (default), html or text, with its url and title, after rendering JavaScript. For structured fields, set output_format to "json" with an llm_extract schema or a parser. Long pages are cut at max_characters (default 20,000) with a link to the full text. For many known URLs use batch_scrape_urls; for many pages of one site use create_crawl.

Inputs: url, parser, country, llm_extract, +4 more.

search_webSearch WebA
Read-onlyIdempotent
Inspect

Use this when you need web pages on a topic and do not have a URL yet. Returns up to limit results (1-25), each with its URL, title and description. Set scrape_results to true to also get each result page's content as markdown in the same call (each scraped page costs extra credits); otherwise pass the URLs you need to scrape_website, or to batch_scrape_urls for many. Use include_domains to search one site. For a direct factual answer with sources, use answers.

Inputs: query (required), limit, max_characters, scrape_results, +2 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.5/5.0

    Scored across 8 tools

    Disambiguation5/5

    Each tool has a clearly distinct role, and the descriptions explicitly disambiguate near-neighbors (create_map for URLs vs create_crawl for content, batch_scrape_urls vs scrape_website by cardinality, answers vs search_web by intent). The paired async polling tools are also explicitly separated ("pass to get_crawl_results (not get_batch_results)").

    Naming Consistency4/5

    Most names follow a verb_noun snake_case pattern (create_map, create_crawl, get_crawl_results, search_web, scrape_website). `answers` breaks the pattern as a bare noun/verb with no object, and `batch_scrape_urls` uses a modifier prefix not seen elsewhere, but overall the convention is readable and predictable.

    Tool Count5/5

    Eight tools is well within the sweet spot for a web-scraping/extraction server. Every tool earns its place: two discovery methods, two fetch modes, two async result retrievers, search, and direct Q&A, with no redundant entries.

    Completeness4/5

    The surface covers the full pipeline: discover (create_map, create_crawl, search_web), fetch (scrape_website, batch_scrape_urls), extract (answers), and retrieve async results with pagination. Minor gaps exist around job lifecycle management (listing or cancelling runs) and no explicit retry/status-check-by-id beyond the two result tools.

    Maintenance

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers