> ## Documentation Index
> Fetch the complete documentation index at: https://docs.olostep.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Olostep + Mastra Integration

> Erstelle KI-Agenten mit Websuche, Scraping und Crawling-Fähigkeiten mit dem Agenten-Framework von Mastra.ai

Die Olostep Mastra-Integration bringt leistungsstarke Webdatenextraktionsfähigkeiten zu Mastra.ai-Agenten. Olostep ist eine Websuche, Scraping und Crawling API — eine API zum Suchen, Extrahieren und Strukturieren von Webdaten. Baue intelligente KI-Agenten, die autonom Daten von jeder Website suchen, scrapen, analysieren und strukturieren können.

[Von npm installieren →](https://www.npmjs.com/package/@olostep/mastra-tools)

## Funktionen

Die Integration bietet 4 leistungsstarke APIs für die automatisierte Webdatenextraktion:

<CardGroup cols={2}>
  <Card title="Website scrapen" icon="file-lines">
    Extrahiere Inhalte von jeder einzelnen URL in mehreren Formaten (Markdown, HTML, JSON, Text)
  </Card>

  <Card title="URLs im Batch scrapen" icon="layer-group">
    Verarbeite bis zu 100.000 URLs parallel. Perfekt für die Extraktion von großen Datenmengen
  </Card>

  <Card title="Crawl erstellen" icon="spider-web">
    Entdecke und scrape ganze Websites autonom, indem du Links folgst
  </Card>

  <Card title="Karte erstellen" icon="map">
    Extrahiere alle URLs von einer Website für die Analyse der Seitenstruktur und Inhaltsentdeckung
  </Card>
</CardGroup>

## Installation

<CodeGroup>
  ```bash npm theme={null}
  npm install @olostep/mastra-tools
  ```

  ```bash yarn theme={null}
  yarn add @olostep/mastra-tools
  ```

  ```bash pnpm theme={null}
  pnpm add @olostep/mastra-tools
  ```
</CodeGroup>

## Einrichtung

### 1. Paket installieren

```bash theme={null}
npm install @olostep/mastra-tools @mastra/core
```

### 2. Integration importieren und registrieren

In deiner Mastra-Konfigurationsdatei:

```typescript theme={null}
import { Mastra } from '@mastra/core';
import { createOlostepIntegration } from '@olostep/mastra-tools';

// Erstelle die Olostep-Integration
const olostep = createOlostepIntegration();

// APIs registrieren (macht sie für Agenten verfügbar)
olostep.registerApis();

// Zur Mastra-Konfiguration hinzufügen
export const mastra = new Mastra({
  config: {
    integrations: [olostep],
    // ... andere Konfiguration
  },
});
```

### 3. API-Schlüssel konfigurieren

Setze deinen Olostep-API-Schlüssel als Umgebungsvariable:

```bash theme={null}
export OLOSTEP_API_KEY=dein-api-schlüssel-hier
```

Oder in deiner `.env` Datei:

```
OLOSTEP_API_KEY=dein-api-schlüssel-hier
```

Hole deinen API-Schlüssel vom [Olostep Dashboard](https://olostep.com/dashboard).

## Verfügbare APIs

Die Integration stellt 4 APIs zur Verfügung, die deine Mastra-Agenten nutzen können:

### scrapeWebsite

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

**Anwendungsfälle:**

* Überwache spezifische Seiten auf Änderungen
* Extrahiere Produktinformationen von E-Commerce-Seiten
* Sammle Daten aus Nachrichtenartikeln oder Blogbeiträgen
* Ziehe Inhalte für Content-Aggregation

**Schema-Parameter:**

<ParamField path="apiKey" type="string" required>
  Dein Olostep-API-Schlüssel
</ParamField>

<ParamField path="url_to_scrape" type="string" required>
  Website-URL zum Scrapen (muss http\:// oder https\:// enthalten)
</ParamField>

<ParamField path="formats" type="array" default="['markdown']">
  Ausgabeformate: \['html', 'markdown', 'json', 'text']
</ParamField>

<ParamField path="country" type="string">
  Ländercode für ortsspezifische Inhalte (z.B. "US", "GB", "CA")
</ParamField>

<ParamField path="wait_before_scraping" type="number">
  Wartezeit in Millisekunden für JavaScript-Rendering (0-10000)
</ParamField>

<ParamField path="parser" type="string">
  Optionaler Parser-ID für spezialisierte Extraktion (z.B. "@olostep/amazon-product")
</ParamField>

**Antwort:**

* `id` - Scrape-ID
* `url_to_scrape` - Gescrapte URL
* `result.markdown_content` - Markdown-Inhalt
* `result.html_content` - HTML-Inhalt
* `result.json_content` - JSON-Inhalt
* `result.text_content` - Textinhalt
* `result.screenshot_hosted_url` - Screenshot-URL (falls verfügbar)
* `result.markdown_hosted_url` - Gehostete Markdown-URL
* `object` - Objekttyp ("scrape")
* `created` - Unix-Zeitstempel

**Beispielverwendung:**

```typescript theme={null}
// In deinem Agenten oder Workflow
const result = await mastra.callApi({
  integrationName: 'olostep',
  api: 'scrapeWebsite',
  payload: {
    data: {
      apiKey: process.env.OLOSTEP_API_KEY,
      url_to_scrape: 'https://example.com',
      formats: ['markdown'],
      country: 'US',
    }
  }
});
```

### batchScrape

Verarbeite mehrere URLs parallel (bis zu 100.000 auf einmal). Perfekt für die Extraktion von großen Datenmengen.

**Anwendungsfälle:**

* Scrape ganze Produktkataloge
* Extrahiere Daten aus mehreren Suchergebnissen
* Verarbeite Listen von URLs aus Tabellen
* Masseninhalts-Extraktion

**Schema-Parameter:**

<ParamField path="apiKey" type="string" required>
  Dein Olostep-API-Schlüssel
</ParamField>

<ParamField path="batch_array" type="array" required>
  Array von Objekten mit `url` und optionalen `custom_id` Feldern

  Beispiel: `[{"url":"https://example.com","custom_id":"site1"}]`
</ParamField>

<ParamField path="formats" type="array" default="['markdown']">
  Ausgabeformate für alle URLs
</ParamField>

<ParamField path="country" type="string">
  Ländercode für ortsspezifisches Scraping
</ParamField>

<ParamField path="wait_before_scraping" type="number">
  Wartezeit in Millisekunden für JavaScript-Rendering
</ParamField>

<ParamField path="parser" type="string">
  Optionaler Parser-ID für spezialisierte Extraktion
</ParamField>

**Antwort:**

* `batch_id` - Batch-ID (verwende dies, um Ergebnisse später abzurufen)
* `status` - Verarbeitungsstatus
* `object` - Objekttyp ("batch")

**Beispielverwendung:**

```typescript theme={null}
const result = await mastra.callApi({
  integrationName: 'olostep',
  api: 'batchScrape',
  payload: {
    data: {
      apiKey: process.env.OLOSTEP_API_KEY,
      batch_array: [
        { url: 'https://example.com', custom_id: 'site1' },
        { url: 'https://test.com', custom_id: 'site2' },
      ],
      formats: ['markdown'],
    }
  }
});
```

### createCrawl

Entdecke und scrape ganze Websites autonom, indem du Links folgst. Perfekt für Dokumentationsseiten, Blogs und Inhaltsrepositorien.

**Anwendungsfälle:**

* Crawle und archiviere ganze Dokumentationsseiten
* Extrahiere alle Blogbeiträge von einer Website
* Baue Wissensdatenbanken aus Webinhalten
* Überwache Änderungen in der Website-Struktur

**Schema-Parameter:**

<ParamField path="apiKey" type="string" required>
  Dein Olostep-API-Schlüssel
</ParamField>

<ParamField path="start_url" type="string" required>
  Start-URL für das Crawlen (muss http\:// oder https\:// enthalten)
</ParamField>

<ParamField path="max_pages" type="number" default="10">
  Maximale Anzahl von Seiten, die gecrawlt werden sollen. Setze auf `1`, um nur die Start-URL zu scrapen.
</ParamField>

<ParamField path="formats" type="array" default="['markdown']">
  Format für gescrapte Inhalte
</ParamField>

<ParamField path="country" type="string">
  Optionaler Ländercode für ortsspezifisches Crawlen
</ParamField>

<ParamField path="parser" type="string">
  Optionaler Parser-ID für spezialisierte Inhaltsextraktion
</ParamField>

**Antwort:**

* `id` - Crawl-ID (verwende dies, um Ergebnisse später abzurufen)
* `object` - Objekttyp ("crawl")
* `status` - Crawl-Status
* `created` - Unix-Zeitstempel

**Beispielverwendung:**

```typescript theme={null}
const result = await mastra.callApi({
  integrationName: 'olostep',
  api: 'createCrawl',
  payload: {
    data: {
      apiKey: process.env.OLOSTEP_API_KEY,
      start_url: 'https://docs.example.com',
      max_pages: 50,
      formats: ['markdown'],
    }
  }
});
```

### createMap

Extrahiere alle URLs von einer Website für Inhaltsentdeckung und Seitenstrukturanalyse.

**Anwendungsfälle:**

* Baue Sitemaps und Diagramme der Seitenstruktur
* Entdecke alle Seiten vor dem Batch-Scraping
* Finde kaputte oder fehlende Seiten
* SEO-Audits und Analysen

**Schema-Parameter:**

<ParamField path="apiKey" type="string" required>
  Dein Olostep-API-Schlüssel
</ParamField>

<ParamField path="url" type="string" required>
  Website-URL, von der Links extrahiert werden sollen (muss http\:// oder https\:// enthalten)
</ParamField>

<ParamField path="search_query" type="string">
  Optionale Suchanfrage, um URLs zu filtern (z.B. "blog")
</ParamField>

<ParamField path="top_n" type="number">
  Begrenze die Anzahl der zurückgegebenen URLs
</ParamField>

<ParamField path="include_urls" type="array">
  Glob-Muster, um spezifische Pfade einzuschließen (z.B. \["/blog/\*\*"])
</ParamField>

<ParamField path="exclude_urls" type="array">
  Glob-Muster, um spezifische Pfade auszuschließen (z.B. \["/admin/\*\*"])
</ParamField>

**Antwort:**

* `id` - Map-ID
* `object` - Objekttyp ("map")
* `url` - Website-URL
* `total_urls` - Gesamtzahl der gefundenen URLs
* `urls` - Array der entdeckten URLs

**Beispielverwendung:**

```typescript theme={null}
const result = await mastra.callApi({
  integrationName: 'olostep',
  api: 'createMap',
  payload: {
    data: {
      apiKey: process.env.OLOSTEP_API_KEY,
      url: 'https://example.com',
      search_query: 'blog',
      top_n: 100,
      include_urls: ['/blog/**'],
    }
  }
});
```

## Verwendung mit Agenten

### Einfaches Agentenbeispiel

Erstelle einen Agenten, der Websites scrapen kann:

```typescript theme={null}
import { Agent } from '@mastra/core';
import { createOlostepIntegration } from '@olostep/mastra-tools';

const olostep = createOlostepIntegration();
olostep.registerApis();

const agent = new Agent({
  name: 'web-researcher',
  instructions: `
    Du bist ein Web-Recherche-Assistent. Wenn Benutzer dich bitten, Informationen von einer Website zu holen,
    verwende die Olostep scrapeWebsite API, um den Inhalt zu extrahieren, und fasse ihn dann für sie zusammen.
  `,
  model: 'openai/gpt-4',
});

// Der Agent kann nun Olostep-APIs über Mastras API-System verwenden
```

### Agenten-Workflow-Beispiel

Erstelle einen Recherche-Workflow, der Inhalte entdeckt und scrapt:

```typescript theme={null}
// 1. Mappe eine Website, um URLs zu entdecken
const mapResult = await mastra.callApi({
  integrationName: 'olostep',
  api: 'createMap',
  payload: {
    data: {
      apiKey: process.env.OLOSTEP_API_KEY,
      url: 'https://example.com',
      include_urls: ['/blog/**'],
    }
  }
});

// 2. Batch scrape entdeckte URLs
const batchResult = await mastra.callApi({
  integrationName: 'olostep',
  api: 'batchScrape',
  payload: {
    data: {
      apiKey: process.env.OLOSTEP_API_KEY,
      batch_array: mapResult.urls.slice(0, 10).map(url => ({ url })),
      formats: ['markdown'],
    }
  }
});

// 3. Verarbeite Ergebnisse mit deinem Agenten
const summary = await agent.generate({
  messages: [{
    role: 'user',
    content: `Fasse diesen Inhalt zusammen: ${batchResult.result.markdown_content}`
  }]
});
```

## Beliebte Anwendungsfälle

### Recherche-Agent

Erstelle einen Agenten, der autonom Themen recherchiert:

<AccordionGroup>
  <Accordion title="Multi-Source Research">
    **Workflow:**

    1. Benutzer fragt: "Recherchiere KI-Trends"
    2. Agent verwendet `createMap`, um relevante Seiten zu entdecken
    3. Agent verwendet `batchScrape`, um Inhalte zu extrahieren
    4. Agent analysiert und fasst die Ergebnisse zusammen
    5. Gibt strukturierten Forschungsbericht zurück
  </Accordion>

  <Accordion title="Wettbewerbsüberwachung">
    **Workflow:**

    1. Tägliche Überwachung planen
    2. Verwende `scrapeWebsite`, um Wettbewerberseiten zu überprüfen
    3. Vergleiche mit vorherigen Daten
    4. Benachrichtige bei signifikanten Änderungen
    5. Generiere wöchentliche Berichte
  </Accordion>

  <Accordion title="Content Aggregation">
    **Workflow:**

    1. Verwende `createCrawl`, um alle Blogbeiträge zu entdecken
    2. Verwende `batchScrape`, um Inhalte zu extrahieren
    3. Verarbeite mit KI, um wichtige Themen zu extrahieren
    4. Speichere in Wissensdatenbank
    5. Generiere Content-Kalender
  </Accordion>
</AccordionGroup>

### E-Commerce-Intelligenz

Überwache Produkte und Preise:

```
Agenten-Workflow:
1. Produktseiten scrapen (scrapeWebsite)
2. Strukturierte Daten extrahieren (mit Parser)
3. Preisänderungen verfolgen
4. Benachrichtigungen generieren
5. Datenbank aktualisieren
```

### SEO-Analyse

Analysiere Website-Struktur und Inhalte:

```
Agenten-Workflow:
1. Website-Struktur mappen (createMap)
2. Wichtige Abschnitte crawlen (createCrawl)
3. Inhaltsqualität analysieren
4. SEO-Möglichkeiten identifizieren
5. Empfehlungen generieren
```

## Spezialisierte Parser

Olostep bietet vorgefertigte Parser für beliebte Websites. Verwende sie mit dem `parser` Parameter:

<CardGroup cols={2}>
  <Card title="Google Search" icon="google">
    `@olostep/google-search`

    Extrahiere: Suchergebnisse, Titel, Snippets, URLs
  </Card>

  <Card title="Google Maps" icon="map">
    `@olostep/google-maps`

    Extrahiere: Geschäftsinformationen, Bewertungen, Bewertungen, Standort
  </Card>
</CardGroup>

### Verwendung von Parsern

Füge die Parser-ID zum `parser` Parameter hinzu:

```typescript theme={null}
const result = await mastra.callApi({
  integrationName: 'olostep',
  api: 'scrapeWebsite',
  payload: {
    data: {
      apiKey: process.env.OLOSTEP_API_KEY,
      url_to_scrape: 'https://www.amazon.com/dp/PRODUCT_ID',
      formats: ['json'],
      parser: '@olostep/amazon-product',
    }
  }
});
```

Der Parser extrahiert automatisch strukturierte Daten, die spezifisch für diesen Website-Typ sind.

## Best Practices

<AccordionGroup>
  <Accordion title="Verwende Batch-Verarbeitung für mehrere URLs">
    Wenn du mehr als 3-5 URLs scrapen möchtest, verwende `batchScrape` anstelle von mehreren `scrapeWebsite`-Aufrufen. Batch-Verarbeitung ist:

    * Viel schneller (parallele Verarbeitung)
    * Kostengünstiger
    * Einfacher zu verwalten
    * Besser für Ratenlimits
  </Accordion>

  <Accordion title="Setze angemessene Wartezeiten">
    Für JavaScript-lastige Seiten verwende den `wait_before_scraping` Parameter:

    * Einfache Seiten: 0-1000ms
    * Dynamische Seiten: 2000-3000ms
    * Schweres JavaScript: 5000-8000ms

    Teste mit verschiedenen Werten, um die optimale Wartezeit zu finden.
  </Accordion>

  <Accordion title="Verwende spezialisierte Parser">
    Für beliebte Websites (Amazon, LinkedIn, Google) verwende vorgefertigte Parser:

    * Erhalte automatisch strukturierte Daten
    * Zuverlässigere Extraktion
    * Keine Notwendigkeit für benutzerdefiniertes Parsing
    * Von Olostep gewartet
  </Accordion>

  <Accordion title="Asynchrone Operationen handhaben">
    Batch-, Crawl- und Map-Operationen sind asynchron:

    * Speichere die zurückgegebene ID (batch\_id, crawl\_id, map\_id)
    * Poll für Abschluss oder verwende Webhooks
    * Richte separate Workflows für den Abruf ein
  </Accordion>

  <Accordion title="Fehlerbehandlung">
    Umfasse API-Aufrufe immer mit try-catch-Blöcken:

    ```typescript theme={null}
    try {
      const result = await mastra.callApi({
        integrationName: 'olostep',
        api: 'scrapeWebsite',
        payload: { data: {...} }
      });
    } catch (error) {
      // Authentifizierungs-, Ratenlimit- oder Netzwerkfehler behandeln
      console.error('Scraping fehlgeschlagen:', error.message);
    }
    ```
  </Accordion>

  <Accordion title="Ratenbegrenzung">
    Achte auf Ratenlimits:

    * Verteile Anfragen mit Verzögerungen
    * Verwende Batch-Verarbeitung, wenn möglich
    * Überwache Nutzung im Olostep-Dashboard
    * Upgrade-Plan bei Bedarf
  </Accordion>
</AccordionGroup>

## Komplettes Beispiel

Hier ist ein komplettes Beispiel für den Aufbau eines Recherche-Agenten:

```typescript theme={null}
import { Mastra } from '@mastra/core';
import { Agent } from '@mastra/core';
import { createOlostepIntegration } from '@olostep/mastra-tools';

// Erstelle und registriere Olostep-Integration
const olostep = createOlostepIntegration();
olostep.registerApis();

// Mastra initialisieren
export const mastra = new Mastra({
  config: {
    integrations: [olostep],
    // ... andere Konfiguration
  },
});

// Forschungsagenten erstellen
const researchAgent = new Agent({
  name: 'research-assistant',
  instructions: `
    Du bist ein Forschungsassistent, der Webdaten suchen, extrahieren und strukturieren kann.
    Wenn Benutzer dich bitten, ein Thema zu recherchieren:
    1. Verwende Olosteps createMap, um relevante Seiten zu entdecken
    2. Verwende batchScrape, um Inhalte aus mehreren Quellen zu extrahieren
    3. Analysiere und fasse die Ergebnisse zusammen
    4. Präsentiere strukturierte Forschungsberichte
  `,
  model: 'openai/gpt-4',
});

// Verwende den Agenten
async function researchTopic(topic: string) {
  // Schritt 1: Relevante Seiten entdecken
  const mapResult = await mastra.callApi({
    integrationName: 'olostep',
    api: 'createMap',
    payload: {
      data: {
        apiKey: process.env.OLOSTEP_API_KEY!,
        url: `https://example.com/search?q=${topic}`,
        top_n: 20,
      }
    }
  });

  // Schritt 2: Entdeckte Seiten scrapen
  const batchResult = await mastra.callApi({
    integrationName: 'olostep',
    api: 'batchScrape',
    payload: {
      data: {
        apiKey: process.env.OLOSTEP_API_KEY!,
        batch_array: mapResult.urls.slice(0, 10).map(url => ({ url })),
        formats: ['markdown'],
      }
    }
  });

  // Schritt 3: Mit Agenten analysieren
  const summary = await researchAgent.generate({
    messages: [{
      role: 'user',
      content: `Basierend auf diesen Forschungsdaten, erstelle eine umfassende Zusammenfassung von ${topic}`
    }]
  });

  return summary;
}
```

## Fehlerbehebung

<AccordionGroup>
  <Accordion title="Authentifizierung fehlgeschlagen">
    **Fehler**: "Ungültiger API-Schlüssel"

    **Lösungen**:

    * Überprüfe den API-Schlüssel vom [Dashboard](https://olostep.com/dashboard)
    * Stelle sicher, dass der API-Schlüssel als Umgebungsvariable gesetzt ist
    * Verifiziere, dass der API-Schlüssel aktiv ist
    * Überprüfe auf zusätzliche Leerzeichen im API-Schlüssel
  </Accordion>

  <Accordion title="API nicht gefunden">
    **Fehler**: "API nicht gefunden" oder "Integration nicht registriert"

    **Lösungen**:

    * Stelle sicher, dass `registerApis()` nach der Erstellung der Integration aufgerufen wird
    * Verifiziere, dass die Integration zur Mastra-Konfiguration hinzugefügt wurde
    * Überprüfe, dass der Integrationsname 'olostep' ist
    * Starte den Mastra-Server nach Änderungen neu
  </Accordion>

  <Accordion title="Scrape gibt leere Inhalte zurück">
    **Fehler**: Inhaltsfelder sind leer

    **Lösungen**:

    * Erhöhe die `wait_before_scraping`-Zeit
    * Überprüfe, ob die Website eine Anmeldung erfordert
    * Versuche ein anderes Format (HTML vs Markdown)
    * Verifiziere, dass die URL zugänglich ist
    * Überprüfe, ob die Seite automatisierten Zugriff blockiert
  </Accordion>

  <Accordion title="Ratenlimit überschritten">
    **Fehler**: "Ratenlimit überschritten"

    **Lösungen**:

    * Verteile Anfragen mit Verzögerungen
    * Verwende Batch-Verarbeitung anstelle von individuellen Scrapes
    * Upgrade deinen Olostep-Plan
    * Überprüfe das Ratenlimit im Dashboard
  </Accordion>

  <Accordion title="TypeScript-Fehler">
    **Fehler**: Modul nicht gefunden oder Typfehler

    **Lösungen**:

    * Stelle sicher, dass `@mastra/core` installiert ist
    * Überprüfe die TypeScript-Version-Kompatibilität
    * Verifiziere, dass alle Abhängigkeiten installiert sind
    * Neu bauen: `npm run build`
  </Accordion>
</AccordionGroup>

## Preisgestaltung

Olostep berechnet basierend auf der API-Nutzung, unabhängig von Mastra:

* **Scrapes**: Bezahlung pro Scrape
* **Batches**: Bezahlung pro URL im Batch
* **Crawls**: Bezahlung pro gecrawlte Seite
* **Maps**: Bezahlung pro Map-Operation

Überprüfe die aktuellen Preise auf [olostep.com/pricing](https://www.olostep.com/pricing).

## Support

Benötigst du Hilfe bei der Mastra-Integration?

<CardGroup cols={2}>
  <Card title="Dokumentation" icon="book" href="https://docs.olostep.com">
    Durchsuche die vollständige API-Dokumentation
  </Card>

  <Card title="Support-E-Mail" icon="envelope" href="mailto:info@olostep.com">
    E-Mail: [info@olostep.com](mailto:info@olostep.com)
  </Card>

  <Card title="Mastra-Dokumentation" icon="robot" href="https://mastra.ai/docs">
    Erfahre mehr über das Mastra-Framework
  </Card>
</CardGroup>

## Verwandte Ressourcen

<CardGroup cols={2}>
  <Card title="Scrapes API" icon="file-lines" href="/features/scrapes">
    Erfahre mehr über den Scrapes-Endpunkt
  </Card>

  <Card title="Batches API" icon="layer-group" href="/features/batches">
    Erfahre mehr über den Batches-Endpunkt
  </Card>

  <Card title="Crawls API" icon="spider-web" href="/features/crawls">
    Erfahre mehr über den Crawls-Endpunkt
  </Card>

  <Card title="Maps API" icon="map" href="/features/maps">
    Erfahre mehr über den Maps-Endpunkt
  </Card>

  <Card title="Zapier-Integration" icon="bolt" href="/integrations/zapier">
    Automatisiere mit Zapier-Workflows
  </Card>

  <Card title="LangChain-Integration" icon="link" href="/integrations/langchain">
    Baue KI-Agenten mit LangChain
  </Card>

  <Card title="Mastra-Website" icon="link" href="https://mastra.ai">
    Mastra-Plattform
  </Card>
</CardGroup>

## Erste Schritte

Bereit, KI-Agenten mit Web-Scraping-Fähigkeiten zu erstellen?

<Card title="Paket installieren" icon="download" href="https://www.npmjs.com/package/@olostep/mastra-tools">
  Installiere @olostep/mastra-tools von npm
</Card>

Baue intelligente KI-Agenten, die mit Olostep und Mastra Webdaten suchen, extrahieren und strukturieren können!