mirror of
https://github.com/simstudioai/sim.git
synced 2026-04-28 03:00:29 -04:00
feat(i18n): update translations (#1437)
This commit is contained in:
Waleed
306
apps/docs/content/docs/de/blocks/agent.mdx
Normal file
306
apps/docs/content/docs/de/blocks/agent.mdx
Normal file
@@ -0,0 +1,306 @@
|
||||
---
|
||||
title: Agent
|
||||
---
|
||||
|
||||
import { Callout } from 'fumadocs-ui/components/callout'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Image } from '@/components/ui/image'
|
||||
import { Video } from '@/components/ui/video'
|
||||
|
||||
Der Agent-Block dient als Schnittstelle zwischen Ihrem Workflow und Large Language Models (LLMs). Er führt Inferenzanfragen an verschiedene KI-Anbieter aus, verarbeitet natürlichsprachliche Eingaben gemäß definierten Anweisungen und erzeugt strukturierte oder unstrukturierte Ausgaben für die nachgelagerte Verarbeitung.
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/agent.png"
|
||||
alt="Agent-Block-Konfiguration"
|
||||
width={500}
|
||||
height={400}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
## Überblick
|
||||
|
||||
Der Agent-Block ermöglicht Ihnen:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Natürliche Sprache verarbeiten</strong>: Benutzereingaben analysieren und kontextbezogene Antworten generieren
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>KI-gestützte Aufgaben ausführen</strong>: Inhaltsanalyse, -erstellung und Entscheidungsfindung durchführen
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Externe Tools aufrufen</strong>: Während der Verarbeitung auf APIs, Datenbanken und Dienste zugreifen
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Strukturierte Ausgabe erzeugen</strong>: JSON-Daten zurückgeben, die Ihren Schema-Anforderungen entsprechen
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Konfigurationsoptionen
|
||||
|
||||
### System-Prompt
|
||||
|
||||
Der System-Prompt legt die Betriebsparameter und Verhaltenseinschränkungen des Agenten fest. Diese Konfiguration definiert die Rolle des Agenten, die Antwortmethodik und die Verarbeitungsgrenzen für alle eingehenden Anfragen.
|
||||
|
||||
```markdown
|
||||
You are a helpful assistant that specializes in financial analysis.
|
||||
Always provide clear explanations and cite sources when possible.
|
||||
When responding to questions about investments, include risk disclaimers.
|
||||
```
|
||||
|
||||
### Benutzer-Prompt
|
||||
|
||||
Der Benutzer-Prompt stellt die primären Eingabedaten für die Inferenzverarbeitung dar. Dieser Parameter akzeptiert natürlichsprachlichen Text oder strukturierte Daten, die der Agent analysieren und auf die er reagieren wird. Zu den Eingabequellen gehören:
|
||||
|
||||
- **Statische Konfiguration**: Direkte Texteingabe, die in der Block-Konfiguration angegeben ist
|
||||
- **Dynamische Eingabe**: Daten, die von vorgelagerten Blöcken über Verbindungsschnittstellen übergeben werden
|
||||
- **Laufzeitgenerierung**: Programmatisch erzeugte Inhalte während der Workflow-Ausführung
|
||||
|
||||
### Modellauswahl
|
||||
|
||||
Der Agent-Block unterstützt mehrere LLM-Anbieter über eine einheitliche Inferenzschnittstelle. Verfügbare Modelle umfassen:
|
||||
|
||||
**OpenAI-Modelle**: GPT-5, GPT-4o, o1, o3, o4-mini, gpt-4.1 (API-basierte Inferenz)
|
||||
**Anthropic-Modelle**: Claude 3.7 Sonnet (API-basierte Inferenz)
|
||||
**Google-Modelle**: Gemini 2.5 Pro, Gemini 2.0 Flash (API-basierte Inferenz)
|
||||
**Alternative Anbieter**: Groq, Cerebras, xAI, DeepSeek (API-basierte Inferenz)
|
||||
**Lokale Bereitstellung**: Ollama-kompatible Modelle (selbst gehostete Inferenz)
|
||||
|
||||
<div className="mx-auto w-3/5 overflow-hidden rounded-lg">
|
||||
<Video src="models.mp4" width={500} height={350} />
|
||||
</div>
|
||||
|
||||
### Temperatur
|
||||
|
||||
Steuern Sie die Kreativität und Zufälligkeit der Antworten:
|
||||
|
||||
<Tabs items={['Niedrig (0-0,3)', 'Mittel (0,3-0,7)', 'Hoch (0,7-2,0)']}>
|
||||
<Tab>
|
||||
Deterministische, fokussierte Antworten. Am besten für faktische Aufgaben, Kundensupport und
|
||||
Situationen, in denen Genauigkeit entscheidend ist.
|
||||
</Tab>
|
||||
<Tab>
|
||||
Ausgewogene Kreativität und Fokus. Geeignet für allgemeine Anwendungen, die sowohl
|
||||
Genauigkeit als auch etwas Kreativität erfordern.
|
||||
</Tab>
|
||||
<Tab>
|
||||
Kreativere, abwechslungsreichere Antworten. Ideal für kreatives Schreiben, Brainstorming und das Generieren
|
||||
vielfältiger Ideen.
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
<div className="mt-4 text-sm text-gray-600 dark:text-gray-400">
|
||||
Der Temperaturbereich (0-1 oder 0-2) variiert je nach ausgewähltem Modell.
|
||||
</div>
|
||||
|
||||
### API-Schlüssel
|
||||
|
||||
Ihr API-Schlüssel für den ausgewählten LLM-Anbieter. Dieser wird sicher gespeichert und für die Authentifizierung verwendet.
|
||||
|
||||
### Tools
|
||||
|
||||
Tools erweitern die Fähigkeiten des Agenten durch externe API-Integrationen und Service-Verbindungen. Das Tool-System ermöglicht Funktionsaufrufe, sodass der Agent Operationen über die Texterstellung hinaus ausführen kann.
|
||||
|
||||
**Tool-Integrationsprozess**:
|
||||
1. Zugriff auf den Tools-Konfigurationsbereich innerhalb des Agent-Blocks
|
||||
2. Auswahl aus über 60 vorgefertigten Integrationen oder Definition benutzerdefinierter Funktionen
|
||||
3. Konfiguration von Authentifizierungsparametern und Betriebseinschränkungen
|
||||
|
||||
<div className="mx-auto w-3/5 overflow-hidden rounded-lg">
|
||||
<Video src="tools.mp4" width={500} height={350} />
|
||||
</div>
|
||||
|
||||
**Verfügbare Tool-Kategorien**:
|
||||
- **Kommunikation**: Gmail, Slack, Telegram, WhatsApp, Microsoft Teams
|
||||
- **Datenquellen**: Notion, Google Sheets, Airtable, Supabase, Pinecone
|
||||
- **Webdienste**: Firecrawl, Google Search, Exa AI, Browser-Automatisierung
|
||||
- **Entwicklung**: GitHub, Jira, Linear Repository- und Issue-Management
|
||||
- **KI-Dienste**: OpenAI, Perplexity, Hugging Face, ElevenLabs
|
||||
|
||||
**Steuerung der Tool-Ausführung**:
|
||||
- **Auto**: Modell bestimmt Tool-Aufruf basierend auf Kontext und Notwendigkeit
|
||||
- **Required**: Tool muss bei jeder Inferenzanfrage aufgerufen werden
|
||||
- **None**: Tool-Definition verfügbar, aber vom Modellkontext ausgeschlossen
|
||||
|
||||
<div className="mx-auto w-3/5 overflow-hidden rounded-lg">
|
||||
<Video src="granular-tool-control.mp4" width={500} height={350} />
|
||||
</div>
|
||||
|
||||
### Antwortformat
|
||||
|
||||
Der Parameter für das Antwortformat erzwingt eine strukturierte Ausgabegenerierung durch JSON-Schema-Validierung. Dies gewährleistet konsistente, maschinenlesbare Antworten, die vordefinierten Datenstrukturen entsprechen:
|
||||
|
||||
```json
|
||||
{
|
||||
"name": "user_analysis",
|
||||
"schema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"sentiment": {
|
||||
"type": "string",
|
||||
"enum": ["positive", "negative", "neutral"]
|
||||
},
|
||||
"confidence": {
|
||||
"type": "number",
|
||||
"minimum": 0,
|
||||
"maximum": 1
|
||||
}
|
||||
},
|
||||
"required": ["sentiment", "confidence"]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Diese Konfiguration beschränkt die Ausgabe des Modells auf die Einhaltung des angegebenen Schemas, verhindert Freitext-Antworten und stellt eine strukturierte Datengenerierung sicher.
|
||||
|
||||
### Zugriff auf Ergebnisse
|
||||
|
||||
Nach Abschluss eines Agenten können Sie auf seine Ausgaben zugreifen:
|
||||
|
||||
- **`<agent.content>`**: Der Antworttext oder die strukturierten Daten des Agenten
|
||||
- **`<agent.tokens>`**: Token-Nutzungsstatistiken (Prompt, Completion, Gesamt)
|
||||
- **`<agent.tool_calls>`**: Details zu allen Tools, die der Agent während der Ausführung verwendet hat
|
||||
- **`<agent.cost>`**: Geschätzte Kosten des API-Aufrufs (falls verfügbar)
|
||||
|
||||
## Erweiterte Funktionen
|
||||
|
||||
### Memory + Agent: Gesprächsverlauf
|
||||
|
||||
Verwenden Sie einen `Memory`Block mit einer konsistenten `id` (zum Beispiel `chat`), um Nachrichten zwischen Durchläufen zu speichern und diesen Verlauf in den Prompt des Agenten einzubeziehen.
|
||||
|
||||
- Fügen Sie die Nachricht des Benutzers vor dem Agenten hinzu
|
||||
- Lesen Sie den Gesprächsverlauf für den Kontext
|
||||
- Hängen Sie die Antwort des Agenten nach dessen Ausführung an
|
||||
|
||||
```yaml
|
||||
# 1) Add latest user message
|
||||
- Memory (operation: add)
|
||||
id: chat
|
||||
role: user
|
||||
content: {{input}}
|
||||
|
||||
# 2) Load conversation history
|
||||
- Memory (operation: get)
|
||||
id: chat
|
||||
|
||||
# 3) Run the agent with prior messages available
|
||||
- Agent
|
||||
System Prompt: ...
|
||||
User Prompt: |
|
||||
Use the conversation so far:
|
||||
{{memory_get.memories}}
|
||||
Current user message: {{input}}
|
||||
|
||||
# 4) Store the agent reply
|
||||
- Memory (operation: add)
|
||||
id: chat
|
||||
role: assistant
|
||||
content: {{agent.content}}
|
||||
```
|
||||
|
||||
Siehe die `Memory`Block-Referenz für Details: [/tools/memory](/tools/memory).
|
||||
|
||||
## Eingaben und Ausgaben
|
||||
|
||||
<Tabs items={['Configuration', 'Variables', 'Results']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>System Prompt</strong>: Anweisungen, die das Verhalten und die Rolle des Agenten definieren
|
||||
</li>
|
||||
<li>
|
||||
<strong>User Prompt</strong>: Eingabetext oder -daten zur Verarbeitung
|
||||
</li>
|
||||
<li>
|
||||
<strong>Model</strong>: KI-Modellauswahl (OpenAI, Anthropic, Google, etc.)
|
||||
</li>
|
||||
<li>
|
||||
<strong>Temperature</strong>: Steuerung der Antwort-Zufälligkeit (0-2)
|
||||
</li>
|
||||
<li>
|
||||
<strong>Tools</strong>: Array verfügbarer Tools für Funktionsaufrufe
|
||||
</li>
|
||||
<li>
|
||||
<strong>Response Format</strong>: JSON-Schema für strukturierte Ausgabe
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>agent.content</strong>: Antworttext oder strukturierte Daten des Agenten
|
||||
</li>
|
||||
<li>
|
||||
<strong>agent.tokens</strong>: Token-Nutzungsstatistik-Objekt
|
||||
</li>
|
||||
<li>
|
||||
<strong>agent.tool_calls</strong>: Array mit Details zur Tool-Ausführung
|
||||
</li>
|
||||
<li>
|
||||
<strong>agent.cost</strong>: Geschätzte API-Aufrufkosten (falls verfügbar)
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Content</strong>: Primäre Antwortausgabe vom Agenten
|
||||
</li>
|
||||
<li>
|
||||
<strong>Metadata</strong>: Nutzungsstatistiken und Ausführungsdetails
|
||||
</li>
|
||||
<li>
|
||||
<strong>Access</strong>: Verfügbar in Blöcken nach dem Agenten
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Beispielanwendungsfälle
|
||||
|
||||
### Automatisierung des Kundendienstes
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Bearbeitung von Kundenanfragen mit Datenbankzugriff</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Benutzer reicht ein Support-Ticket über den API-Block ein</li>
|
||||
<li>Agent prüft Bestellungen/Abonnements in Postgres und durchsucht die Wissensdatenbank nach Anleitungen</li>
|
||||
<li>Falls eine Eskalation erforderlich ist, erstellt der Agent ein Linear-Ticket mit relevantem Kontext</li>
|
||||
<li>Agent verfasst eine klare E-Mail-Antwort</li>
|
||||
<li>Gmail sendet die Antwort an den Kunden</li>
|
||||
<li>Konversation wird im Speicher gesichert, um den Verlauf für zukünftige Nachrichten zu erhalten</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Multi-Modell-Inhaltsanalyse
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Analyse von Inhalten mit verschiedenen KI-Modellen</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Funktionsblock verarbeitet hochgeladenes Dokument</li>
|
||||
<li>Agent mit GPT-4o führt technische Analyse durch</li>
|
||||
<li>Agent mit Claude analysiert Stimmung und Tonfall</li>
|
||||
<li>Funktionsblock kombiniert Ergebnisse für den Abschlussbericht</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Werkzeuggestützter Rechercheassistent
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Rechercheassistent mit Websuche und Dokumentenzugriff</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Benutzeranfrage über Eingabe erhalten</li>
|
||||
<li>Agent durchsucht das Web mit dem Google Search-Tool</li>
|
||||
<li>Agent greift auf Notion-Datenbank für interne Dokumente zu</li>
|
||||
<li>Agent erstellt umfassenden Recherchebericht</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
## Best Practices
|
||||
|
||||
- **Sei spezifisch in System-Prompts**: Definiere die Rolle, den Tonfall und die Einschränkungen des Agenten klar. Je spezifischer deine Anweisungen sind, desto besser kann der Agent seinen vorgesehenen Zweck erfüllen.
|
||||
- **Wähle die richtige Temperatureinstellung**: Verwende niedrigere Temperatureinstellungen (0-0,3), wenn Genauigkeit wichtig ist, oder erhöhe die Temperatur (0,7-2,0) für kreativere oder abwechslungsreichere Antworten
|
||||
- **Nutze Tools effektiv**: Integriere Tools, die den Zweck des Agenten ergänzen und seine Fähigkeiten erweitern. Sei selektiv bei der Auswahl der Tools, um den Agenten nicht zu überfordern. Für Aufgaben mit wenig Überschneidung verwende einen anderen Agent-Block für die besten Ergebnisse.
|
||||
232
apps/docs/content/docs/de/blocks/api.mdx
Normal file
232
apps/docs/content/docs/de/blocks/api.mdx
Normal file
@@ -0,0 +1,232 @@
|
||||
---
|
||||
title: API
|
||||
---
|
||||
|
||||
import { Callout } from 'fumadocs-ui/components/callout'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Image } from '@/components/ui/image'
|
||||
|
||||
Der API-Block ermöglicht es Ihnen, Ihren Workflow über API-Endpunkte mit externen Diensten zu verbinden, indem HTTP-Anfragen verwendet werden. Er unterstützt verschiedene Methoden wie GET, POST, PUT, DELETE und PATCH, wodurch Sie mit praktisch jedem API-Endpunkt interagieren können.
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/api.png"
|
||||
alt="API-Block"
|
||||
width={500}
|
||||
height={400}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
## Überblick
|
||||
|
||||
Der API-Block ermöglicht Ihnen:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Verbindung zu externen Diensten</strong>: HTTP-Anfragen an REST-APIs und Webdienste stellen
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Daten senden und empfangen</strong>: Antworten verarbeiten und Daten aus externen Quellen transformieren
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Integration von Drittanbieter-Plattformen</strong>: Verbindung mit Diensten wie Stripe, Slack oder benutzerdefinierten APIs
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Authentifizierung verwalten</strong>: Unterstützung verschiedener Authentifizierungsmethoden einschließlich Bearer-Tokens und API-Schlüssel
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Funktionsweise
|
||||
|
||||
Der API-Block verarbeitet HTTP-Anfragen durch einen strukturierten Ansatz:
|
||||
|
||||
1. **Anfrage konfigurieren** - URL, Methode, Header und Body-Parameter festlegen
|
||||
2. **Anfrage ausführen** - HTTP-Anfrage an den angegebenen Endpunkt senden
|
||||
3. **Antwort verarbeiten** - Antwortdaten, Statuscodes und Header verarbeiten
|
||||
4. **Fehlerbehandlung** - Timeouts, Wiederholungsversuche und Fehlerbedingungen verwalten
|
||||
|
||||
## Konfigurationsoptionen
|
||||
|
||||
### URL
|
||||
|
||||
Die Endpunkt-URL für die API-Anfrage. Dies kann sein:
|
||||
|
||||
- Eine statische URL, die direkt im Block eingegeben wird
|
||||
- Eine dynamische URL, die mit der Ausgabe eines anderen Blocks verbunden ist
|
||||
- Eine URL mit Pfadparametern
|
||||
|
||||
### Methode
|
||||
|
||||
Wählen Sie die HTTP-Methode für Ihre Anfrage:
|
||||
|
||||
- **GET**: Daten vom Server abrufen
|
||||
- **POST**: Daten an den Server senden, um eine Ressource zu erstellen
|
||||
- **PUT**: Eine bestehende Ressource auf dem Server aktualisieren
|
||||
- **DELETE**: Eine Ressource vom Server entfernen
|
||||
- **PATCH**: Eine bestehende Ressource teilweise aktualisieren
|
||||
|
||||
### Abfrageparameter
|
||||
|
||||
Definieren Sie Schlüssel-Wert-Paare, die als Abfrageparameter an die URL angehängt werden. Zum Beispiel:
|
||||
|
||||
```
|
||||
Key: apiKey
|
||||
Value: your_api_key_here
|
||||
|
||||
Key: limit
|
||||
Value: 10
|
||||
```
|
||||
|
||||
Diese würden der URL als `?apiKey=your_api_key_here&limit=10` hinzugefügt werden.
|
||||
|
||||
### Header
|
||||
|
||||
Konfigurieren Sie HTTP-Header für Ihre Anfrage. Häufige Header sind:
|
||||
|
||||
```
|
||||
Key: Content-Type
|
||||
Value: application/json
|
||||
|
||||
Key: Authorization
|
||||
Value: Bearer your_token_here
|
||||
```
|
||||
|
||||
### Anfrage-Body
|
||||
|
||||
Für Methoden, die einen Anfrage-Body unterstützen (POST, PUT, PATCH), können Sie die zu sendenden Daten definieren. Der Body kann sein:
|
||||
|
||||
- JSON-Daten, die direkt im Block eingegeben werden
|
||||
- Daten, die mit der Ausgabe eines anderen Blocks verbunden sind
|
||||
- Dynamisch während der Workflow-Ausführung generierte Daten
|
||||
|
||||
### Zugriff auf Ergebnisse
|
||||
|
||||
Nach Abschluss einer API-Anfrage können Sie auf folgende Ausgaben zugreifen:
|
||||
|
||||
- **`<api.data>`**: Die Antwortdaten vom API
|
||||
- **`<api.status>`**: HTTP-Statuscode (200, 404, 500, usw.)
|
||||
- **`<api.headers>`**: Antwort-Header vom Server
|
||||
- **`<api.error>`**: Fehlerdetails, falls die Anfrage fehlgeschlagen ist
|
||||
|
||||
## Erweiterte Funktionen
|
||||
|
||||
### Dynamische URL-Konstruktion
|
||||
|
||||
Bauen Sie URLs dynamisch mit Variablen aus vorherigen Blöcken:
|
||||
|
||||
```javascript
|
||||
// In a Function block before the API
|
||||
const userId = <start.userId>;
|
||||
const apiUrl = `https://api.example.com/users/${userId}/profile`;
|
||||
```
|
||||
|
||||
### Anfrage-Wiederholungen
|
||||
|
||||
Der API-Block behandelt automatisch:
|
||||
- Netzwerk-Timeouts mit exponentiellem Backoff
|
||||
- Rate-Limit-Antworten (429-Statuscodes)
|
||||
- Serverfehler (5xx-Statuscodes) mit Wiederholungslogik
|
||||
- Verbindungsfehler mit Wiederverbindungsversuchen
|
||||
|
||||
### Antwortvalidierung
|
||||
|
||||
Validieren Sie API-Antworten vor der Verarbeitung:
|
||||
|
||||
```javascript
|
||||
// In a Function block after the API
|
||||
if (<api.status> === 200) {
|
||||
const data = <api.data>;
|
||||
// Process successful response
|
||||
} else {
|
||||
// Handle error response
|
||||
console.error(`API Error: ${<api.status>}`);
|
||||
}
|
||||
```
|
||||
|
||||
## Eingaben und Ausgaben
|
||||
|
||||
<Tabs items={['Configuration', 'Variables', 'Results']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>URL</strong>: Der Endpunkt, an den die Anfrage gesendet werden soll
|
||||
</li>
|
||||
<li>
|
||||
<strong>Method</strong>: HTTP-Methode (GET, POST, PUT, DELETE, PATCH)
|
||||
</li>
|
||||
<li>
|
||||
<strong>Query Parameters</strong>: Schlüssel-Wert-Paare für URL-Parameter
|
||||
</li>
|
||||
<li>
|
||||
<strong>Headers</strong>: HTTP-Header für Authentifizierung und Inhaltstyp
|
||||
</li>
|
||||
<li>
|
||||
<strong>Body</strong>: Anfrage-Payload für POST/PUT/PATCH-Methoden
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>api.data</strong>: Antwortdaten vom API-Aufruf
|
||||
</li>
|
||||
<li>
|
||||
<strong>api.status</strong>: Vom Server zurückgegebener HTTP-Statuscode
|
||||
</li>
|
||||
<li>
|
||||
<strong>api.headers</strong>: Antwort-Header vom Server
|
||||
</li>
|
||||
<li>
|
||||
<strong>api.error</strong>: Fehlerdetails, falls die Anfrage fehlgeschlagen ist
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Response Data</strong>: Primärer API-Antwortinhalt
|
||||
</li>
|
||||
<li>
|
||||
<strong>Status Information</strong>: HTTP-Status und Fehlerdetails
|
||||
</li>
|
||||
<li>
|
||||
<strong>Access</strong>: Verfügbar in Blöcken nach dem API-Aufruf
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Beispielanwendungsfälle
|
||||
|
||||
### Benutzerprofildaten abrufen
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Benutzerinformationen von externem Dienst abrufen</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Funktionsblock erstellt Benutzer-ID aus Eingabe</li>
|
||||
<li>API-Block ruft GET /users/{id} Endpunkt auf</li>
|
||||
<li>Funktionsblock verarbeitet und formatiert Benutzerdaten</li>
|
||||
<li>Antwortblock gibt formatiertes Profil zurück</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Zahlungsabwicklung
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Zahlung über Stripe API verarbeiten</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Funktionsblock validiert Zahlungsdaten</li>
|
||||
<li>API-Block erstellt Zahlungsabsicht über Stripe</li>
|
||||
<li>Bedingungsblock behandelt Zahlungserfolg/-fehler</li>
|
||||
<li>Supabase-Block aktualisiert Bestellstatus in der Datenbank</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
## Best Practices
|
||||
|
||||
- **Umgebungsvariablen für sensible Daten verwenden**: Keine API-Schlüssel oder Anmeldedaten im Code hinterlegen
|
||||
- **Fehler elegant behandeln**: Fehlerbehandlungslogik für fehlgeschlagene Anfragen einbinden
|
||||
- **Antworten validieren**: Statuscodes und Antwortformate vor der Datenverarbeitung prüfen
|
||||
- **Ratenbegrenzungen beachten**: Auf API-Ratenbegrenzungen achten und angemessene Drosselung implementieren
|
||||
242
apps/docs/content/docs/de/blocks/condition.mdx
Normal file
242
apps/docs/content/docs/de/blocks/condition.mdx
Normal file
@@ -0,0 +1,242 @@
|
||||
---
|
||||
title: Bedingung
|
||||
---
|
||||
|
||||
import { Callout } from 'fumadocs-ui/components/callout'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Accordion, Accordions } from 'fumadocs-ui/components/accordion'
|
||||
import { Image } from '@/components/ui/image'
|
||||
|
||||
Der Bedingungsblock ermöglicht es Ihnen, den Ausführungspfad Ihres Workflows basierend auf booleschen Ausdrücken zu verzweigen und so dynamische, reaktionsfähige Workflows mit unterschiedlichen Ausführungspfaden zu erstellen. Er wertet Bedingungen aus und leitet den Workflow entsprechend weiter, sodass Sie den Ausführungsfluss basierend auf Daten oder Logik steuern können, ohne ein LLM zu benötigen.
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/condition.png"
|
||||
alt="Bedingungsblock"
|
||||
width={500}
|
||||
height={350}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
<Callout>
|
||||
Bedingungsblöcke ermöglichen deterministische Entscheidungsfindung ohne ein LLM zu benötigen, was sie ideal
|
||||
für unkomplizierte Verzweigungslogik macht.
|
||||
</Callout>
|
||||
|
||||
## Überblick
|
||||
|
||||
Der Bedingungsblock ermöglicht Ihnen:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Verzweigungslogik erstellen</strong>: Workflows basierend auf booleschen Ausdrücken leiten
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Datengesteuerte Entscheidungen treffen</strong>: Bedingungen anhand von Ausgaben vorheriger Blöcke auswerten
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Mehrere Szenarien behandeln</strong>: Mehrere Bedingungen mit unterschiedlichen Pfaden definieren
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Deterministische Weiterleitung bieten</strong>: Entscheidungen ohne ein LLM treffen
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Funktionsweise
|
||||
|
||||
Der Bedingungsblock arbeitet durch einen sequentiellen Auswertungsprozess:
|
||||
|
||||
1. **Ausdruck auswerten** - Verarbeitet den JavaScript/TypeScript-booleschen Ausdruck mit aktuellen Workflow-Daten
|
||||
2. **Ergebnis bestimmen** - Gibt basierend auf der Ausdrucksauswertung true oder false zurück
|
||||
3. **Workflow weiterleiten** - Leitet die Ausführung basierend auf dem Ergebnis an den entsprechenden Zielblock weiter
|
||||
4. **Kontext bereitstellen** - Generiert Metadaten über die Entscheidung für Debugging und Überwachung
|
||||
|
||||
## Konfigurationsoptionen
|
||||
|
||||
### Bedingungen
|
||||
|
||||
Definieren Sie eine oder mehrere Bedingungen, die ausgewertet werden. Jede Bedingung umfasst:
|
||||
|
||||
- **Ausdruck**: Ein JavaScript/TypeScript-Ausdruck, der zu true oder false ausgewertet wird
|
||||
- **Pfad**: Der Zielblock, zu dem weitergeleitet werden soll, wenn die Bedingung true ist
|
||||
- **Beschreibung**: Optionale Erklärung, was die Bedingung prüft
|
||||
|
||||
Sie können mehrere Bedingungen erstellen, die der Reihe nach ausgewertet werden, wobei die erste übereinstimmende Bedingung den Ausführungspfad bestimmt.
|
||||
|
||||
### Format für Bedingungsausdrücke
|
||||
|
||||
Bedingungen verwenden JavaScript-Syntax und können auf Eingabewerte aus vorherigen Blöcken verweisen.
|
||||
|
||||
<Tabs items={['Schwellenwert', 'Textanalyse', 'Mehrere Bedingungen']}>
|
||||
<Tab>
|
||||
|
||||
```javascript
|
||||
// Check if a score is above a threshold
|
||||
<agent.score> > 75
|
||||
```
|
||||
|
||||
</Tab>
|
||||
<Tab>
|
||||
|
||||
```javascript
|
||||
// Check if a text contains specific keywords
|
||||
<agent.text>.includes('urgent') || <agent.text>.includes('emergency')
|
||||
```
|
||||
|
||||
</Tab>
|
||||
<Tab>
|
||||
|
||||
```javascript
|
||||
// Check multiple conditions
|
||||
<agent.age> >= 18 && <agent.country> === 'US'
|
||||
```
|
||||
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
### Zugriff auf Ergebnisse
|
||||
|
||||
Nach der Auswertung einer Bedingung können Sie auf folgende Ausgaben zugreifen:
|
||||
|
||||
- **`<condition.result>`**: Boolesches Ergebnis der Bedingungsauswertung
|
||||
- **`<condition.matched_condition>`**: ID der übereinstimmenden Bedingung
|
||||
- **`<condition.content>`**: Beschreibung des Auswertungsergebnisses
|
||||
- **`<condition.path>`**: Details zum gewählten Routing-Ziel
|
||||
|
||||
## Erweiterte Funktionen
|
||||
|
||||
### Komplexe Ausdrücke
|
||||
|
||||
Verwenden Sie JavaScript-Operatoren und -Funktionen in Bedingungen:
|
||||
|
||||
```javascript
|
||||
// String operations
|
||||
<user.email>.endsWith('@company.com')
|
||||
|
||||
// Array operations
|
||||
<api.tags>.includes('urgent')
|
||||
|
||||
// Mathematical operations
|
||||
<agent.confidence> * 100 > 85
|
||||
|
||||
// Date comparisons
|
||||
new Date(<api.created_at>) > new Date('2024-01-01')
|
||||
```
|
||||
|
||||
### Auswertung mehrerer Bedingungen
|
||||
|
||||
Bedingungen werden der Reihe nach ausgewertet, bis eine übereinstimmt:
|
||||
|
||||
```javascript
|
||||
// Condition 1: Check for high priority
|
||||
<ticket.priority> === 'high'
|
||||
|
||||
// Condition 2: Check for urgent keywords
|
||||
<ticket.subject>.toLowerCase().includes('urgent')
|
||||
|
||||
// Condition 3: Default fallback
|
||||
true
|
||||
```
|
||||
|
||||
### Fehlerbehandlung
|
||||
|
||||
Bedingungen behandeln automatisch:
|
||||
- Undefinierte oder Null-Werte mit sicherer Auswertung
|
||||
- Typabweichungen mit geeigneten Fallbacks
|
||||
- Ungültige Ausdrücke mit Fehlerprotokollierung
|
||||
- Fehlende Variablen mit Standardwerten
|
||||
|
||||
## Eingaben und Ausgaben
|
||||
|
||||
<Tabs items={['Konfiguration', 'Variablen', 'Ergebnisse']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Bedingungen</strong>: Array von booleschen Ausdrücken zur Auswertung
|
||||
</li>
|
||||
<li>
|
||||
<strong>Ausdrücke</strong>: JavaScript/TypeScript-Bedingungen mit Block-Ausgaben
|
||||
</li>
|
||||
<li>
|
||||
<strong>Routing-Pfade</strong>: Zielblöcke für jedes Bedingungsergebnis
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>condition.result</strong>: Boolesches Ergebnis der Bedingungsauswertung
|
||||
</li>
|
||||
<li>
|
||||
<strong>condition.matched_condition</strong>: ID der übereinstimmenden Bedingung
|
||||
</li>
|
||||
<li>
|
||||
<strong>condition.content</strong>: Beschreibung des Auswertungsergebnisses
|
||||
</li>
|
||||
<li>
|
||||
<strong>condition.path</strong>: Details zum gewählten Routing-Ziel
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Boolesches Ergebnis</strong>: Primäres Ergebnis der Bedingungsauswertung
|
||||
</li>
|
||||
<li>
|
||||
<strong>Routing-Informationen</strong>: Pfadauswahl und Bedingungsdetails
|
||||
</li>
|
||||
<li>
|
||||
<strong>Zugriff</strong>: Verfügbar in Blöcken nach der Bedingung
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Beispielanwendungsfälle
|
||||
|
||||
### Routing im Kundenservice
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Support-Tickets nach Priorität weiterleiten</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>API-Block ruft Support-Ticket-Daten ab</li>
|
||||
<li>Bedingung prüft, ob `<api.priority>` gleich 'high' ist</li>
|
||||
<li>Tickets mit hoher Priorität → Mitarbeiter mit Eskalationswerkzeugen</li>
|
||||
<li>Tickets mit normaler Priorität → Standard-Support-Mitarbeiter</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Inhaltsmoderation
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Inhalte basierend auf Analyseergebnissen filtern</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Agent analysiert nutzergenerierte Inhalte</li>
|
||||
<li>Bedingung prüft, ob `<agent.toxicity_score>` > 0.7</li>
|
||||
<li>Toxische Inhalte → Moderationsworkflow</li>
|
||||
<li>Unbedenkliche Inhalte → Veröffentlichungsworkflow</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Benutzer-Onboarding-Prozess
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Onboarding basierend auf Benutzertyp personalisieren</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Funktionsblock verarbeitet Benutzerregistrierungsdaten</li>
|
||||
<li>Bedingung prüft, ob `<user.account_type>` === 'enterprise'</li>
|
||||
<li>Unternehmensbenutzer → Erweiterter Einrichtungsworkflow</li>
|
||||
<li>Einzelbenutzer → Einfacher Onboarding-Workflow</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
## Best Practices
|
||||
|
||||
- **Bedingungen richtig anordnen**: Platzieren Sie spezifischere Bedingungen vor allgemeinen, damit spezifische Logik Vorrang vor Fallbacks hat
|
||||
- **Standardbedingung einfügen**: Fügen Sie eine Auffangbedingung (`true`) als letzte Bedingung hinzu, um nicht übereinstimmende Fälle zu behandeln und zu verhindern, dass die Workflow-Ausführung stecken bleibt
|
||||
- **Ausdrücke einfach halten**: Verwenden Sie klare, unkomplizierte boolesche Ausdrücke für bessere Lesbarkeit und einfachere Fehlersuche
|
||||
- **Dokumentieren Sie Ihre Bedingungen**: Fügen Sie Beschreibungen hinzu, um den Zweck jeder Bedingung für bessere Teamzusammenarbeit und Wartung zu erklären
|
||||
- **Testen Sie Grenzfälle**: Überprüfen Sie, ob Bedingungen Grenzwerte korrekt behandeln, indem Sie mit Werten an den Grenzen Ihrer Bedingungsbereiche testen
|
||||
199
apps/docs/content/docs/de/blocks/evaluator.mdx
Normal file
199
apps/docs/content/docs/de/blocks/evaluator.mdx
Normal file
@@ -0,0 +1,199 @@
|
||||
---
|
||||
title: Evaluator
|
||||
---
|
||||
|
||||
import { Callout } from 'fumadocs-ui/components/callout'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Image } from '@/components/ui/image'
|
||||
import { Video } from '@/components/ui/video'
|
||||
|
||||
Der Evaluator-Block nutzt KI, um die Inhaltsqualität anhand anpassbarer Bewertungsmetriken zu bewerten, die du selbst definierst. Perfekt für Qualitätskontrolle, A/B-Tests und um sicherzustellen, dass deine KI-Ausgaben bestimmte Standards erfüllen.
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/evaluator.png"
|
||||
alt="Evaluator-Block-Konfiguration"
|
||||
width={500}
|
||||
height={400}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
## Überblick
|
||||
|
||||
Mit dem Evaluator-Block kannst du:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Inhaltsqualität bewerten</strong>: Nutze KI, um Inhalte anhand benutzerdefinierter Metriken mit numerischen Werten zu bewerten
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Benutzerdefinierte Metriken erstellen</strong>: Erstelle spezifische Bewertungskriterien, die auf deinen Anwendungsfall zugeschnitten sind
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Qualitätskontrolle automatisieren</strong>: Erstelle Workflows, die Inhalte automatisch bewerten und filtern
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Leistung verfolgen</strong>: Überwache Verbesserungen und Konsistenz im Laufe der Zeit mit objektiver Bewertung
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Funktionsweise
|
||||
|
||||
Der Evaluator-Block verarbeitet Inhalte durch KI-gestützte Bewertung:
|
||||
|
||||
1. **Inhalte empfangen** - Nimmt Eingabeinhalte von vorherigen Blöcken in deinem Workflow entgegen
|
||||
2. **Metriken anwenden** - Bewertet Inhalte anhand deiner definierten benutzerdefinierten Metriken
|
||||
3. **Bewertungen generieren** - KI-Modell weist numerische Werte für jede Metrik zu
|
||||
4. **Zusammenfassung bereitstellen** - Liefert detaillierte Auswertung mit Bewertungen und Erklärungen
|
||||
|
||||
## Konfigurationsoptionen
|
||||
|
||||
### Bewertungsmetriken
|
||||
|
||||
Definiere benutzerdefinierte Metriken, anhand derer Inhalte bewertet werden. Jede Metrik umfasst:
|
||||
|
||||
- **Name**: Eine kurze Bezeichnung für die Metrik
|
||||
- **Beschreibung**: Eine detaillierte Erklärung dessen, was die Metrik misst
|
||||
- **Bereich**: Der numerische Bereich für die Bewertung (z.B. 1-5, 0-10)
|
||||
|
||||
Beispielmetriken:
|
||||
|
||||
```
|
||||
Accuracy (1-5): How factually accurate is the content?
|
||||
Clarity (1-5): How clear and understandable is the content?
|
||||
Relevance (1-5): How relevant is the content to the original query?
|
||||
```
|
||||
|
||||
### Inhalt
|
||||
|
||||
Der zu bewertende Inhalt. Dies kann sein:
|
||||
|
||||
- Direkt in der Blockkonfiguration bereitgestellt
|
||||
- Verbunden mit der Ausgabe eines anderen Blocks (typischerweise ein Agent-Block)
|
||||
- Dynamisch während der Workflow-Ausführung generiert
|
||||
|
||||
### Modellauswahl
|
||||
|
||||
Wählen Sie ein KI-Modell für die Durchführung der Bewertung:
|
||||
|
||||
**OpenAI**: GPT-4o, o1, o3, o4-mini, gpt-4.1
|
||||
**Anthropic**: Claude 3.7 Sonnet
|
||||
**Google**: Gemini 2.5 Pro, Gemini 2.0 Flash
|
||||
**Andere Anbieter**: Groq, Cerebras, xAI, DeepSeek
|
||||
**Lokale Modelle**: Jedes Modell, das auf Ollama läuft
|
||||
|
||||
<div className="w-full max-w-2xl mx-auto overflow-hidden rounded-lg">
|
||||
<Video src="models.mp4" width={500} height={350} />
|
||||
</div>
|
||||
|
||||
**Empfehlung**: Verwenden Sie Modelle mit starken Argumentationsfähigkeiten wie GPT-4o oder Claude 3.7 Sonnet für genauere Bewertungen.
|
||||
|
||||
### API-Schlüssel
|
||||
|
||||
Ihr API-Schlüssel für den ausgewählten LLM-Anbieter. Dieser wird sicher gespeichert und für die Authentifizierung verwendet.
|
||||
|
||||
## Funktionsweise
|
||||
|
||||
1. Der Evaluator-Block nimmt den bereitgestellten Inhalt und Ihre benutzerdefinierten Metriken
|
||||
2. Er generiert einen spezialisierten Prompt, der das LLM anweist, den Inhalt zu bewerten
|
||||
3. Der Prompt enthält klare Richtlinien zur Bewertung jeder Metrik
|
||||
4. Das LLM bewertet den Inhalt und gibt numerische Werte für jede Metrik zurück
|
||||
5. Der Evaluator-Block formatiert diese Werte als strukturierte Ausgabe zur Verwendung in Ihrem Workflow
|
||||
|
||||
## Beispielanwendungsfälle
|
||||
|
||||
### Bewertung der Inhaltsqualität
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Bewertung der Blogpost-Qualität vor der Veröffentlichung</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Agent-Block generiert Blogpost-Inhalte</li>
|
||||
<li>Evaluator bewertet Genauigkeit, Lesbarkeit und Engagement</li>
|
||||
<li>Bedingungsblock prüft, ob die Werte Mindestschwellen erreichen</li>
|
||||
<li>Hohe Werte → Veröffentlichen, Niedrige Werte → Überarbeiten und erneut versuchen</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### A/B-Testing von Inhalten
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Vergleich mehrerer KI-generierter Antworten</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Parallelblock generiert mehrere Antwortvarianten</li>
|
||||
<li>Evaluator bewertet jede Variante nach Klarheit und Relevanz</li>
|
||||
<li>Funktionsblock wählt die Antwort mit der höchsten Bewertung aus</li>
|
||||
<li>Antwortblock gibt das beste Ergebnis zurück</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Qualitätskontrolle im Kundensupport
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Sicherstellen, dass Support-Antworten den Qualitätsstandards entsprechen</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Support-Mitarbeiter generiert Antwort auf Kundenanfrage</li>
|
||||
<li>Evaluator bewertet Hilfsbereitschaft, Einfühlungsvermögen und Genauigkeit</li>
|
||||
<li>Bewertungen werden für Training und Leistungsüberwachung protokolliert</li>
|
||||
<li>Niedrige Bewertungen lösen einen manuellen Überprüfungsprozess aus</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
## Eingaben und Ausgaben
|
||||
|
||||
<Tabs items={['Konfiguration', 'Variablen', 'Ergebnisse']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Inhalt</strong>: Der zu bewertende Text oder strukturierte Daten
|
||||
</li>
|
||||
<li>
|
||||
<strong>Bewertungsmetriken</strong>: Benutzerdefinierte Kriterien mit Bewertungsbereichen
|
||||
</li>
|
||||
<li>
|
||||
<strong>Modell</strong>: KI-Modell für die Bewertungsanalyse
|
||||
</li>
|
||||
<li>
|
||||
<strong>API-Schlüssel</strong>: Authentifizierung für den ausgewählten LLM-Anbieter
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>evaluator.content</strong>: Zusammenfassung der Bewertung
|
||||
</li>
|
||||
<li>
|
||||
<strong>evaluator.model</strong>: Für die Bewertung verwendetes Modell
|
||||
</li>
|
||||
<li>
|
||||
<strong>evaluator.tokens</strong>: Token-Nutzungsstatistiken
|
||||
</li>
|
||||
<li>
|
||||
<strong>evaluator.cost</strong>: Kostenübersicht für den Bewertungsaufruf
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Metrik-Bewertungen</strong>: Numerische Bewertungen für jede definierte Metrik
|
||||
</li>
|
||||
<li>
|
||||
<strong>Bewertungszusammenfassung</strong>: Detaillierte Beurteilung mit Erläuterungen
|
||||
</li>
|
||||
<li>
|
||||
<strong>Zugriff</strong>: Verfügbar in Blöcken nach dem Evaluator
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Best Practices
|
||||
|
||||
- **Verwenden Sie spezifische Metrikbeschreibungen**: Definieren Sie klar, was jede Metrik misst, um genauere Bewertungen zu erhalten
|
||||
- **Wählen Sie geeignete Bereiche**: Wählen Sie Bewertungsbereiche, die ausreichend Granularität bieten, ohne übermäßig komplex zu sein
|
||||
- **Verbinden Sie mit Agent-Blöcken**: Verwenden Sie Evaluator-Blöcke, um die Ausgaben von Agent-Blöcken zu bewerten und Feedback-Schleifen zu erstellen
|
||||
- **Verwenden Sie konsistente Metriken**: Für vergleichende Analysen sollten Sie konsistente Metriken über ähnliche Bewertungen hinweg beibehalten
|
||||
- **Kombinieren Sie mehrere Metriken**: Verwenden Sie mehrere Metriken, um eine umfassende Bewertung zu erhalten
|
||||
156
apps/docs/content/docs/de/blocks/function.mdx
Normal file
156
apps/docs/content/docs/de/blocks/function.mdx
Normal file
@@ -0,0 +1,156 @@
|
||||
---
|
||||
title: Funktion
|
||||
---
|
||||
|
||||
import { Callout } from 'fumadocs-ui/components/callout'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Image } from '@/components/ui/image'
|
||||
|
||||
Der Funktionsblock ermöglicht die Ausführung von benutzerdefiniertem JavaScript- oder TypeScript-Code in Ihren Workflows. Verwenden Sie ihn, um Daten zu transformieren, Berechnungen durchzuführen oder benutzerdefinierte Logik zu implementieren, die in anderen Blöcken nicht verfügbar ist.
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/function.png"
|
||||
alt="Funktionsblock mit Code-Editor"
|
||||
width={500}
|
||||
height={350}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
## Überblick
|
||||
|
||||
Der Funktionsblock ermöglicht Ihnen:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Daten transformieren</strong>: Formate konvertieren, Text analysieren, Arrays und Objekte manipulieren
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Berechnungen durchführen</strong>: Mathematische Operationen, Statistiken, Finanzberechnungen
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Benutzerdefinierte Logik implementieren</strong>: Komplexe Bedingungen, Schleifen und Algorithmen
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Externe Daten verarbeiten</strong>: Antworten parsen, Anfragen formatieren, Authentifizierung verwalten
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Funktionsweise
|
||||
|
||||
Der Funktionsblock führt Ihren Code in einer sicheren, isolierten Umgebung aus:
|
||||
|
||||
1. **Eingabe empfangen**: Zugriff auf Daten aus vorherigen Blöcken über das `input` Objekt
|
||||
2. **Code ausführen**: Führen Sie Ihren JavaScript/Python-Code aus
|
||||
3. **Ergebnisse zurückgeben**: Verwenden Sie `return`, um Daten an den nächsten Block zu übergeben
|
||||
4. **Fehler behandeln**: Integrierte Fehlerbehandlung und Protokollierung
|
||||
|
||||
## Remote-Ausführung (E2B)
|
||||
|
||||
- **Sprachen**: JavaScript und Python in einer isolierten E2B-Sandbox ausführen.
|
||||
- **Aktivierung**: Schalten Sie “Remote Code Execution” im Funktionsblock ein.
|
||||
- **Einsatzbereich**: Schwerere Logik, externe Bibliotheken oder Python-spezifischer Code.
|
||||
- **Leistung**: Langsamer als lokales JS aufgrund von Sandbox-Start und Netzwerk-Overhead.
|
||||
- **Hinweise**: Erfordert `E2B_API_KEY` bei lokaler Ausführung. Für niedrigste Latenz verwenden Sie nativ lokales JS (Fast Mode).
|
||||
|
||||
## Eingaben und Ausgaben
|
||||
|
||||
<Tabs items={['Configuration', 'Variables']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Code</strong>: Ihr JavaScript/Python-Code zur Ausführung
|
||||
</li>
|
||||
<li>
|
||||
<strong>Timeout</strong>: Maximale Ausführungszeit (standardmäßig 30 Sekunden)
|
||||
</li>
|
||||
<li>
|
||||
<strong>Eingabedaten</strong>: Alle verbundenen Block-Ausgaben sind über Variablen verfügbar
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>function.result</strong>: Der von Ihrer Funktion zurückgegebene Wert
|
||||
</li>
|
||||
<li>
|
||||
<strong>function.stdout</strong>: Console.log()-Ausgabe aus Ihrem Code
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Beispielanwendungsfälle
|
||||
|
||||
### Datenverarbeitungspipeline
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: API-Antwort in strukturierte Daten umwandeln</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>API-Block ruft Rohdaten der Kunden ab</li>
|
||||
<li>Funktionsblock verarbeitet und validiert Daten</li>
|
||||
<li>Funktionsblock berechnet abgeleitete Metriken</li>
|
||||
<li>Antwortblock gibt formatierte Ergebnisse zurück</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Implementierung von Geschäftslogik
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Berechnung von Treuepunkten und Stufen</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Agent ruft Kaufhistorie des Kunden ab</li>
|
||||
<li>Funktionsblock berechnet Treuemetriken</li>
|
||||
<li>Funktionsblock bestimmt Kundenstufe</li>
|
||||
<li>Bedingungsblock leitet basierend auf der Stufenhöhe weiter</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Datenvalidierung und -bereinigung
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Benutzereingaben validieren und bereinigen</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Benutzereingabe aus Formularübermittlung erhalten</li>
|
||||
<li>Funktionsblock validiert E-Mail-Format und Telefonnummern</li>
|
||||
<li>Funktionsblock bereinigt und normalisiert Daten</li>
|
||||
<li>API-Block speichert validierte Daten in der Datenbank</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Beispiel: Treuepunkte-Rechner
|
||||
|
||||
```javascript title="loyalty-calculator.js"
|
||||
// Process customer data and calculate loyalty score
|
||||
const { purchaseHistory, accountAge, supportTickets } = <agent>;
|
||||
|
||||
// Calculate metrics
|
||||
const totalSpent = purchaseHistory.reduce((sum, purchase) => sum + purchase.amount, 0);
|
||||
const purchaseFrequency = purchaseHistory.length / (accountAge / 365);
|
||||
const ticketRatio = supportTickets.resolved / supportTickets.total;
|
||||
|
||||
// Calculate loyalty score (0-100)
|
||||
const spendScore = Math.min(totalSpent / 1000 * 30, 30);
|
||||
const frequencyScore = Math.min(purchaseFrequency * 20, 40);
|
||||
const supportScore = ticketRatio * 30;
|
||||
|
||||
const loyaltyScore = Math.round(spendScore + frequencyScore + supportScore);
|
||||
|
||||
return {
|
||||
customer: <agent.name>,
|
||||
loyaltyScore,
|
||||
loyaltyTier: loyaltyScore >= 80 ? "Platinum" : loyaltyScore >= 60 ? "Gold" : "Silver",
|
||||
metrics: { spendScore, frequencyScore, supportScore }
|
||||
};
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
- **Funktionen fokussiert halten**: Schreiben Sie Funktionen, die eine Sache gut erledigen, um die Wartbarkeit und Fehlersuche zu verbessern
|
||||
- **Fehler elegant behandeln**: Verwenden Sie try/catch-Blöcke, um potenzielle Fehler zu behandeln und aussagekräftige Fehlermeldungen bereitzustellen
|
||||
- **Grenzfälle testen**: Stellen Sie sicher, dass Ihr Code ungewöhnliche Eingaben, Null-Werte und Grenzbedingungen korrekt behandelt
|
||||
- **Auf Leistung optimieren**: Achten Sie bei großen Datensätzen auf die Berechnungskomplexität und den Speicherverbrauch
|
||||
- **console.log() zum Debuggen verwenden**: Nutzen Sie die Stdout-Ausgabe zum Debuggen und Überwachen der Funktionsausführung
|
||||
129
apps/docs/content/docs/de/blocks/index.mdx
Normal file
129
apps/docs/content/docs/de/blocks/index.mdx
Normal file
@@ -0,0 +1,129 @@
|
||||
---
|
||||
title: Blöcke
|
||||
description: Die Bausteine deiner KI-Workflows
|
||||
---
|
||||
|
||||
import { Card, Cards } from 'fumadocs-ui/components/card'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Video } from '@/components/ui/video'
|
||||
|
||||
Blöcke sind die Bausteine, die du miteinander verbindest, um KI-Workflows zu erstellen. Betrachte sie als spezialisierte Module, die jeweils eine bestimmte Aufgabe übernehmen – vom Chatten mit KI-Modellen über API-Aufrufe bis hin zur Datenverarbeitung.
|
||||
|
||||
<div className="w-full max-w-2xl mx-auto overflow-hidden rounded-lg">
|
||||
<Video src="connections.mp4" width={700} height={450} />
|
||||
</div>
|
||||
|
||||
## Grundlegende Blocktypen
|
||||
|
||||
Sim bietet sieben grundlegende Blocktypen, die die wesentlichen Funktionen von KI-Workflows abdecken:
|
||||
|
||||
### Verarbeitungsblöcke
|
||||
- **[Agent](/blocks/agent)** - Chatte mit KI-Modellen (OpenAI, Anthropic, Google, lokale Modelle)
|
||||
- **[Function](/blocks/function)** - Führe benutzerdefinierten JavaScript/TypeScript-Code aus
|
||||
- **[API](/blocks/api)** - Verbinde dich mit externen Diensten über HTTP-Anfragen
|
||||
|
||||
### Logikblöcke
|
||||
- **[Condition](/blocks/condition)** - Verzweige Workflow-Pfade basierend auf booleschen Ausdrücken
|
||||
- **[Router](/blocks/router)** - Nutze KI, um Anfragen intelligent auf verschiedene Pfade zu leiten
|
||||
- **[Evaluator](/blocks/evaluator)** - Bewerte und beurteile die Inhaltsqualität mit KI
|
||||
|
||||
### Ausgabeblöcke
|
||||
- **[Response](/blocks/response)** - Formatiere und gib endgültige Ergebnisse aus deinem Workflow zurück
|
||||
|
||||
## Wie Blöcke funktionieren
|
||||
|
||||
Jeder Block hat drei Hauptkomponenten:
|
||||
|
||||
**Eingaben**: Daten, die in den Block von anderen Blöcken oder Benutzereingaben kommen
|
||||
**Konfiguration**: Einstellungen, die das Verhalten des Blocks steuern
|
||||
**Ausgaben**: Daten, die der Block für andere Blöcke produziert
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Eingabe empfangen</strong>: Block erhält Daten von verbundenen Blöcken oder Benutzereingaben
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Verarbeiten</strong>: Block verarbeitet die Eingabe gemäß seiner Konfiguration
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Ergebnisse ausgeben</strong>: Block erzeugt Ausgabedaten für die nächsten Blöcke im Workflow
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Blöcke verbinden
|
||||
|
||||
Sie erstellen Workflows, indem Sie Blöcke miteinander verbinden. Die Ausgabe eines Blocks wird zur Eingabe eines anderen:
|
||||
|
||||
- **Ziehen zum Verbinden**: Ziehen Sie von einem Ausgabeport zu einem Eingabeport
|
||||
- **Mehrfachverbindungen**: Eine Ausgabe kann mit mehreren Eingängen verbunden werden
|
||||
- **Verzweigende Pfade**: Einige Blöcke können basierend auf Bedingungen zu verschiedenen Pfaden weiterleiten
|
||||
|
||||
<div className="w-full max-w-2xl mx-auto overflow-hidden rounded-lg">
|
||||
<Video src="connections.mp4" width={700} height={450} />
|
||||
</div>
|
||||
|
||||
## Häufige Muster
|
||||
|
||||
### Sequentielle Verarbeitung
|
||||
Verbinden Sie Blöcke in einer Kette, wobei jeder Block die Ausgabe des vorherigen verarbeitet:
|
||||
|
||||
```
|
||||
User Input → Agent → Function → Response
|
||||
```
|
||||
|
||||
### Bedingte Verzweigung
|
||||
Verwenden Sie Bedingungsblöcke oder Router-Blöcke, um verschiedene Pfade zu erstellen:
|
||||
|
||||
```
|
||||
User Input → Router → Agent A (for questions)
|
||||
→ Agent B (for commands)
|
||||
```
|
||||
|
||||
### Qualitätskontrolle
|
||||
Verwenden Sie Evaluator-Blöcke, um Ausgaben zu bewerten und zu filtern:
|
||||
|
||||
```
|
||||
Agent → Evaluator → Condition → Response (if good)
|
||||
→ Agent (retry if bad)
|
||||
```
|
||||
|
||||
## Block-Konfiguration
|
||||
|
||||
Jeder Blocktyp hat spezifische Konfigurationsoptionen:
|
||||
|
||||
**Alle Blöcke**:
|
||||
- Ein-/Ausgabeverbindungen
|
||||
- Fehlerbehandlungsverhalten
|
||||
- Zeitüberschreitungseinstellungen für die Ausführung
|
||||
|
||||
**KI-Blöcke** (Agent, Router, Evaluator):
|
||||
- Modellauswahl (OpenAI, Anthropic, Google, lokal)
|
||||
- API-Schlüssel und Authentifizierung
|
||||
- Temperature und andere Modellparameter
|
||||
- Systemaufforderungen und Anweisungen
|
||||
|
||||
**Logikblöcke** (Bedingung, Funktion):
|
||||
- Benutzerdefinierte Ausdrücke oder Code
|
||||
- Variablenreferenzen
|
||||
- Einstellungen für die Ausführungsumgebung
|
||||
|
||||
**Integrationsblöcke** (API, Antwort):
|
||||
- Endpunktkonfiguration
|
||||
- Header und Authentifizierung
|
||||
- Anfrage-/Antwortformatierung
|
||||
|
||||
<Cards>
|
||||
<Card title="Agent Block" href="/blocks/agent">
|
||||
Verbindung zu KI-Modellen herstellen und intelligente Antworten erzeugen
|
||||
</Card>
|
||||
<Card title="Function Block" href="/blocks/function">
|
||||
Benutzerdefinierten Code ausführen, um Daten zu verarbeiten und zu transformieren
|
||||
</Card>
|
||||
<Card title="API Block" href="/blocks/api">
|
||||
Integration mit externen Diensten und APIs
|
||||
</Card>
|
||||
<Card title="Condition Block" href="/blocks/condition">
|
||||
Verzweigende Logik basierend auf Datenbewertung erstellen
|
||||
</Card>
|
||||
</Cards>
|
||||
211
apps/docs/content/docs/de/blocks/loop.mdx
Normal file
211
apps/docs/content/docs/de/blocks/loop.mdx
Normal file
@@ -0,0 +1,211 @@
|
||||
---
|
||||
title: Loop
|
||||
---
|
||||
|
||||
import { Callout } from 'fumadocs-ui/components/callout'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Image } from '@/components/ui/image'
|
||||
|
||||
Der Loop-Block ist ein Container-Block in Sim, der es ermöglicht, iterative Workflows zu erstellen, indem eine Gruppe von Blöcken wiederholt ausgeführt wird. Loops ermöglichen iterative Verarbeitung in deinen Workflows.
|
||||
|
||||
Der Loop-Block unterstützt zwei Arten der Iteration:
|
||||
|
||||
<Callout type="info">
|
||||
Loop-Blöcke sind Container-Knoten, die andere Blöcke enthalten können. Die Blöcke innerhalb einer Schleife werden basierend auf deiner Konfiguration mehrfach ausgeführt.
|
||||
</Callout>
|
||||
|
||||
## Überblick
|
||||
|
||||
Der Loop-Block ermöglicht dir:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Über Sammlungen iterieren</strong>: Arrays oder Objekte Element für Element verarbeiten
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Operationen wiederholen</strong>: Blöcke eine festgelegte Anzahl von Malen ausführen
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Sequentielle Verarbeitung</strong>: Datentransformation in geordneten Iterationen durchführen
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Ergebnisse aggregieren</strong>: Ausgaben aus allen Schleifeniterationen sammeln
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Funktionsweise
|
||||
|
||||
Der Loop-Block führt enthaltene Blöcke durch sequentielle Iteration aus:
|
||||
|
||||
1. **Schleife initialisieren** - Iterationsparameter festlegen (Anzahl oder Sammlung)
|
||||
2. **Iteration ausführen** - Enthaltene Blöcke für aktuelle Iteration ausführen
|
||||
3. **Ergebnisse sammeln** - Ausgabe jeder Iteration speichern
|
||||
4. **Fortfahren oder abschließen** - Zur nächsten Iteration übergehen oder Schleife beenden
|
||||
|
||||
## Konfigurationsoptionen
|
||||
|
||||
### Schleifentyp
|
||||
|
||||
Wähle zwischen zwei Arten von Schleifen:
|
||||
|
||||
<Tabs items={['For Loop', 'ForEach Loop']}>
|
||||
<Tab>
|
||||
**For Loop (Iterationen)** - Eine numerische Schleife, die eine feste Anzahl von Malen ausgeführt wird:
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/loop-1.png"
|
||||
alt="For Loop mit Iterationen"
|
||||
width={500}
|
||||
height={400}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
Verwende diese Option, wenn du eine Operation eine bestimmte Anzahl von Malen wiederholen musst.
|
||||
|
||||
|
||||
```
|
||||
Example: Run 5 times
|
||||
- Iteration 1
|
||||
- Iteration 2
|
||||
- Iteration 3
|
||||
- Iteration 4
|
||||
- Iteration 5
|
||||
```
|
||||
|
||||
</Tab>
|
||||
<Tab>
|
||||
**ForEach-Schleife (Sammlung)** - Eine sammlungsbasierte Schleife, die über jedes Element in einem Array oder Objekt iteriert:
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/loop-2.png"
|
||||
alt="ForEach-Schleife mit Sammlung"
|
||||
width={500}
|
||||
height={400}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
Verwende diese, wenn du eine Sammlung von Elementen verarbeiten musst.
|
||||
|
||||
|
||||
```
|
||||
Example: Process ["apple", "banana", "orange"]
|
||||
- Iteration 1: Process "apple"
|
||||
- Iteration 2: Process "banana"
|
||||
- Iteration 3: Process "orange"
|
||||
```
|
||||
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Wie man Schleifen verwendet
|
||||
|
||||
### Eine Schleife erstellen
|
||||
|
||||
1. Ziehe einen Schleifenblock aus der Werkzeugleiste auf deine Leinwand
|
||||
2. Konfiguriere den Schleifentyp und die Parameter
|
||||
3. Ziehe andere Blöcke in den Schleifencontainer
|
||||
4. Verbinde die Blöcke nach Bedarf
|
||||
|
||||
### Auf Ergebnisse zugreifen
|
||||
|
||||
Nach Abschluss einer Schleife kannst du auf aggregierte Ergebnisse zugreifen:
|
||||
|
||||
- **`<loop.results>`**: Array von Ergebnissen aus allen Schleifendurchläufen
|
||||
|
||||
## Beispielanwendungsfälle
|
||||
|
||||
### Verarbeitung von API-Ergebnissen
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Mehrere Kundendatensätze verarbeiten</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>API-Block ruft Kundenliste ab</li>
|
||||
<li>ForEach-Schleife iteriert über jeden Kunden</li>
|
||||
<li>Innerhalb der Schleife: Agent analysiert Kundendaten</li>
|
||||
<li>Innerhalb der Schleife: Funktion speichert Analyseergebnisse</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Iterative Inhaltserstellung
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Mehrere Variationen generieren</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>For-Schleife auf 5 Iterationen einstellen</li>
|
||||
<li>Innerhalb der Schleife: Agent generiert Inhaltsvariante</li>
|
||||
<li>Innerhalb der Schleife: Evaluator bewertet den Inhalt</li>
|
||||
<li>Nach der Schleife: Funktion wählt die beste Variante aus</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
## Erweiterte Funktionen
|
||||
|
||||
### Einschränkungen
|
||||
|
||||
<Callout type="warning">
|
||||
Container-Blöcke (Schleifen und Parallele) können nicht ineinander verschachtelt werden. Das bedeutet:
|
||||
- Du kannst keinen Schleifenblock in einen anderen Schleifenblock platzieren
|
||||
- Du kannst keinen Parallelblock in einen Schleifenblock platzieren
|
||||
- Du kannst keinen Container-Block in einen anderen Container-Block platzieren
|
||||
|
||||
Wenn du mehrdimensionale Iterationen benötigst, erwäge eine Umstrukturierung deines Workflows, um sequentielle Schleifen zu verwenden oder Daten in Stufen zu verarbeiten.
|
||||
</Callout>
|
||||
|
||||
<Callout type="info">
|
||||
Schleifen werden sequentiell ausgeführt, nicht parallel. Wenn Sie eine gleichzeitige Ausführung benötigen, verwenden Sie stattdessen den Parallel-Block.
|
||||
</Callout>
|
||||
|
||||
## Eingaben und Ausgaben
|
||||
|
||||
<Tabs items={['Konfiguration', 'Variablen', 'Ergebnisse']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Schleifentyp</strong>: Wählen Sie zwischen 'for' oder 'forEach'
|
||||
</li>
|
||||
<li>
|
||||
<strong>Iterationen</strong>: Anzahl der Ausführungen (für for-Schleifen)
|
||||
</li>
|
||||
<li>
|
||||
<strong>Sammlung</strong>: Array oder Objekt zum Durchlaufen (für forEach-Schleifen)
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>loop.currentItem</strong>: Aktuell verarbeitetes Element
|
||||
</li>
|
||||
<li>
|
||||
<strong>loop.index</strong>: Aktuelle Iterationsnummer (0-basiert)
|
||||
</li>
|
||||
<li>
|
||||
<strong>loop.items</strong>: Vollständige Sammlung (forEach-Schleifen)
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>loop.results</strong>: Array aller Iterationsergebnisse
|
||||
</li>
|
||||
<li>
|
||||
<strong>Struktur</strong>: Ergebnisse behalten die Iterationsreihenfolge bei
|
||||
</li>
|
||||
<li>
|
||||
<strong>Zugriff</strong>: Verfügbar in Blöcken nach der Schleife
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Best Practices
|
||||
|
||||
- **Setzen Sie vernünftige Grenzen**: Halten Sie die Anzahl der Iterationen in einem vernünftigen Rahmen, um lange Ausführungszeiten zu vermeiden
|
||||
- **Verwenden Sie ForEach für Sammlungen**: Verwenden Sie ForEach statt For-Schleifen, wenn Sie Arrays oder Objekte verarbeiten
|
||||
- **Behandeln Sie Fehler angemessen**: Erwägen Sie, Fehlerbehandlung innerhalb von Schleifen einzubauen, um robuste Workflows zu gewährleisten
|
||||
231
apps/docs/content/docs/de/blocks/parallel.mdx
Normal file
231
apps/docs/content/docs/de/blocks/parallel.mdx
Normal file
@@ -0,0 +1,231 @@
|
||||
---
|
||||
title: Parallel
|
||||
---
|
||||
|
||||
import { Callout } from 'fumadocs-ui/components/callout'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Image } from '@/components/ui/image'
|
||||
|
||||
Der Parallel-Block ist ein Container-Block in Sim, der es ermöglicht, mehrere Instanzen von Blöcken gleichzeitig auszuführen, um Workflows schneller zu verarbeiten.
|
||||
|
||||
Der Parallel-Block unterstützt zwei Arten der gleichzeitigen Ausführung:
|
||||
|
||||
<Callout type="info">
|
||||
Parallel-Blöcke sind Container-Knoten, die ihre Inhalte mehrfach gleichzeitig ausführen, im Gegensatz zu Schleifen, die sequentiell ausgeführt werden.
|
||||
</Callout>
|
||||
|
||||
## Überblick
|
||||
|
||||
Der Parallel-Block ermöglicht es dir:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Arbeit zu verteilen</strong>: Mehrere Elemente gleichzeitig zu verarbeiten
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Ausführung zu beschleunigen</strong>: Unabhängige Operationen gleichzeitig auszuführen
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Massenoperationen zu bewältigen</strong>: Große Datensätze effizient zu verarbeiten
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Ergebnisse zu aggregieren</strong>: Ausgaben aus allen parallelen Ausführungen zu sammeln
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Konfigurationsoptionen
|
||||
|
||||
### Parallel-Typ
|
||||
|
||||
Wähle zwischen zwei Arten der parallelen Ausführung:
|
||||
|
||||
<Tabs items={['Count-based', 'Collection-based']}>
|
||||
<Tab>
|
||||
**Anzahlbasierte Parallelität** - Führe eine feste Anzahl paralleler Instanzen aus:
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/parallel-1.png"
|
||||
alt="Anzahlbasierte parallele Ausführung"
|
||||
width={500}
|
||||
height={400}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
Verwende dies, wenn du dieselbe Operation mehrmals gleichzeitig ausführen musst.
|
||||
|
||||
|
||||
```
|
||||
Example: Run 5 parallel instances
|
||||
- Instance 1 ┐
|
||||
- Instance 2 ├─ All execute simultaneously
|
||||
- Instance 3 │
|
||||
- Instance 4 │
|
||||
- Instance 5 ┘
|
||||
```
|
||||
|
||||
</Tab>
|
||||
<Tab>
|
||||
**Sammlungsbasierte Parallelität** - Verteile eine Sammlung auf parallele Instanzen:
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/parallel-2.png"
|
||||
alt="Sammlungsbasierte parallele Ausführung"
|
||||
width={500}
|
||||
height={400}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
Jede Instanz verarbeitet gleichzeitig ein Element aus der Sammlung.
|
||||
|
||||
|
||||
```
|
||||
Example: Process ["task1", "task2", "task3"] in parallel
|
||||
- Instance 1: Process "task1" ┐
|
||||
- Instance 2: Process "task2" ├─ All execute simultaneously
|
||||
- Instance 3: Process "task3" ┘
|
||||
```
|
||||
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Wie man Parallel-Blöcke verwendet
|
||||
|
||||
### Einen Parallel-Block erstellen
|
||||
|
||||
1. Ziehe einen Parallel-Block aus der Werkzeugleiste auf deine Leinwand
|
||||
2. Konfiguriere den Parallel-Typ und die Parameter
|
||||
3. Ziehe einen einzelnen Block in den Parallel-Container
|
||||
4. Verbinde den Block nach Bedarf
|
||||
|
||||
### Auf Ergebnisse zugreifen
|
||||
|
||||
Nach Abschluss eines parallelen Blocks können Sie auf aggregierte Ergebnisse zugreifen:
|
||||
|
||||
- **`<parallel.results>`**: Array mit Ergebnissen aus allen parallelen Instanzen
|
||||
|
||||
## Beispielanwendungsfälle
|
||||
|
||||
### Batch-API-Verarbeitung
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Mehrere API-Aufrufe gleichzeitig verarbeiten</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Paralleler Block mit einer Sammlung von API-Endpunkten</li>
|
||||
<li>Innerhalb des parallelen Blocks: API-Block ruft jeden Endpunkt auf</li>
|
||||
<li>Nach dem parallelen Block: Alle Antworten gemeinsam verarbeiten</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Multi-Modell-KI-Verarbeitung
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Antworten von mehreren KI-Modellen erhalten</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Sammlungsbasierte Parallelverarbeitung über eine Liste von Modell-IDs (z.B. ["gpt-4o", "claude-3.7-sonnet", "gemini-2.5-pro"])</li>
|
||||
<li>Innerhalb des parallelen Blocks: Das Modell des Agenten wird auf das aktuelle Element aus der Sammlung gesetzt</li>
|
||||
<li>Nach dem parallelen Block: Vergleichen und Auswählen der besten Antwort</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
## Erweiterte Funktionen
|
||||
|
||||
### Ergebnisaggregation
|
||||
|
||||
Ergebnisse aus allen parallelen Instanzen werden automatisch gesammelt:
|
||||
|
||||
```javascript
|
||||
// In a Function block after the parallel
|
||||
const allResults = input.parallel.results;
|
||||
// Returns: [result1, result2, result3, ...]
|
||||
```
|
||||
|
||||
### Instanzisolierung
|
||||
|
||||
Jede parallele Instanz läuft unabhängig:
|
||||
- Separate Variablenbereiche
|
||||
- Kein gemeinsamer Zustand zwischen Instanzen
|
||||
- Fehler in einer Instanz beeinflussen andere nicht
|
||||
|
||||
### Einschränkungen
|
||||
|
||||
<Callout type="warning">
|
||||
Container-Blöcke (Schleifen und Parallele) können nicht ineinander verschachtelt werden. Das bedeutet:
|
||||
- Sie können keinen Schleifenblock in einen parallelen Block platzieren
|
||||
- Sie können keinen weiteren parallelen Block in einen parallelen Block platzieren
|
||||
- Sie können keinen Container-Block in einen anderen Container-Block platzieren
|
||||
</Callout>
|
||||
|
||||
<Callout type="warning">
|
||||
Parallele Blöcke können nur einen einzigen Block enthalten. Sie können nicht mehrere Blöcke haben, die innerhalb eines parallelen Blocks miteinander verbunden sind - in diesem Fall würde nur der erste Block ausgeführt werden.
|
||||
</Callout>
|
||||
|
||||
<Callout type="info">
|
||||
Obwohl die parallele Ausführung schneller ist, sollten Sie Folgendes beachten:
|
||||
- API-Ratenbegrenzungen bei gleichzeitigen Anfragen
|
||||
- Speichernutzung bei großen Datensätzen
|
||||
- Maximum von 20 gleichzeitigen Instanzen, um Ressourcenerschöpfung zu vermeiden
|
||||
</Callout>
|
||||
|
||||
## Parallel vs. Loop
|
||||
|
||||
Verstehen, wann was zu verwenden ist:
|
||||
|
||||
| Funktion | Parallel | Loop |
|
||||
|---------|----------|------|
|
||||
| Ausführung | Gleichzeitig | Sequentiell |
|
||||
| Geschwindigkeit | Schneller für unabhängige Operationen | Langsamer, aber geordnet |
|
||||
| Reihenfolge | Keine garantierte Reihenfolge | Behält Reihenfolge bei |
|
||||
| Anwendungsfall | Unabhängige Operationen | Abhängige Operationen |
|
||||
| Ressourcennutzung | Höher | Niedriger |
|
||||
|
||||
## Eingaben und Ausgaben
|
||||
|
||||
<Tabs items={['Konfiguration', 'Variablen', 'Ergebnisse']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Parallel-Typ</strong>: Wählen Sie zwischen 'count' oder 'collection'
|
||||
</li>
|
||||
<li>
|
||||
<strong>Count</strong>: Anzahl der auszuführenden Instanzen (anzahlbasiert)
|
||||
</li>
|
||||
<li>
|
||||
<strong>Collection</strong>: Array oder Objekt zur Verteilung (sammlungsbasiert)
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>parallel.currentItem</strong>: Element für diese Instanz
|
||||
</li>
|
||||
<li>
|
||||
<strong>parallel.index</strong>: Instanznummer (0-basiert)
|
||||
</li>
|
||||
<li>
|
||||
<strong>parallel.items</strong>: Vollständige Sammlung (sammlungsbasiert)
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>parallel.results</strong>: Array aller Instanzergebnisse
|
||||
</li>
|
||||
<li>
|
||||
<strong>Access</strong>: Verfügbar in Blöcken nach dem Parallel
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Best Practices
|
||||
|
||||
- **Nur unabhängige Operationen**: Stellen Sie sicher, dass Operationen nicht voneinander abhängen
|
||||
- **Rate-Limits berücksichtigen**: Fügen Sie Verzögerungen oder Drosselungen für API-intensive Workflows hinzu
|
||||
- **Fehlerbehandlung**: Jede Instanz sollte ihre eigenen Fehler angemessen behandeln
|
||||
246
apps/docs/content/docs/de/blocks/response.mdx
Normal file
246
apps/docs/content/docs/de/blocks/response.mdx
Normal file
@@ -0,0 +1,246 @@
|
||||
---
|
||||
title: Antwort
|
||||
---
|
||||
|
||||
import { Callout } from 'fumadocs-ui/components/callout'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Image } from '@/components/ui/image'
|
||||
|
||||
Der Antwort-Block ist der letzte Schritt in deinem Workflow, der eine strukturierte Antwort formatiert und an API-Aufrufe zurücksendet. Er funktioniert wie eine "return"-Anweisung für deinen gesamten Workflow – er verpackt Ergebnisse und sendet sie zurück.
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/response.png"
|
||||
alt="Konfiguration des Antwort-Blocks"
|
||||
width={500}
|
||||
height={400}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
<Callout type="info">
|
||||
Antwort-Blöcke sind terminale Blöcke - sie beenden die Workflow-Ausführung und können nicht mit anderen Blöcken verbunden werden.
|
||||
</Callout>
|
||||
|
||||
## Überblick
|
||||
|
||||
Der Antwort-Block ermöglicht dir:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>API-Antworten formatieren</strong>: Strukturierung von Workflow-Ergebnissen in korrekte HTTP-Antworten
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Statuscodes festlegen</strong>: Konfiguration passender HTTP-Statuscodes basierend auf Workflow-Ergebnissen
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Header kontrollieren</strong>: Hinzufügen benutzerdefinierter Header für API-Antworten und Webhooks
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Daten transformieren</strong>: Umwandlung von Workflow-Variablen in client-freundliche Antwortformate
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Wie es funktioniert
|
||||
|
||||
Der Antwort-Block schließt die Workflow-Ausführung ab:
|
||||
|
||||
1. **Daten sammeln** - Sammelt Variablen und Ausgaben von vorherigen Blöcken
|
||||
2. **Antwort formatieren** - Strukturiert Daten gemäß deiner Konfiguration
|
||||
3. **HTTP-Details festlegen** - Wendet Statuscodes und Header an
|
||||
4. **Antwort senden** - Gibt die formatierte Antwort an den API-Aufrufer zurück
|
||||
|
||||
## Wann du Antwort-Blöcke benötigst
|
||||
|
||||
- **API-Endpunkte**: Wenn dein Workflow über eine API aufgerufen wird, formatieren Antwort-Blöcke die Rückgabedaten
|
||||
- **Webhooks**: Rückgabe von Bestätigungen oder Daten an das aufrufende System
|
||||
- **Testen**: Anzeige formatierter Ergebnisse beim Testen deines Workflows
|
||||
|
||||
## Zwei Möglichkeiten zum Erstellen von Antworten
|
||||
|
||||
### Builder-Modus (Empfohlen)
|
||||
Visuelle Oberfläche zum Erstellen der Antwortstruktur:
|
||||
- Felder per Drag-and-Drop einfügen
|
||||
- Einfache Referenzierung von Workflow-Variablen
|
||||
- Visuelle Vorschau der Antwortstruktur
|
||||
|
||||
### Editor-Modus (Fortgeschritten)
|
||||
JSON direkt schreiben:
|
||||
- Volle Kontrolle über das Antwortformat
|
||||
- Unterstützung für komplexe verschachtelte Strukturen
|
||||
- Verwendung der `<variable.name>`Syntax für dynamische Werte
|
||||
|
||||
## Konfigurationsoptionen
|
||||
|
||||
### Antwortdaten
|
||||
|
||||
Die Antwortdaten sind der Hauptinhalt, der an den API-Aufrufer zurückgesendet wird. Diese sollten als JSON formatiert sein und können Folgendes enthalten:
|
||||
|
||||
- Statische Werte
|
||||
- Dynamische Verweise auf Workflow-Variablen mit der `<variable.name>`Syntax
|
||||
- Verschachtelte Objekte und Arrays
|
||||
- Jede gültige JSON-Struktur
|
||||
|
||||
### Statuscode
|
||||
|
||||
Legen Sie den HTTP-Statuscode für die Antwort fest. Häufige Statuscodes sind:
|
||||
|
||||
<Tabs items={['Erfolg (2xx)', 'Client-Fehler (4xx)', 'Server-Fehler (5xx)']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li><strong>200</strong>: OK - Standard-Erfolgsantwort</li>
|
||||
<li><strong>201</strong>: Erstellt - Ressource erfolgreich erstellt</li>
|
||||
<li><strong>204</strong>: Kein Inhalt - Erfolg ohne Antworttext</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li><strong>400</strong>: Ungültige Anfrage - Ungültige Anfrageparameter</li>
|
||||
<li><strong>401</strong>: Nicht autorisiert - Authentifizierung erforderlich</li>
|
||||
<li><strong>404</strong>: Nicht gefunden - Ressource existiert nicht</li>
|
||||
<li><strong>422</strong>: Nicht verarbeitbare Entität - Validierungsfehler</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li><strong>500</strong>: Interner Serverfehler - Serverseitiger Fehler</li>
|
||||
<li><strong>502</strong>: Bad Gateway - Fehler eines externen Dienstes</li>
|
||||
<li><strong>503</strong>: Dienst nicht verfügbar - Dienst vorübergehend nicht erreichbar</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
<div className="mt-4 text-sm text-gray-600 dark:text-gray-400">
|
||||
Der Standard-Statuscode ist 200, wenn nicht anders angegeben.
|
||||
</div>
|
||||
|
||||
### Antwort-Header
|
||||
|
||||
Konfigurieren Sie zusätzliche HTTP-Header, die in die Antwort aufgenommen werden sollen.
|
||||
|
||||
Header werden als Schlüssel-Wert-Paare konfiguriert:
|
||||
|
||||
| Schlüssel | Wert |
|
||||
|-----|-------|
|
||||
| Content-Type | application/json |
|
||||
| Cache-Control | no-cache |
|
||||
| X-API-Version | 1.0 |
|
||||
|
||||
## Beispielanwendungsfälle
|
||||
|
||||
### API-Endpunkt-Antwort
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Strukturierte Daten von einer Such-API zurückgeben</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Workflow verarbeitet Suchanfrage und ruft Ergebnisse ab</li>
|
||||
<li>Funktionsblock formatiert und paginiert Ergebnisse</li>
|
||||
<li>Antwortblock gibt JSON mit Daten, Paginierung und Metadaten zurück</li>
|
||||
<li>Client erhält strukturierte Antwort mit Status 200</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Webhook-Bestätigung
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Bestätigung des Webhook-Empfangs und der Verarbeitung</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Webhook-Trigger empfängt Daten vom externen System</li>
|
||||
<li>Workflow verarbeitet die eingehenden Daten</li>
|
||||
<li>Antwortblock gibt Bestätigung mit Verarbeitungsstatus zurück</li>
|
||||
<li>Externes System erhält Bestätigung</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Fehlerantwort-Behandlung
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Angemessene Fehlerantworten zurückgeben</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Bedingungsblock erkennt Validierungsfehler oder Systemfehler</li>
|
||||
<li>Router leitet zum Fehlerbehandlungspfad weiter</li>
|
||||
<li>Antwortblock gibt Status 400/500 mit Fehlerdetails zurück</li>
|
||||
<li>Client erhält strukturierte Fehlerinformationen</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
## Eingaben und Ausgaben
|
||||
|
||||
<Tabs items={['Konfiguration', 'Variablen', 'Ergebnisse']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Antwortdaten</strong>: JSON-Struktur für den Antworttext
|
||||
</li>
|
||||
<li>
|
||||
<strong>Statuscode</strong>: HTTP-Statuscode (Standard: 200)
|
||||
</li>
|
||||
<li>
|
||||
<strong>Header</strong>: Benutzerdefinierte HTTP-Header als Schlüssel-Wert-Paare
|
||||
</li>
|
||||
<li>
|
||||
<strong>Modus</strong>: Builder- oder Editor-Modus für die Antworterstellung
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>response.data</strong>: Der strukturierte Antworttext
|
||||
</li>
|
||||
<li>
|
||||
<strong>response.status</strong>: Gesendeter HTTP-Statuscode
|
||||
</li>
|
||||
<li>
|
||||
<strong>response.headers</strong>: In der Antwort enthaltene Header
|
||||
</li>
|
||||
<li>
|
||||
<strong>response.success</strong>: Boolescher Wert, der erfolgreichen Abschluss anzeigt
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>HTTP-Antwort</strong>: Vollständige Antwort an den API-Aufrufer
|
||||
</li>
|
||||
<li>
|
||||
<strong>Workflow-Beendigung</strong>: Beendet die Workflow-Ausführung
|
||||
</li>
|
||||
<li>
|
||||
<strong>Zugriff</strong>: Antwortblöcke sind terminal - keine nachfolgenden Blöcke
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Variablenreferenzen
|
||||
|
||||
Verwenden Sie die `<variable.name>` Syntax, um Workflow-Variablen dynamisch in Ihre Antwort einzufügen:
|
||||
|
||||
```json
|
||||
{
|
||||
"user": {
|
||||
"id": "<variable.userId>",
|
||||
"name": "<variable.userName>",
|
||||
"email": "<variable.userEmail>"
|
||||
},
|
||||
"query": "<variable.searchQuery>",
|
||||
"results": "<variable.searchResults>",
|
||||
"totalFound": "<variable.resultCount>",
|
||||
"processingTime": "<variable.executionTime>ms"
|
||||
}
|
||||
```
|
||||
|
||||
<Callout type="warning">
|
||||
Variablennamen sind Groß- und Kleinschreibung sensitiv und müssen exakt mit den in Ihrem Workflow verfügbaren Variablen übereinstimmen.
|
||||
</Callout>
|
||||
|
||||
## Best Practices
|
||||
|
||||
- **Verwenden Sie aussagekräftige Statuscodes**: Wählen Sie passende HTTP-Statuscodes, die das Ergebnis des Workflows genau widerspiegeln
|
||||
- **Strukturieren Sie Ihre Antworten einheitlich**: Behalten Sie eine konsistente JSON-Struktur über alle API-Endpunkte hinweg für eine bessere Entwicklererfahrung bei
|
||||
- **Fügen Sie relevante Metadaten hinzu**: Ergänzen Sie Zeitstempel und Versionsinformationen, um bei der Fehlersuche und Überwachung zu helfen
|
||||
- **Behandeln Sie Fehler elegant**: Verwenden Sie bedingte Logik in Ihrem Workflow, um angemessene Fehlerantworten mit aussagekräftigen Meldungen zu setzen
|
||||
- **Validieren Sie Variablenreferenzen**: Stellen Sie sicher, dass alle referenzierten Variablen existieren und die erwarteten Datentypen enthalten, bevor der Response-Block ausgeführt wird
|
||||
225
apps/docs/content/docs/de/blocks/router.mdx
Normal file
225
apps/docs/content/docs/de/blocks/router.mdx
Normal file
@@ -0,0 +1,225 @@
|
||||
---
|
||||
title: Router
|
||||
---
|
||||
|
||||
import { Callout } from 'fumadocs-ui/components/callout'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Accordion, Accordions } from 'fumadocs-ui/components/accordion'
|
||||
import { Image } from '@/components/ui/image'
|
||||
import { Video } from '@/components/ui/video'
|
||||
|
||||
Der Router-Block nutzt KI, um intelligent zu entscheiden, welchen Pfad Ihr Workflow als nächstes nehmen sollte, indem er die Workflow-Ausführung basierend auf spezifischen Bedingungen oder Logik leitet. Im Gegensatz zu Bedingungsblöcken, die einfache Regeln verwenden, können Router-Blöcke den Kontext verstehen und intelligente Routing-Entscheidungen auf Basis von Inhaltsanalysen treffen.
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/router.png"
|
||||
alt="Router-Block mit mehreren Pfaden"
|
||||
width={500}
|
||||
height={400}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
## Überblick
|
||||
|
||||
Der Router-Block ermöglicht Ihnen:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Intelligentes Content-Routing</strong>: Nutzung von KI zum Verständnis von Absicht und Kontext
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Dynamische Pfadauswahl</strong>: Routing von Workflows basierend auf unstrukturierter Inhaltsanalyse
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Kontextbewusste Entscheidungen</strong>: Treffen intelligenter Routing-Entscheidungen über einfache Regeln hinaus
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Multi-Pfad-Management</strong>: Verwaltung komplexer Workflows mit mehreren potenziellen Zielen
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Router vs. Bedingungsblöcke
|
||||
|
||||
<Accordions>
|
||||
<Accordion title="Wann Router verwenden">
|
||||
- KI-gestützte Inhaltsanalyse erforderlich
|
||||
- Unstrukturierte oder variierende Inhaltstypen
|
||||
- Absichtsbasiertes Routing (z.B. "Support-Tickets an Abteilungen weiterleiten")
|
||||
- Kontextbewusste Entscheidungsfindung erforderlich
|
||||
</Accordion>
|
||||
<Accordion title="Wann Bedingung verwenden">
|
||||
- Einfache, regelbasierte Entscheidungen
|
||||
- Strukturierte Daten oder numerische Vergleiche
|
||||
- Schnelles, deterministisches Routing erforderlich
|
||||
- Boolesche Logik ausreichend
|
||||
</Accordion>
|
||||
</Accordions>
|
||||
|
||||
## Funktionsweise
|
||||
|
||||
Der Router-Block:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Analysiert Inhalte</strong>: Verwendet ein LLM, um Eingabeinhalte und Kontext zu verstehen
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Bewertet Ziele</strong>: Vergleicht Inhalte mit verfügbaren Zielblöcken
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Wählt Ziel aus</strong>: Identifiziert den am besten geeigneten Pfad basierend auf der Absicht
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Leitet Ausführung</strong>: Dirigiert den Workflow zum ausgewählten Block
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Konfigurationsoptionen
|
||||
|
||||
### Inhalt/Prompt
|
||||
|
||||
Der Inhalt oder Prompt, den der Router analysiert, um Routing-Entscheidungen zu treffen. Dies kann sein:
|
||||
|
||||
- Eine direkte Benutzeranfrage oder -eingabe
|
||||
- Ausgabe aus einem vorherigen Block
|
||||
- Eine vom System generierte Nachricht
|
||||
|
||||
### Zielblöcke
|
||||
|
||||
Die möglichen Zielblöcke, aus denen der Router auswählen kann. Der Router erkennt automatisch verbundene Blöcke, aber Sie können auch:
|
||||
|
||||
- Die Beschreibungen der Zielblöcke anpassen, um die Routing-Genauigkeit zu verbessern
|
||||
- Routing-Kriterien für jeden Zielblock festlegen
|
||||
- Bestimmte Blöcke von der Berücksichtigung als Routing-Ziele ausschließen
|
||||
|
||||
### Modellauswahl
|
||||
|
||||
Wählen Sie ein KI-Modell für die Routing-Entscheidung:
|
||||
|
||||
**OpenAI**: GPT-4o, o1, o3, o4-mini, gpt-4.1 \
|
||||
**Anthropic**: Claude 3.7 Sonnet \
|
||||
**Google**: Gemini 2.5 Pro, Gemini 2.0 Flash \
|
||||
**Andere Anbieter**: Groq, Cerebras, xAI, DeepSeek \
|
||||
**Lokale Modelle**: Jedes Modell, das auf Ollama läuft
|
||||
|
||||
<div className="w-full max-w-2xl mx-auto overflow-hidden rounded-lg">
|
||||
<Video src="router-model-dropdown.mp4" width={500} height={350} />
|
||||
</div>
|
||||
|
||||
**Empfehlung**: Verwenden Sie Modelle mit starken Reasoning-Fähigkeiten wie GPT-4o oder Claude 3.7 Sonnet für genauere Routing-Entscheidungen.
|
||||
|
||||
### API-Schlüssel
|
||||
|
||||
Ihr API-Schlüssel für den ausgewählten LLM-Anbieter. Dieser wird sicher gespeichert und für die Authentifizierung verwendet.
|
||||
|
||||
### Zugriff auf Ergebnisse
|
||||
|
||||
Nachdem ein Router eine Entscheidung getroffen hat, können Sie auf seine Ausgaben zugreifen:
|
||||
|
||||
- **`<router.prompt>`**: Zusammenfassung des verwendeten Routing-Prompts
|
||||
- **`<router.selected_path>`**: Details zum ausgewählten Zielblock
|
||||
- **`<router.tokens>`**: Token-Nutzungsstatistiken vom LLM
|
||||
- **`<router.cost>`**: Kostenübersicht für den Routing-Aufruf (Eingabe, Ausgabe, Gesamt)
|
||||
- **`<router.model>`**: Das für die Entscheidungsfindung verwendete Modell
|
||||
|
||||
## Erweiterte Funktionen
|
||||
|
||||
### Benutzerdefinierte Routing-Kriterien
|
||||
|
||||
Definieren Sie spezifische Kriterien für jeden Zielblock:
|
||||
|
||||
```javascript
|
||||
// Example routing descriptions
|
||||
Target Block 1: "Technical support issues, API problems, integration questions"
|
||||
Target Block 2: "Billing inquiries, subscription changes, payment issues"
|
||||
Target Block 3: "General questions, feedback, feature requests"
|
||||
```
|
||||
|
||||
## Eingaben und Ausgaben
|
||||
|
||||
<Tabs items={['Konfiguration', 'Variablen']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Inhalt/Prompt</strong>: Zu analysierender Text für Routing-Entscheidungen
|
||||
</li>
|
||||
<li>
|
||||
<strong>Zielblöcke</strong>: Verbundene Blöcke als potenzielle Ziele
|
||||
</li>
|
||||
<li>
|
||||
<strong>Modell</strong>: KI-Modell für Routing-Analyse
|
||||
</li>
|
||||
<li>
|
||||
<strong>API-Schlüssel</strong>: Authentifizierung für ausgewählten LLM-Anbieter
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>router.prompt</strong>: Zusammenfassung des verwendeten Routing-Prompts
|
||||
</li>
|
||||
<li>
|
||||
<strong>router.selected_path</strong>: Details zum gewählten Ziel
|
||||
</li>
|
||||
<li>
|
||||
<strong>router.tokens</strong>: Token-Nutzungsstatistiken
|
||||
</li>
|
||||
<li>
|
||||
<strong>router.cost</strong>: Kostenübersicht für den Routing-Aufruf (Eingabe, Ausgabe, Gesamt)
|
||||
</li>
|
||||
<li>
|
||||
<strong>router.model</strong>: Für die Entscheidungsfindung verwendetes Modell
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Beispielanwendungsfälle
|
||||
|
||||
### Kundensupport-Triage
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Support-Tickets an spezialisierte Abteilungen weiterleiten</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Benutzer reicht Supportanfrage über Formular ein</li>
|
||||
<li>Router analysiert Ticket-Inhalt und Kontext</li>
|
||||
<li>Technische Probleme → Engineering-Support-Mitarbeiter</li>
|
||||
<li>Abrechnungsfragen → Finanz-Support-Mitarbeiter</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Inhaltsklassifizierung
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Benutzergenerierte Inhalte klassifizieren und weiterleiten</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Benutzer reicht Inhalt oder Feedback ein</li>
|
||||
<li>Router analysiert Inhaltstyp und Stimmung</li>
|
||||
<li>Feature-Anfragen → Produkt-Team-Workflow</li>
|
||||
<li>Fehlerberichte → Technischer Support-Workflow</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Lead-Qualifizierung
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Leads basierend auf Qualifizierungskriterien weiterleiten</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Lead-Informationen aus Formular erfasst</li>
|
||||
<li>Router analysiert Unternehmensgröße, Branche und Bedürfnisse</li>
|
||||
<li>Enterprise-Leads → Vertriebsteam mit individueller Preisgestaltung</li>
|
||||
<li>KMU-Leads → Self-Service-Onboarding-Prozess</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
## Best Practices
|
||||
|
||||
- **Klare Zielbeschreibungen bereitstellen**: Helfen Sie dem Router zu verstehen, wann jedes Ziel mit spezifischen, detaillierten Beschreibungen ausgewählt werden soll
|
||||
- **Spezifische Routing-Kriterien verwenden**: Definieren Sie klare Bedingungen und Beispiele für jeden Pfad, um die Genauigkeit zu verbessern
|
||||
- **Fallback-Pfade implementieren**: Verbinden Sie ein Standardziel für Fälle, in denen kein spezifischer Pfad geeignet ist
|
||||
- **Mit verschiedenen Eingaben testen**: Stellen Sie sicher, dass der Router verschiedene Eingabetypen, Grenzfälle und unerwartete Inhalte verarbeiten kann
|
||||
- **Routing-Leistung überwachen**: Überprüfen Sie Routing-Entscheidungen regelmäßig und verfeinern Sie Kriterien basierend auf tatsächlichen Nutzungsmustern
|
||||
- **Geeignete Modelle auswählen**: Verwenden Sie Modelle mit starken Argumentationsfähigkeiten für komplexe Routing-Entscheidungen
|
||||
168
apps/docs/content/docs/de/blocks/workflow.mdx
Normal file
168
apps/docs/content/docs/de/blocks/workflow.mdx
Normal file
@@ -0,0 +1,168 @@
|
||||
---
|
||||
title: Workflow
|
||||
---
|
||||
|
||||
import { Callout } from 'fumadocs-ui/components/callout'
|
||||
import { Step, Steps } from 'fumadocs-ui/components/steps'
|
||||
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
|
||||
import { Image } from '@/components/ui/image'
|
||||
|
||||
Der Workflow-Block ermöglicht es, andere Workflows als wiederverwendbare Komponenten innerhalb deines aktuellen Workflows auszuführen. Dies ermöglicht modulares Design, Codewiederverwendung und die Erstellung komplexer verschachtelter Workflows, die aus kleineren, fokussierten Workflows zusammengesetzt werden können.
|
||||
|
||||
<div className="flex justify-center">
|
||||
<Image
|
||||
src="/static/blocks/workflow.png"
|
||||
alt="Workflow-Block"
|
||||
width={500}
|
||||
height={350}
|
||||
className="my-6"
|
||||
/>
|
||||
</div>
|
||||
|
||||
<Callout type="info">
|
||||
Workflow-Blöcke ermöglichen modulares Design, indem sie es erlauben, komplexe Workflows aus kleineren, wiederverwendbaren Komponenten zusammenzusetzen.
|
||||
</Callout>
|
||||
|
||||
## Überblick
|
||||
|
||||
Der Workflow-Block dient als Brücke zwischen Workflows und ermöglicht es dir:
|
||||
|
||||
<Steps>
|
||||
<Step>
|
||||
<strong>Bestehende Workflows wiederzuverwenden</strong>: Führe zuvor erstellte Workflows als Komponenten innerhalb neuer Workflows aus
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Modulare Designs zu erstellen</strong>: Zerlege komplexe Prozesse in kleinere, überschaubare Workflows
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Trennung der Zuständigkeiten beizubehalten</strong>: Halte verschiedene Geschäftslogik in separaten Workflows isoliert
|
||||
</Step>
|
||||
<Step>
|
||||
<strong>Teamzusammenarbeit zu ermöglichen</strong>: Teile und verwende Workflows über verschiedene Projekte und Teammitglieder hinweg wieder
|
||||
</Step>
|
||||
</Steps>
|
||||
|
||||
## Funktionsweise
|
||||
|
||||
Der Workflow-Block:
|
||||
|
||||
1. Nimmt eine Referenz zu einem anderen Workflow in deinem Workspace
|
||||
2. Übergibt Eingabedaten vom aktuellen Workflow an den untergeordneten Workflow (verfügbar über start.input)
|
||||
3. Führt den untergeordneten Workflow in einem isolierten Kontext aus
|
||||
4. Gibt das Ergebnis zur weiteren Verarbeitung an den übergeordneten Workflow zurück
|
||||
|
||||
## Konfigurationsoptionen
|
||||
|
||||
### Workflow-Auswahl
|
||||
|
||||
Wähle aus einer Dropdown-Liste der verfügbaren Workflows in deinem Workspace aus, welcher Workflow ausgeführt werden soll. Die Liste umfasst:
|
||||
|
||||
- Alle Workflows, auf die du im aktuellen Workspace Zugriff hast
|
||||
- Workflows, die von anderen Teammitgliedern mit dir geteilt wurden
|
||||
- Sowohl aktivierte als auch deaktivierte Workflows (obwohl nur aktivierte Workflows ausgeführt werden können)
|
||||
|
||||
### Ausführungskontext
|
||||
|
||||
Der untergeordnete Workflow wird ausgeführt mit:
|
||||
|
||||
- Seinem eigenen isolierten Ausführungskontext
|
||||
- Zugriff auf dieselben Workspace-Ressourcen (API-Schlüssel, Umgebungsvariablen)
|
||||
- Korrekten Workspace-Mitgliedschafts- und Berechtigungsprüfungen
|
||||
- Verschachteltem Tracespan im Ausführungsprotokoll
|
||||
|
||||
<Callout type="warning">
|
||||
**Zykluserkennung**: Das System erkennt und verhindert automatisch zirkuläre Abhängigkeiten zwischen Workflows, um Endlosschleifen zu vermeiden.
|
||||
</Callout>
|
||||
|
||||
## Eingaben und Ausgaben
|
||||
|
||||
<Tabs items={['Configuration', 'Variables', 'Results']}>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Workflow-Auswahl</strong>: Wählen Sie aus, welcher Workflow ausgeführt werden soll
|
||||
</li>
|
||||
<li>
|
||||
<strong>Eingabedaten</strong>: Variable oder Blockreferenz, die an den untergeordneten Workflow übergeben wird
|
||||
</li>
|
||||
<li>
|
||||
<strong>Ausführungskontext</strong>: Isolierte Umgebung mit Workspace-Ressourcen
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>workflow.success</strong>: Boolescher Wert, der den Abschlussstatus angibt
|
||||
</li>
|
||||
<li>
|
||||
<strong>workflow.childWorkflowName</strong>: Name des ausgeführten untergeordneten Workflows
|
||||
</li>
|
||||
<li>
|
||||
<strong>workflow.result</strong>: Vom untergeordneten Workflow zurückgegebenes Ergebnis
|
||||
</li>
|
||||
<li>
|
||||
<strong>workflow.error</strong>: Fehlerdetails, falls der Workflow fehlgeschlagen ist
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
<Tab>
|
||||
<ul className="list-disc space-y-2 pl-6">
|
||||
<li>
|
||||
<strong>Workflow-Antwort</strong>: Primäre Ausgabe des untergeordneten Workflows
|
||||
</li>
|
||||
<li>
|
||||
<strong>Ausführungsstatus</strong>: Erfolgsstatus und Fehlerinformationen
|
||||
</li>
|
||||
<li>
|
||||
<strong>Zugriff</strong>: Verfügbar in Blöcken nach dem Workflow
|
||||
</li>
|
||||
</ul>
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Beispielanwendungsfälle
|
||||
|
||||
### Modulares Kunden-Onboarding
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Komplexes Onboarding in wiederverwendbare Komponenten aufteilen</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Hauptworkflow empfängt Kundendaten</li>
|
||||
<li>Workflow-Block führt Validierungs-Workflow aus</li>
|
||||
<li>Workflow-Block führt Kontoeinrichtungs-Workflow aus</li>
|
||||
<li>Workflow-Block führt Willkommens-E-Mail-Workflow aus</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Microservice-Architektur
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Unabhängige Service-Workflows erstellen</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Zahlungsabwicklungs-Workflow verarbeitet Transaktionen</li>
|
||||
<li>Bestandsverwaltungs-Workflow aktualisiert den Lagerbestand</li>
|
||||
<li>Benachrichtigungs-Workflow sendet Bestätigungen</li>
|
||||
<li>Hauptworkflow orchestriert alle Dienste</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
### Bedingte Verarbeitung
|
||||
|
||||
<div className="mb-4 rounded-md border p-4">
|
||||
<h4 className="font-medium">Szenario: Führe verschiedene Workflows basierend auf Bedingungen aus</h4>
|
||||
<ol className="list-decimal pl-5 text-sm">
|
||||
<li>Bedingungsblock bewertet den Benutzertyp</li>
|
||||
<li>Enterprise-Benutzer → Komplexer Genehmigungsworkflow</li>
|
||||
<li>Standard-Benutzer → Einfacher Genehmigungsworkflow</li>
|
||||
<li>Kostenlose Benutzer → Grundlegender Verarbeitungsworkflow</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
## Bewährte Praktiken
|
||||
|
||||
- **Workflows fokussiert halten**: Gestalte untergeordnete Workflows für spezifische, klar definierte Aufgaben mit eindeutigen Ein- und Ausgaben
|
||||
- **Verschachtelungstiefe minimieren**: Vermeide tief verschachtelte Workflow-Hierarchien für bessere Wartbarkeit und Leistung
|
||||
- **Fehler elegant behandeln**: Implementiere eine ordnungsgemäße Fehlerbehandlung für Fehler in untergeordneten Workflows und stelle Fallback-Mechanismen bereit
|
||||
- **Unabhängig testen**: Stelle sicher, dass untergeordnete Workflows unabhängig von übergeordneten Workflows getestet und validiert werden können
|
||||
- **Semantische Benennung verwenden**: Gib Workflows beschreibende Namen, die ihren Zweck und ihre Funktionalität klar angeben
|
||||
Reference in New Issue
Block a user