v0.5.40: supabase ops to allow non-public schemas, jira uuid

* added uuid param

* revmoed comment

* fixed naming

.cursor/rules/emcn-components.mdc

@@ -0,0 +1,45 @@
+---
+description: EMCN component library patterns with CVA
+globs: ["apps/sim/components/emcn/**"]
+---
+
+# EMCN Component Guidelines
+
+## When to Use CVA vs Direct Styles
+
+**Use CVA (class-variance-authority) when:**
+- 2+ visual variants (primary, secondary, outline)
+- Multiple sizes or state variations
+- Example: Button with variants
+
+**Use direct className when:**
+- Single consistent style
+- No variations needed
+- Example: Label with one style
+
+## Patterns
+
+**With CVA:**
+```tsx
+const buttonVariants = cva('base-classes', {
+  variants: { 
+    variant: { default: '...', primary: '...' },
+    size: { sm: '...', md: '...' }
+  }
+})
+export { Button, buttonVariants }
+```
+
+**Without CVA:**
+```tsx
+function Label({ className, ...props }) {
+  return <Primitive className={cn('single-style-classes', className)} {...props} />
+}
+```
+
+## Rules
+- Use Radix UI primitives for accessibility
+- Export component and variants (if using CVA)
+- TSDoc with usage examples
+- Consistent tokens: `font-medium`, `text-[12px]`, `rounded-[4px]`
+- Always use `transition-colors` for hover states

.cursor/rules/global.mdc

@@ -0,0 +1,20 @@
+---
+description: Global coding standards that apply to all files
+alwaysApply: true
+---
+
+# Global Standards
+
+You are a professional software engineer. All code must follow best practices: accurate, readable, clean, and efficient.
+
+## Logging
+Use `logger.info`, `logger.warn`, `logger.error` instead of `console.log`.
+
+## Comments
+Use TSDoc for documentation. No `====` separators. No non-TSDoc comments.
+
+## Styling
+Never update global styles. Keep all styling local to components.
+
+## Package Manager
+Use `bun` and `bunx`, not `npm` and `npx`.

.cursor/rules/sim-architecture.mdc

@@ -0,0 +1,67 @@
+---
+description: Core architecture principles for the Sim app
+globs: ["apps/sim/**"]
+---
+
+# Sim App Architecture
+
+## Core Principles
+1. **Single Responsibility**: Each component, hook, store has one clear purpose
+2. **Composition Over Complexity**: Break down complex logic into smaller pieces
+3. **Type Safety First**: TypeScript interfaces for all props, state, return types
+4. **Predictable State**: Zustand for global state, useState for UI-only concerns
+5. **Performance by Default**: useMemo, useCallback, refs appropriately
+
+## File Organization
+
+```
+feature/
+├── components/        # Feature components
+│   └── sub-feature/   # Sub-feature with own components
+├── hooks/             # Custom hooks
+└── feature.tsx        # Main component
+```
+
+## Naming Conventions
+- **Components**: PascalCase (`WorkflowList`, `TriggerPanel`)
+- **Hooks**: camelCase with `use` prefix (`useWorkflowOperations`)
+- **Files**: kebab-case matching export (`workflow-list.tsx`)
+- **Stores**: kebab-case in stores/ (`sidebar/store.ts`)
+- **Constants**: SCREAMING_SNAKE_CASE
+- **Interfaces**: PascalCase with suffix (`WorkflowListProps`)
+
+## State Management
+
+**useState**: UI-only concerns (dropdown open, hover, form inputs)
+**Zustand**: Shared state, persistence, global app state
+**useRef**: DOM refs, avoiding dependency issues, mutable non-reactive values
+
+## Component Extraction
+
+**Extract to separate file when:**
+- Complex (50+ lines)
+- Used across 2+ files
+- Has own state/logic
+
+**Keep inline when:**
+- Simple (< 10 lines)
+- Used in only 1 file
+- Purely presentational
+
+**Never import utilities from another component file.** Extract shared helpers to `lib/` or `utils/`.
+
+## Utils Files
+
+**Never create a `utils.ts` file for a single consumer.** Inline the logic directly in the consuming component.
+
+**Create `utils.ts` when:**
+- 2+ files import the same helper
+
+**Prefer existing sources of truth:**
+- Before duplicating logic, check if a centralized helper already exists (e.g., `lib/logs/get-trigger-options.ts`)
+- Import from the source of truth rather than creating wrapper functions
+
+**Location hierarchy:**
+- `lib/` — App-wide utilities (auth, billing, core)
+- `feature/utils.ts` — Feature-scoped utilities (used by 2+ components in the feature)
+- Inline — Single-use helpers (define directly in the component)

.cursor/rules/sim-components.mdc

@@ -0,0 +1,64 @@
+---
+description: Component patterns and structure for React components
+globs: ["apps/sim/**/*.tsx"]
+---
+
+# Component Patterns
+
+## Structure Order
+```typescript
+'use client' // Only if using hooks
+
+// 1. Imports (external → internal → relative)
+// 2. Constants at module level
+const CONFIG = { SPACING: 8 } as const
+
+// 3. Props interface with TSDoc
+interface ComponentProps {
+  /** Description */
+  requiredProp: string
+  optionalProp?: boolean
+}
+
+// 4. Component with TSDoc
+export function Component({ requiredProp, optionalProp = false }: ComponentProps) {
+  // a. Refs
+  // b. External hooks (useParams, useRouter)
+  // c. Store hooks
+  // d. Custom hooks
+  // e. Local state
+  // f. useMemo computations
+  // g. useCallback handlers
+  // h. useEffect
+  // i. Return JSX
+}
+```
+
+## Rules
+1. Add `'use client'` when using React hooks
+2. Always define props interface
+3. TSDoc on component: description, @param, @returns
+4. Extract constants with `as const`
+5. Use Tailwind only, no inline styles
+6. Semantic HTML (`aside`, `nav`, `article`)
+7. Include ARIA attributes where appropriate
+8. Optional chain callbacks: `onAction?.(id)`
+
+## Factory Pattern with Caching
+
+When generating components for a specific signature (e.g., icons):
+
+```typescript
+const cache = new Map<string, React.ComponentType<{ className?: string }>>()
+
+function getColorIcon(color: string) {
+  if (cache.has(color)) return cache.get(color)!
+  
+  const Icon = ({ className }: { className?: string }) => (
+    <div className={cn(className, 'rounded-[3px]')} style={{ backgroundColor: color, width: 10, height: 10 }} />
+  )
+  Icon.displayName = `ColorIcon(${color})`
+  cache.set(color, Icon)
+  return Icon
+}
+```

.cursor/rules/sim-hooks.mdc

@@ -0,0 +1,68 @@
+---
+description: Custom hook patterns and best practices
+globs: ["apps/sim/**/use-*.ts", "apps/sim/**/hooks/**/*.ts"]
+---
+
+# Hook Patterns
+
+## Structure
+```typescript
+import { createLogger } from '@/lib/logs/console/logger'
+
+const logger = createLogger('useFeatureName')
+
+interface UseFeatureProps {
+  id: string
+  onSuccess?: (result: Result) => void
+}
+
+/**
+ * Hook description.
+ * @param props - Configuration
+ * @returns State and operations
+ */
+export function useFeature({ id, onSuccess }: UseFeatureProps) {
+  // 1. Refs for stable dependencies
+  const idRef = useRef(id)
+  const onSuccessRef = useRef(onSuccess)
+
+  // 2. State
+  const [data, setData] = useState<Data | null>(null)
+  const [isLoading, setIsLoading] = useState(false)
+  const [error, setError] = useState<Error | null>(null)
+
+  // 3. Sync refs
+  useEffect(() => {
+    idRef.current = id
+    onSuccessRef.current = onSuccess
+  }, [id, onSuccess])
+
+  // 4. Operations with useCallback
+  const fetchData = useCallback(async () => {
+    setIsLoading(true)
+    try {
+      const result = await fetch(`/api/${idRef.current}`).then(r => r.json())
+      setData(result)
+      onSuccessRef.current?.(result)
+    } catch (err) {
+      setError(err as Error)
+      logger.error('Failed', { error: err })
+    } finally {
+      setIsLoading(false)
+    }
+  }, []) // Empty deps - using refs
+
+  // 5. Return grouped by state/operations
+  return { data, isLoading, error, fetchData }
+}
+```
+
+## Rules
+1. Single responsibility per hook
+2. Props interface required
+3. TSDoc required
+4. Use logger, not console.log
+5. Refs for stable callback dependencies
+6. Wrap returned functions in useCallback
+7. Always try/catch async operations
+8. Track loading/error states

.cursor/rules/sim-imports.mdc

@@ -0,0 +1,37 @@
+---
+description: Import patterns for the Sim application
+globs: ["apps/sim/**/*.ts", "apps/sim/**/*.tsx"]
+---
+
+# Import Patterns
+
+## EMCN Components
+Import from `@/components/emcn`, never from subpaths like `@/components/emcn/components/modal/modal`.
+
+**Exception**: CSS imports use actual file paths: `import '@/components/emcn/components/code/code.css'`
+
+## Feature Components
+Import from central folder indexes, not specific subfolders:
+```typescript
+// ✅ Correct
+import { Dashboard, Sidebar } from '@/app/workspace/[workspaceId]/logs/components'
+
+// ❌ Wrong
+import { Dashboard } from '@/app/workspace/[workspaceId]/logs/components/dashboard'
+```
+
+## Internal vs External
+- **Cross-feature**: Absolute paths through central index
+- **Within feature**: Relative paths (`./components/...`, `../utils`)
+
+## Import Order
+1. React/core libraries
+2. External libraries
+3. UI components (`@/components/emcn`, `@/components/ui`)
+4. Utilities (`@/lib/...`)
+5. Feature imports from indexes
+6. Relative imports
+7. CSS imports
+
+## Types
+Use `type` keyword: `import type { WorkflowLog } from '...'`

.cursor/rules/sim-stores.mdc

@@ -0,0 +1,57 @@
+---
+description: Zustand store patterns
+globs: ["apps/sim/**/store.ts", "apps/sim/**/stores/**/*.ts"]
+---
+
+# Zustand Store Patterns
+
+## Structure
+```typescript
+import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+
+interface FeatureState {
+  // State
+  items: Item[]
+  activeId: string | null
+  
+  // Actions
+  setItems: (items: Item[]) => void
+  addItem: (item: Item) => void
+  clearState: () => void
+}
+
+const createInitialState = () => ({
+  items: [],
+  activeId: null,
+})
+
+export const useFeatureStore = create<FeatureState>()(
+  persist(
+    (set) => ({
+      ...createInitialState(),
+
+      setItems: (items) => set({ items }),
+
+      addItem: (item) => set((state) => ({
+        items: [...state.items, item],
+      })),
+
+      clearState: () => set(createInitialState()),
+    }),
+    {
+      name: 'feature-state',
+      partialize: (state) => ({ items: state.items }),
+    }
+  )
+)
+```
+
+## Rules
+1. Interface includes state and actions
+2. Extract config to module constants
+3. TSDoc on store
+4. Only persist what's needed
+5. Immutable updates only - never mutate
+6. Use `set((state) => ...)` when depending on previous state
+7. Provide clear/reset actions

.cursor/rules/sim-styling.mdc

@@ -0,0 +1,47 @@
+---
+description: Tailwind CSS and styling conventions
+globs: ["apps/sim/**/*.tsx", "apps/sim/**/*.css"]
+---
+
+# Styling Rules
+
+## Tailwind
+1. **No inline styles** - Use Tailwind classes exclusively
+2. **No duplicate dark classes** - Don't add `dark:` when value matches light mode
+3. **Exact values** - Use design system values (`text-[14px]`, `h-[25px]`)
+4. **Prefer px** - Use `px-[4px]` over `px-1`
+5. **Transitions** - Add `transition-colors` for interactive states
+
+## Conditional Classes
+```typescript
+import { cn } from '@/lib/utils'
+
+<div className={cn(
+  'base-classes',
+  isActive && 'active-classes',
+  disabled ? 'opacity-60' : 'hover:bg-accent'
+)} />
+```
+
+## CSS Variables for Dynamic Styles
+```typescript
+// In store setter
+setSidebarWidth: (width) => {
+  set({ sidebarWidth: width })
+  document.documentElement.style.setProperty('--sidebar-width', `${width}px`)
+}
+
+// In component
+<aside style={{ width: 'var(--sidebar-width)' }} />
+```
+
+## Anti-Patterns
+```typescript
+// ❌ Bad
+<div style={{ width: 200 }}>
+<div className='text-[var(--text-primary)] dark:text-[var(--text-primary)]'>
+
+// ✅ Good
+<div className='w-[200px]'>
+<div className='text-[var(--text-primary)]'>
+```

.cursor/rules/sim-typescript.mdc

@@ -0,0 +1,24 @@
+---
+description: TypeScript conventions and type safety
+globs: ["apps/sim/**/*.ts", "apps/sim/**/*.tsx"]
+---
+
+# TypeScript Rules
+
+1. **No `any`** - Use proper types or `unknown` with type guards
+2. **Props interface** - Always define, even for simple components
+3. **Callback types** - Full signature with params and return type
+4. **Generics** - Use for reusable components/hooks
+5. **Const assertions** - `as const` for constant objects/arrays
+6. **Ref types** - Explicit: `useRef<HTMLDivElement>(null)`
+
+## Anti-Patterns
+```typescript
+// ❌ Bad
+const handleClick = (e: any) => {}
+useEffect(() => { doSomething(prop) }, []) // Missing dep
+
+// ✅ Good  
+const handleClick = (e: React.MouseEvent<HTMLButtonElement>) => {}
+useEffect(() => { doSomething(prop) }, [prop])
+```

.devcontainer/.bashrc

@@ -1,69 +0,0 @@
-# Sim Development Environment Bashrc
-# This gets sourced by post-create.sh
-
-# Enhanced prompt with git branch info
-parse_git_branch() {
-  git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
-}
-
-export PS1="\[\033[01;32m\]\u@simstudio\[\033[00m\]:\[\033[01;34m\]\w\[\033[33m\]\$(parse_git_branch)\[\033[00m\]\$ "
-
-# Helpful aliases
-alias ll="ls -la"
-alias ..="cd .."
-alias ...="cd ../.."
-
-# Database aliases
-alias pgc="PGPASSWORD=postgres psql -h db -U postgres -d simstudio"
-alias check-db="PGPASSWORD=postgres psql -h db -U postgres -c '\l'"
-
-# Sim specific aliases
-alias logs="cd /workspace/apps/sim && tail -f logs/*.log 2>/dev/null || echo 'No log files found'"
-alias sim-start="cd /workspace && bun run dev"
-alias sim-migrate="cd /workspace/apps/sim && bunx drizzle-kit push"
-alias sim-generate="cd /workspace/apps/sim && bunx drizzle-kit generate"
-alias sim-rebuild="cd /workspace && bun run build && bun run start"
-alias docs-dev="cd /workspace/apps/docs && bun run dev"
-
-# Turbo related commands
-alias turbo-build="cd /workspace && bunx turbo run build"
-alias turbo-dev="cd /workspace && bunx turbo run dev"
-alias turbo-test="cd /workspace && bunx turbo run test"
-
-# Bun specific commands
-alias bun-update="cd /workspace && bun update"
-alias bun-add="cd /workspace && bun add"
-alias bun-pm="cd /workspace && bun pm"
-alias bun-canary="bun upgrade --canary"
-
-# Default to workspace directory
-cd /workspace 2>/dev/null || true
-
-# Welcome message - only show once per session
-if [ -z "$SIM_WELCOME_SHOWN" ]; then
-  export SIM_WELCOME_SHOWN=1
-  
-  echo ""
-  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-  echo "🚀 Welcome to Sim development environment!"
-  echo ""
-  echo "Available commands:"
-  echo "  sim-start    - Start all apps in development mode"
-  echo "  sim-migrate  - Push schema changes to the database for sim app"
-  echo "  sim-generate - Generate new migrations for sim app"
-  echo "  sim-rebuild  - Build and start all apps"
-  echo "  docs-dev     - Start only the docs app in development mode"
-  echo ""
-  echo "Turbo commands:"
-  echo "  turbo-build  - Build all apps using Turborepo"
-  echo "  turbo-dev    - Start development mode for all apps"
-  echo "  turbo-test   - Run tests for all packages"
-  echo ""
-  echo "Bun commands:"
-  echo "  bun-update   - Update dependencies"
-  echo "  bun-add      - Add a new dependency"
-  echo "  bun-pm       - Manage dependencies"
-  echo "  bun-canary   - Upgrade to the latest canary version of Bun"
-  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-  echo ""
-fi 

.devcontainer/Dockerfile

@@ -1,38 +1,43 @@
-# Use the latest Bun canary image for development
-FROM oven/bun:canary
-
-# Avoid warnings by switching to noninteractive
-ENV DEBIAN_FRONTEND=noninteractive
+FROM oven/bun:1.3.3-alpine
 
 # Install necessary packages for development
-RUN apt-get update \
-    && apt-get -y install --no-install-recommends \
-       git curl wget jq sudo postgresql-client vim nano \
-       bash-completion ca-certificates lsb-release gnupg \
-    && apt-get clean -y \
-    && rm -rf /var/lib/apt/lists/*
+RUN apk add --no-cache \
+    git \
+    curl \
+    wget \
+    jq \
+    sudo \
+    postgresql-client \
+    vim \
+    nano \
+    bash \
+    bash-completion \
+    zsh \
+    zsh-vcs \
+    ca-certificates \
+    shadow
 
-# Create a non-root user
+# Create a non-root user with matching UID/GID
 ARG USERNAME=bun
 ARG USER_UID=1000
 ARG USER_GID=$USER_UID
 
+# Create user group if it doesn't exist
+RUN if ! getent group $USER_GID >/dev/null; then \
+        addgroup -g $USER_GID $USERNAME; \
+    fi
+
+# Create user if it doesn't exist
+RUN if ! getent passwd $USER_UID >/dev/null; then \
+        adduser -D -u $USER_UID -G $(getent group $USER_GID | cut -d: -f1) $USERNAME; \
+    fi
+
 # Add sudo support
 RUN echo "$USERNAME ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/$USERNAME \
     && chmod 0440 /etc/sudoers.d/$USERNAME
 
-# Install global packages for development
-RUN bun install -g turbo drizzle-kit typescript @types/node
-
-# Install bun completions
-RUN bun completions > /etc/bash_completion.d/bun
-
 # Set up shell environment
-RUN echo "export PATH=$PATH:/home/$USERNAME/.bun/bin" >> /etc/profile
-RUN echo "source /etc/profile" >> /etc/bash.bashrc
-
-# Switch back to dialog for any ad-hoc use of apt-get
-ENV DEBIAN_FRONTEND=dialog
+RUN echo "export PATH=\$PATH:/home/$USERNAME/.bun/bin" >> /etc/profile
 
 WORKDIR /workspace
 

.devcontainer/README.md

@@ -1,78 +1,75 @@
 # Sim Development Container
 
-This directory contains configuration files for Visual Studio Code Dev Containers / GitHub Codespaces. Dev containers provide a consistent, isolated development environment for this project.
+Development container configuration for VS Code Dev Containers and GitHub Codespaces.
 
-## Contents
-
-- `devcontainer.json` - The main configuration file that defines the development container settings
-- `Dockerfile` - Defines the container image and development environment
-- `docker-compose.yml` - Sets up the application and database containers
-- `post-create.sh` - Script that runs when the container is created
-- `.bashrc` - Custom shell configuration with helpful aliases
-
-## Usage
-
-### Prerequisites
+## Prerequisites
 
 - Visual Studio Code
-- Docker installation:
-  - Docker Desktop (Windows/macOS)
-  - Docker Engine (Linux)
-- VS Code Remote - Containers extension
+- Docker Desktop or Podman Desktop
+- VS Code Dev Containers extension
 
-### Getting Started
+## Getting Started
 
-1. Open this project in Visual Studio Code
-2. When prompted, click "Reopen in Container"
-   - Alternatively, press `F1` and select "Remote-Containers: Reopen in Container"
+1. Open this project in VS Code
+2. Click "Reopen in Container" when prompted (or press `F1` → "Dev Containers: Reopen in Container")
 3. Wait for the container to build and initialize
-4. The post-creation script will automatically:
+4. Start developing with `sim-start`
 
-   - Install dependencies
-   - Set up environment variables
-   - Run database migrations
-   - Configure helpful aliases
+The setup script will automatically install dependencies and run migrations.
 
-5. Start the application with `sim-start` (alias for `bun run dev`)
+## Development Commands
 
-### Development Commands
+### Running Services
 
-The development environment includes these helpful aliases:
+You have two options for running the development environment:
+
+**Option 1: Run everything together (recommended for most development)**
+```bash
+sim-start  # Runs both app and socket server using concurrently
+```
+
+**Option 2: Run services separately (useful for debugging individual services)**
+- In the **app** container terminal: `sim-app` (starts Next.js app on port 3000)
+- In the **realtime** container terminal: `sim-sockets` (starts socket server on port 3002)
+
+### Other Commands
 
-- `sim-start` - Start the development server
 - `sim-migrate` - Push schema changes to the database
 - `sim-generate` - Generate new migrations
-- `sim-rebuild` - Build and start the production version
-- `pgc` - Connect to the PostgreSQL database
-- `check-db` - List all databases
-
-### Using GitHub Codespaces
-
-This project is also configured for GitHub Codespaces. To use it:
-
-1. Go to the GitHub repository
-2. Click the "Code" button
-3. Select the "Codespaces" tab
-4. Click "Create codespace on main"
-
-This will start a new Codespace with the development environment already set up.
-
-## Customization
-
-You can customize the development environment by:
-
-- Modifying `devcontainer.json` to add VS Code extensions or settings
-- Updating the `Dockerfile` to install additional packages
-- Editing `docker-compose.yml` to add services or change configuration
-- Modifying `.bashrc` to add custom aliases or configurations
+- `build` - Build the application
+- `pgc` - Connect to PostgreSQL database
 
 ## Troubleshooting
 
-If you encounter issues:
+**Build errors**: Rebuild the container with `F1` → "Dev Containers: Rebuild Container"
 
-1. Rebuild the container: `F1` → "Remote-Containers: Rebuild Container"
-2. Check Docker logs for build errors
-3. Verify Docker Desktop is running
-4. Ensure all prerequisites are installed
+**Port conflicts**: Ensure ports 3000, 3002, and 5432 are available
 
-For more information, see the [VS Code Remote Development documentation](https://code.visualstudio.com/docs/remote/containers).
+**Container runtime issues**: Verify Docker Desktop or Podman Desktop is running
+
+## Technical Details
+
+Services:
+- **App container** (8GB memory limit) - Main Next.js application
+- **Realtime container** (4GB memory limit) - Socket.io server for real-time features
+- **Database** - PostgreSQL with pgvector extension
+- **Migrations** - Runs automatically on container creation
+
+You can develop with services running together or independently.
+
+### Personalization
+
+**Project commands** (`sim-start`, `sim-app`, etc.) are automatically available via `/workspace/.devcontainer/sim-commands.sh`.
+
+**Personal shell customization** (aliases, prompts, etc.) should use VS Code's dotfiles feature:
+1. Create a dotfiles repository (e.g., `github.com/youruser/dotfiles`)
+2. Add your `.bashrc`, `.zshrc`, or other configs
+3. Configure in VS Code Settings:
+   ```json
+   {
+     "dotfiles.repository": "youruser/dotfiles",
+     "dotfiles.installCommand": "install.sh"
+   }
+   ```
+
+This separates project-specific commands from personal preferences, following VS Code best practices.

.devcontainer/devcontainer.json

@@ -13,13 +13,6 @@
           "source.fixAll.biome": "explicit",
           "source.organizeImports.biome": "explicit"
         },
-        "terminal.integrated.defaultProfile.linux": "bash",
-        "terminal.integrated.profiles.linux": {
-          "bash": {
-            "path": "/bin/bash",
-            "args": ["--login"]
-          }
-        },
         "terminal.integrated.shellIntegration.enabled": true
       },
       "extensions": [
@@ -36,18 +29,9 @@
     }
   },
 
-  "forwardPorts": [3000, 5432],
+  "forwardPorts": [3000, 3002, 5432],
 
   "postCreateCommand": "bash -c 'bash .devcontainer/post-create.sh || true'",
 
-  "postStartCommand": "bash -c 'if [ ! -f ~/.bashrc ] || ! grep -q \"sim-start\" ~/.bashrc; then cp .devcontainer/.bashrc ~/.bashrc; fi'",
-
-  "remoteUser": "bun",
-
-  "features": {
-    "ghcr.io/devcontainers/features/git:1": {},
-    "ghcr.io/prulloac/devcontainer-features/bun:1": {
-      "version": "latest"
-    }
-  }
+  "remoteUser": "bun"
 }

.devcontainer/docker-compose.yml

@@ -7,52 +7,56 @@ services:
       - ..:/workspace:cached
       - bun-cache:/home/bun/.bun/cache:delegated
     command: sleep infinity
+    deploy:
+      resources:
+        limits:
+          memory: 8G
     environment:
       - NODE_ENV=development
       - DATABASE_URL=postgresql://postgres:postgres@db:5432/simstudio
       - BETTER_AUTH_URL=http://localhost:3000
       - NEXT_PUBLIC_APP_URL=http://localhost:3000
+      - BETTER_AUTH_SECRET=${BETTER_AUTH_SECRET:-your_auth_secret_here}
+      - ENCRYPTION_KEY=${ENCRYPTION_KEY:-your_encryption_key_here}
+      - COPILOT_API_KEY=${COPILOT_API_KEY}
+      - SIM_AGENT_API_URL=${SIM_AGENT_API_URL}
+      - OLLAMA_URL=${OLLAMA_URL:-http://localhost:11434}
+      - NEXT_PUBLIC_SOCKET_URL=${NEXT_PUBLIC_SOCKET_URL:-http://localhost:3002}
       - BUN_INSTALL_CACHE_DIR=/home/bun/.bun/cache
     depends_on:
       db:
         condition: service_healthy
-      realtime:
-        condition: service_healthy
       migrations:
         condition: service_completed_successfully
     ports:
       - "3000:3000"
       - "3001:3001"
     working_dir: /workspace
-    healthcheck:
-      test: ['CMD', 'wget', '--spider', '--quiet', 'http://127.0.0.1:3000']
-      interval: 90s
-      timeout: 5s
-      retries: 3
-      start_period: 10s
 
   realtime:
     build:
       context: ..
       dockerfile: .devcontainer/Dockerfile
+    volumes:
+      - ..:/workspace:cached
+      - bun-cache:/home/bun/.bun/cache:delegated
     command: sleep infinity
+    deploy:
+      resources:
+        limits:
+          memory: 4G
     environment:
       - NODE_ENV=development
       - DATABASE_URL=postgresql://postgres:postgres@db:5432/simstudio
       - BETTER_AUTH_URL=http://localhost:3000
       - NEXT_PUBLIC_APP_URL=http://localhost:3000
+      - BETTER_AUTH_SECRET=${BETTER_AUTH_SECRET:-your_auth_secret_here}
     depends_on:
       db:
         condition: service_healthy
     ports:
       - "3002:3002"
     working_dir: /workspace
-    healthcheck:
-      test: ['CMD', 'wget', '--spider', '--quiet', 'http://127.0.0.1:3002']
-      interval: 90s
-      timeout: 5s
-      retries: 3
-      start_period: 10s
 
   migrations:
     build:

.devcontainer/post-create.sh

@@ -8,11 +8,43 @@ echo "🔧 Setting up Sim development environment..."
 # Change to the workspace root directory
 cd /workspace
 
-# Setup .bashrc
-echo "📄 Setting up .bashrc with aliases..."
-cp /workspace/.devcontainer/.bashrc ~/.bashrc
-# Add to .profile to ensure .bashrc is sourced in non-interactive shells
-echo 'if [ -f ~/.bashrc ]; then . ~/.bashrc; fi' >> ~/.profile
+# Install global packages for development (done at runtime, not build time)
+echo "📦 Installing global development tools..."
+bun install -g turbo drizzle-kit typescript @types/node 2>/dev/null || {
+  echo "⚠️ Some global packages may already be installed, continuing..."
+}
+
+# Set up bun completions (with proper shell detection)
+echo "🔧 Setting up shell completions..."
+if [ -n "$SHELL" ] && [ -f "$SHELL" ]; then
+  SHELL=/bin/bash bun completions 2>/dev/null | sudo tee /etc/bash_completion.d/bun > /dev/null || {
+    echo "⚠️ Could not install bun completions, but continuing..."
+  }
+fi
+
+# Add project commands to shell profile
+echo "📄 Setting up project commands..."
+# Add sourcing of sim-commands.sh to user's shell config files if they exist
+for rcfile in ~/.bashrc ~/.zshrc; do
+  if [ -f "$rcfile" ]; then
+    # Check if already added
+    if ! grep -q "sim-commands.sh" "$rcfile"; then
+      echo "" >> "$rcfile"
+      echo "# Sim project commands" >> "$rcfile"
+      echo "if [ -f /workspace/.devcontainer/sim-commands.sh ]; then" >> "$rcfile"
+      echo "  source /workspace/.devcontainer/sim-commands.sh" >> "$rcfile"
+      echo "fi" >> "$rcfile"
+    fi
+  fi
+done
+
+# If no rc files exist yet, create a minimal one
+if [ ! -f ~/.bashrc ] && [ ! -f ~/.zshrc ]; then
+  echo "# Source Sim project commands" > ~/.bashrc
+  echo "if [ -f /workspace/.devcontainer/sim-commands.sh ]; then" >> ~/.bashrc
+  echo "  source /workspace/.devcontainer/sim-commands.sh" >> ~/.bashrc
+  echo "fi" >> ~/.bashrc
+fi
 
 # Clean and reinstall dependencies to ensure platform compatibility
 echo "📦 Cleaning and reinstalling dependencies..."
@@ -29,18 +61,12 @@ chmod 700 ~/.bun ~/.bun/cache
 
 # Install dependencies with platform-specific binaries
 echo "Installing dependencies with Bun..."
-bun install || {
-  echo "⚠️ bun install had issues but continuing setup..."
-}
+bun install
 
 # Check for native dependencies
 echo "Checking for native dependencies compatibility..."
-NATIVE_DEPS=$(grep '"trustedDependencies"' apps/sim/package.json || echo "")
-if [ ! -z "$NATIVE_DEPS" ]; then
-  echo "⚠️ Native dependencies detected. Ensuring compatibility with Bun..."
-  for pkg in $(echo $NATIVE_DEPS | grep -oP '"[^"]*"' | tr -d '"' | grep -v "trustedDependencies"); do
-    echo "Checking compatibility for $pkg..."
-  done
+if grep -q '"trustedDependencies"' apps/sim/package.json 2>/dev/null; then
+  echo "⚠️ Native dependencies detected. Bun will handle compatibility during install."
 fi
 
 # Set up environment variables if .env doesn't exist for the sim app
@@ -82,23 +108,6 @@ echo "Waiting for database to be ready..."
   fi
 ) || echo "⚠️ Database setup had issues but continuing..."
 
-# Add additional helpful aliases to .bashrc
-cat << EOF >> ~/.bashrc
-
-# Additional Sim Development Aliases
-alias migrate="cd /workspace/apps/sim && DATABASE_URL=postgresql://postgres:postgres@db:5432/simstudio bunx drizzle-kit push"
-alias generate="cd /workspace/apps/sim && bunx drizzle-kit generate"
-alias dev="cd /workspace && bun run dev"
-alias build="cd /workspace && bun run build"
-alias start="cd /workspace && bun run dev"
-alias lint="cd /workspace/apps/sim && bun run lint"
-alias test="cd /workspace && bun run test"
-alias bun-update="cd /workspace && bun update"
-EOF
-
-# Source the .bashrc to make aliases available immediately
-. ~/.bashrc
-
 # Clear the welcome message flag to ensure it shows after setup
 unset SIM_WELCOME_SHOWN
 

.devcontainer/sim-commands.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Sim Project Commands
+# Source this file to add project-specific commands to your shell
+# Add to your ~/.bashrc or ~/.zshrc: source /workspace/.devcontainer/sim-commands.sh
+
+# Project-specific aliases for Sim development
+alias sim-start="cd /workspace && bun run dev:full"
+alias sim-app="cd /workspace && bun run dev"
+alias sim-sockets="cd /workspace && bun run dev:sockets"
+alias sim-migrate="cd /workspace/apps/sim && bunx drizzle-kit push"
+alias sim-generate="cd /workspace/apps/sim && bunx drizzle-kit generate"
+alias sim-rebuild="cd /workspace && bun run build && bun run start"
+alias docs-dev="cd /workspace/apps/docs && bun run dev"
+
+# Database connection helpers
+alias pgc="PGPASSWORD=postgres psql -h db -U postgres -d simstudio"
+alias check-db="PGPASSWORD=postgres psql -h db -U postgres -c '\l'"
+
+# Default to workspace directory
+cd /workspace 2>/dev/null || true
+
+# Welcome message - show once per session
+if [ -z "$SIM_WELCOME_SHOWN" ]; then
+  export SIM_WELCOME_SHOWN=1
+
+  echo ""
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "🚀 Sim Development Environment"
+  echo ""
+  echo "Project commands:"
+  echo "  sim-start      - Start app + socket server"
+  echo "  sim-app        - Start only main app"
+  echo "  sim-sockets    - Start only socket server"
+  echo "  sim-migrate    - Push schema changes"
+  echo "  sim-generate   - Generate migrations"
+  echo ""
+  echo "Database:"
+  echo "  pgc            - Connect to PostgreSQL"
+  echo "  check-db       - List databases"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+fi

.dockerignore

@@ -1,11 +1,67 @@
+# Git
+.git
+.gitignore
+
+# Documentation
 LICENSE
 NOTICE
+README.md
+*.md
+docs/
+
+# IDE and editor
+.vscode
+.idea
+*.swp
+*.swo
+
+# Environment and config
+.env*
+!.env.example
 .prettierrc
 .prettierignore
-README.md
-.gitignore
-.husky
+.eslintrc*
+.eslintignore
+
+# CI/CD and DevOps
 .github
 .devcontainer
-.env.example
-node_modules
+.husky
+docker-compose*.yml
+Dockerfile*
+
+# Build artifacts and caches
+.next
+.turbo
+.cache
+dist
+build
+out
+coverage
+*.log
+
+# Dependencies (will be installed fresh in container)
+node_modules
+.bun
+
+# Test files
+**/*.test.ts
+**/*.test.tsx
+**/*.spec.ts
+**/*.spec.tsx
+__tests__
+__mocks__
+jest.config.*
+vitest.config.*
+
+# TypeScript build info
+*.tsbuildinfo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Temporary files
+tmp
+temp
+*.tmp

.gitattributes

@@ -0,0 +1,34 @@
+# Set default behavior to automatically normalize line endings
+* text=auto eol=lf
+
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout
+*.ts text eol=lf
+*.tsx text eol=lf
+*.js text eol=lf
+*.jsx text eol=lf
+*.json text eol=lf
+*.md text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf
+*.toml text eol=lf
+*.css text eol=lf
+*.scss text eol=lf
+*.sh text eol=lf
+*.bash text eol=lf
+Dockerfile* text eol=lf
+.dockerignore text eol=lf
+.gitignore text eol=lf
+.gitattributes text eol=lf
+
+# Denote all files that are truly binary and should not be modified
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.woff binary
+*.woff2 binary
+*.ttf binary
+*.eot binary
+*.pdf binary

.github/CONTRIBUTING.md

@@ -321,8 +321,7 @@ In addition, you will need to update the registries:
        {
          id: 'operation',
          title: 'Operation',
-         type: 'dropdown',
-         layout: 'full',
+         type: 'dropdown'
          required: true,
          options: [
            { label: 'Generate Embeddings', id: 'generate' },
@@ -333,8 +332,7 @@ In addition, you will need to update the registries:
        {
          id: 'apiKey',
          title: 'API Key',
-         type: 'short-input',
-         layout: 'full',
+         type: 'short-input'
          placeholder: 'Your Pinecone API key',
          password: true,
          required: true,
@@ -376,7 +374,7 @@ In addition, you will need to update the registries:
    Add your block to the blocks registry (`/apps/sim/blocks/registry.ts`):
 
    ```typescript:/apps/sim/blocks/registry.ts
-   import { PineconeBlock } from './blocks/pinecone'
+   import { PineconeBlock } from '@/blocks/blocks/pinecone'
 
    // Registry of all available blocks
    export const registry: Record<string, BlockConfig> = {

.github/workflows/ci.yml

@@ -16,12 +16,37 @@ jobs:
     uses: ./.github/workflows/test-build.yml
     secrets: inherit
 
+  # Detect if this is a version release commit (e.g., "v0.5.24: ...")
+  detect-version:
+    name: Detect Version
+    runs-on: blacksmith-4vcpu-ubuntu-2404
+    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/staging')
+    outputs:
+      version: ${{ steps.extract.outputs.version }}
+      is_release: ${{ steps.extract.outputs.is_release }}
+    steps:
+      - name: Extract version from commit message
+        id: extract
+        run: |
+          COMMIT_MSG="${{ github.event.head_commit.message }}"
+          # Only tag versions on main branch
+          if [ "${{ github.ref }}" = "refs/heads/main" ] && [[ "$COMMIT_MSG" =~ ^(v[0-9]+\.[0-9]+\.[0-9]+): ]]; then
+            VERSION="${BASH_REMATCH[1]}"
+            echo "version=${VERSION}" >> $GITHUB_OUTPUT
+            echo "is_release=true" >> $GITHUB_OUTPUT
+            echo "✅ Detected release commit: ${VERSION}"
+          else
+            echo "version=" >> $GITHUB_OUTPUT
+            echo "is_release=false" >> $GITHUB_OUTPUT
+            echo "ℹ️ Not a release commit"
+          fi
+
   # Build AMD64 images and push to ECR immediately (+ GHCR for main)
   build-amd64:
     name: Build AMD64
-    needs: test-build
+    needs: [test-build, detect-version]
     if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/staging')
-    runs-on: blacksmith-4vcpu-ubuntu-2404
+    runs-on: blacksmith-8vcpu-ubuntu-2404
     permissions:
       contents: read
       packages: write
@@ -93,6 +118,14 @@ jobs:
             GHCR_AMD64="${GHCR_IMAGE}:latest-amd64"
             GHCR_SHA="${GHCR_IMAGE}:${{ github.sha }}-amd64"
             TAGS="${TAGS},$GHCR_AMD64,$GHCR_SHA"
+
+            # Add version tag if this is a release commit
+            if [ "${{ needs.detect-version.outputs.is_release }}" = "true" ]; then
+              VERSION="${{ needs.detect-version.outputs.version }}"
+              GHCR_VERSION="${GHCR_IMAGE}:${VERSION}-amd64"
+              TAGS="${TAGS},$GHCR_VERSION"
+              echo "📦 Adding version tag: ${VERSION}-amd64"
+            fi
           fi
 
           echo "tags=${TAGS}" >> $GITHUB_OUTPUT
@@ -111,8 +144,8 @@ jobs:
   # Build ARM64 images for GHCR (main branch only, runs in parallel)
   build-ghcr-arm64:
     name: Build ARM64 (GHCR Only)
-    needs: test-build
-    runs-on: linux-arm64-8-core
+    needs: [test-build, detect-version]
+    runs-on: blacksmith-8vcpu-ubuntu-2404-arm
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     permissions:
       contents: read
@@ -146,7 +179,16 @@ jobs:
         id: meta
         run: |
           IMAGE="${{ matrix.image }}"
-          echo "tags=${IMAGE}:latest-arm64,${IMAGE}:${{ github.sha }}-arm64" >> $GITHUB_OUTPUT
+          TAGS="${IMAGE}:latest-arm64,${IMAGE}:${{ github.sha }}-arm64"
+
+          # Add version tag if this is a release commit
+          if [ "${{ needs.detect-version.outputs.is_release }}" = "true" ]; then
+            VERSION="${{ needs.detect-version.outputs.version }}"
+            TAGS="${TAGS},${IMAGE}:${VERSION}-arm64"
+            echo "📦 Adding version tag: ${VERSION}-arm64"
+          fi
+
+          echo "tags=${TAGS}" >> $GITHUB_OUTPUT
 
       - name: Build and push ARM64 to GHCR
         uses: useblacksmith/build-push-action@v2
@@ -162,8 +204,8 @@ jobs:
   # Create GHCR multi-arch manifests (only for main, after both builds)
   create-ghcr-manifests:
     name: Create GHCR Manifests
-    runs-on: blacksmith-4vcpu-ubuntu-2404
-    needs: [build-amd64, build-ghcr-arm64]
+    runs-on: blacksmith-2vcpu-ubuntu-2404
+    needs: [build-amd64, build-ghcr-arm64, detect-version]
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     permissions:
       packages: write
@@ -198,18 +240,40 @@ jobs:
             "${IMAGE_BASE}:${{ github.sha }}-arm64"
           docker manifest push "${IMAGE_BASE}:${{ github.sha }}"
 
-  # Deploy Trigger.dev (after ECR images are pushed, runs in parallel with process-docs)
-  trigger-deploy:
-    name: Deploy Trigger.dev
-    needs: build-amd64
-    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/staging')
-    uses: ./.github/workflows/trigger-deploy.yml
-    secrets: inherit
+          # Create version manifest if this is a release commit
+          if [ "${{ needs.detect-version.outputs.is_release }}" = "true" ]; then
+            VERSION="${{ needs.detect-version.outputs.version }}"
+            echo "📦 Creating version manifest: ${VERSION}"
+            docker manifest create "${IMAGE_BASE}:${VERSION}" \
+              "${IMAGE_BASE}:${VERSION}-amd64" \
+              "${IMAGE_BASE}:${VERSION}-arm64"
+            docker manifest push "${IMAGE_BASE}:${VERSION}"
+          fi
 
-  # Process docs embeddings (after ECR images are pushed, runs in parallel with trigger-deploy)
+  # Check if docs changed
+  check-docs-changes:
+    name: Check Docs Changes
+    runs-on: blacksmith-4vcpu-ubuntu-2404
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    outputs:
+      docs_changed: ${{ steps.filter.outputs.docs }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2  # Need at least 2 commits to detect changes
+      - uses: dorny/paths-filter@v3
+        id: filter
+        with:
+          filters: |
+            docs:
+              - 'apps/docs/content/docs/en/**'
+              - 'apps/sim/scripts/process-docs.ts'
+              - 'apps/sim/lib/chunkers/**'
+
+  # Process docs embeddings (only when docs change, after ECR images are pushed)
   process-docs:
     name: Process Docs
-    needs: build-amd64
-    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/staging')
+    needs: [build-amd64, check-docs-changes]
+    if: needs.check-docs-changes.outputs.docs_changed == 'true'
     uses: ./.github/workflows/docs-embeddings.yml
     secrets: inherit

.github/workflows/docs-embeddings.yml

@@ -7,8 +7,8 @@ on:
 jobs:
   process-docs-embeddings:
     name: Process Documentation Embeddings
-    runs-on: blacksmith-4vcpu-ubuntu-2404
-    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/staging'
+    runs-on: blacksmith-8vcpu-ubuntu-2404
+    if: github.ref == 'refs/heads/main'
 
     steps:
       - name: Checkout code
@@ -17,19 +17,30 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.3
 
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
           node-version: latest
 
+      - name: Cache Bun dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.bun/install/cache
+            node_modules
+            **/node_modules
+          key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-bun-
+
       - name: Install dependencies
-        run: bun install
+        run: bun install --frozen-lockfile
 
       - name: Process docs embeddings
         working-directory: ./apps/sim
         env:
-          DATABASE_URL: ${{ github.ref == 'refs/heads/main' && secrets.DATABASE_URL || secrets.STAGING_DATABASE_URL }}
+          DATABASE_URL: ${{ secrets.DATABASE_URL }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-        run: bun run scripts/process-docs-embeddings.ts --clear 
+        run: bun run scripts/process-docs.ts --clear 

.github/workflows/i18n.yml

@@ -3,10 +3,9 @@ name: 'Auto-translate Documentation'
 on:
   push:
     branches: [ staging ]
-    paths: 
+    paths:
       - 'apps/docs/content/docs/en/**'
       - 'apps/docs/i18n.json'
-  workflow_dispatch: # Allow manual triggers
 
 permissions:
   contents: write
@@ -27,7 +26,18 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.3
+
+      - name: Cache Bun dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.bun/install/cache
+            node_modules
+            **/node_modules
+          key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-bun-
 
       - name: Run Lingo.dev translations
         env:
@@ -116,12 +126,23 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.3
+
+      - name: Cache Bun dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.bun/install/cache
+            node_modules
+            **/node_modules
+          key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-bun-
 
       - name: Install dependencies
         run: |
           cd apps/docs
-          bun install
+          bun install --frozen-lockfile
 
       - name: Build documentation to verify translations
         run: |

.github/workflows/images.yml

@@ -12,7 +12,7 @@ permissions:
 jobs:
   build-amd64:
     name: Build AMD64
-    runs-on: blacksmith-4vcpu-ubuntu-2404
+    runs-on: blacksmith-8vcpu-ubuntu-2404
     strategy:
       fail-fast: false
       matrix:
@@ -100,7 +100,7 @@ jobs:
 
   build-ghcr-arm64:
     name: Build ARM64 (GHCR Only)
-    runs-on: linux-arm64-8-core
+    runs-on: blacksmith-8vcpu-ubuntu-2404-arm
     if: github.ref == 'refs/heads/main'
     strategy:
       fail-fast: false
@@ -146,7 +146,7 @@ jobs:
 
   create-ghcr-manifests:
     name: Create GHCR Manifests
-    runs-on: blacksmith-4vcpu-ubuntu-2404
+    runs-on: blacksmith-8vcpu-ubuntu-2404
     needs: [build-amd64, build-ghcr-arm64]
     if: github.ref == 'refs/heads/main'
     strategy:

.github/workflows/migrations.yml

@@ -16,10 +16,21 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.3
+
+      - name: Cache Bun dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.bun/install/cache
+            node_modules
+            **/node_modules
+          key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-bun-
 
       - name: Install dependencies
-        run: bun install
+        run: bun install --frozen-lockfile
 
       - name: Apply migrations
         working-directory: ./packages/db

.github/workflows/publish-cli.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.3
 
       - name: Setup Node.js for npm publishing
         uses: actions/setup-node@v4
@@ -24,9 +24,20 @@ jobs:
           node-version: '18'
           registry-url: 'https://registry.npmjs.org/'
 
+      - name: Cache Bun dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.bun/install/cache
+            node_modules
+            **/node_modules
+          key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-bun-
+
       - name: Install dependencies
         working-directory: packages/cli
-        run: bun install
+        run: bun install --frozen-lockfile
 
       - name: Build package
         working-directory: packages/cli

.github/workflows/publish-python-sdk.yml

@@ -84,6 +84,6 @@ jobs:
             ```
             
             ### Documentation
-            See the [README](https://github.com/simstudio/sim/tree/main/packages/python-sdk) for usage instructions.
+            See the [README](https://github.com/simstudioai/sim/tree/main/packages/python-sdk) or the [docs](https://docs.sim.ai/sdks/python) for more information.
           draft: false
           prerelease: false 

.github/workflows/publish-ts-sdk.yml

@@ -16,17 +16,27 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.3
 
       - name: Setup Node.js for npm publishing
         uses: actions/setup-node@v4
         with:
-          node-version: '18'
+          node-version: '22'
           registry-url: 'https://registry.npmjs.org/'
 
+      - name: Cache Bun dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.bun/install/cache
+            node_modules
+            **/node_modules
+          key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-bun-
+
       - name: Install dependencies
-        working-directory: packages/ts-sdk
-        run: bun install
+        run: bun install --frozen-lockfile
 
       - name: Run tests
         working-directory: packages/ts-sdk
@@ -80,6 +90,6 @@ jobs:
             ```
             
             ### Documentation
-            See the [README](https://github.com/simstudio/sim/tree/main/packages/ts-sdk) for usage instructions.
+            See the [README](https://github.com/simstudioai/sim/tree/main/packages/ts-sdk) or the [docs](https://docs.sim.ai/sdks/typescript) for more information.
           draft: false
           prerelease: false 

.github/workflows/test-build.yml

@@ -16,16 +16,30 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.3
 
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
           node-version: latest
 
+      - name: Cache Bun dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.bun/install/cache
+            node_modules
+            **/node_modules
+          key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-bun-
+
       - name: Install dependencies
         run: bun install --frozen-lockfile
 
+      - name: Lint code
+        run: bun run lint:check
+
       - name: Run tests with coverage
         env:
           NODE_OPTIONS: '--no-warnings'
@@ -34,6 +48,19 @@ jobs:
           ENCRYPTION_KEY: '7cf672e460e430c1fba707575c2b0e2ad5a99dddf9b7b7e3b5646e630861db1c' # dummy key for CI only
         run: bun run test
 
+      - name: Check schema and migrations are in sync
+        working-directory: packages/db
+        run: |
+          bunx drizzle-kit generate --config=./drizzle.config.ts
+          if [ -n "$(git status --porcelain ./migrations)" ]; then
+            echo "❌ Schema and migrations are out of sync!"
+            echo "Run 'cd packages/db && bunx drizzle-kit generate' and commit the new migrations."
+            git status --porcelain ./migrations
+            git diff ./migrations
+            exit 1
+          fi
+          echo "✅ Schema and migrations are in sync"
+
       - name: Build application
         env:
           NODE_OPTIONS: '--no-warnings'

.github/workflows/trigger-deploy.yml

@@ -1,44 +0,0 @@
-name: Trigger.dev Deploy
-
-on:
-  workflow_call:
-  workflow_dispatch:
-
-jobs:
-  deploy:
-    name: Deploy to Trigger.dev
-    runs-on: blacksmith-4vcpu-ubuntu-2404
-    concurrency:
-      group: trigger-deploy-${{ github.ref }}
-      cancel-in-progress: false
-    env:
-      TRIGGER_ACCESS_TOKEN: ${{ secrets.TRIGGER_ACCESS_TOKEN }}
-      TRIGGER_PROJECT_ID: ${{ secrets.TRIGGER_PROJECT_ID }}
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: latest
-
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-
-      - name: Install dependencies
-        run: bun install
-
-      - name: Deploy to Trigger.dev (Staging)
-        if: github.ref == 'refs/heads/staging'
-        working-directory: ./apps/sim
-        run: npx --yes trigger.dev@4.0.4 deploy -e staging
-
-      - name: Deploy to Trigger.dev (Production)
-        if: github.ref == 'refs/heads/main'
-        working-directory: ./apps/sim
-        run: npx --yes trigger.dev@4.0.4 deploy
-

.gitignore

@@ -46,7 +46,7 @@ sim-standalone.tar.gz
 next-env.d.ts
 
 # cursorrules
-.cursorrules
+# .cursorrules
 
 # docs
 /apps/docs/.source
@@ -67,6 +67,9 @@ start-collector.sh
 # VSCode
 .vscode
 
+# IntelliJ
+.idea
+
 ## Helm Chart Tests
 helm/sim/test
 i18n.cache

CLAUDE.md

@@ -0,0 +1,47 @@
+# Expert Programming Standards
+
+**You are tasked with implementing solutions that follow best practices. You MUST be accurate, elegant, and efficient as an expert programmer.**
+
+---
+
+# Role
+
+You are a professional software engineer. All code you write MUST follow best practices, ensuring accuracy, quality, readability, and cleanliness. You MUST make FOCUSED EDITS that are EFFICIENT and ELEGANT.
+
+## Logs
+
+ENSURE that you use the logger.info and logger.warn and logger.error instead of the console.log whenever you want to display logs.
+
+## Comments
+
+You must use TSDOC for comments. Do not use ==== for comments to separate sections. Do not leave any comments that are not TSDOC.
+
+## Global Styles
+
+You should not update the global styles unless it is absolutely necessary. Keep all styling local to components and files.
+
+## Bun
+
+Use bun and bunx not npm and npx.
+
+## Code Quality
+
+- Write clean, maintainable code that follows the project's existing patterns
+- Prefer composition over inheritance
+- Keep functions small and focused on a single responsibility
+- Use meaningful variable and function names
+- Handle errors gracefully and provide useful error messages
+- Write type-safe code with proper TypeScript types
+
+## Testing
+
+- Write tests for new functionality when appropriate
+- Ensure existing tests pass before completing work
+- Follow the project's testing conventions
+
+## Performance
+
+- Consider performance implications of your code
+- Avoid unnecessary re-renders in React components
+- Use appropriate data structures and algorithms
+- Profile and optimize when necessary

README.md

@@ -13,8 +13,25 @@
   <a href="https://docs.sim.ai" target="_blank" rel="noopener noreferrer"><img src="https://img.shields.io/badge/Docs-6F3DFA.svg" alt="Documentation"></a>
 </p>
 
+### Build Workflows with Ease
+Design agent workflows visually on a canvas—connect agents, tools, and blocks, then run them instantly.
+
 <p align="center">
-  <img src="apps/sim/public/static/demo.gif" alt="Sim Demo" width="800"/>
+  <img src="apps/sim/public/static/workflow.gif" alt="Workflow Builder Demo" width="800"/>
+</p>
+
+### Supercharge with Copilot
+Leverage Copilot to generate nodes, fix errors, and iterate on flows directly from natural language.
+
+<p align="center">
+  <img src="apps/sim/public/static/copilot.gif" alt="Copilot Demo" width="800"/>
+</p>
+
+### Integrate Vector Databases
+Upload documents to a vector store and let agents answer questions grounded in your specific content.
+
+<p align="center">
+  <img src="apps/sim/public/static/knowledge.gif" alt="Knowledge Uploads and Retrieval Demo" width="800"/>
 </p>
 
 ## Quickstart
@@ -72,6 +89,36 @@ Wait for the model to download, then visit [http://localhost:3000](http://localh
 docker compose -f docker-compose.ollama.yml exec ollama ollama pull llama3.1:8b
 ```
 
+#### Using an External Ollama Instance
+
+If you already have Ollama running on your host machine (outside Docker), you need to configure the `OLLAMA_URL` to use `host.docker.internal` instead of `localhost`:
+
+```bash
+# Docker Desktop (macOS/Windows)
+OLLAMA_URL=http://host.docker.internal:11434 docker compose -f docker-compose.prod.yml up -d
+
+# Linux (add extra_hosts or use host IP)
+docker compose -f docker-compose.prod.yml up -d  # Then set OLLAMA_URL to your host's IP
+```
+
+**Why?** When running inside Docker, `localhost` refers to the container itself, not your host machine. `host.docker.internal` is a special DNS name that resolves to the host.
+
+For Linux users, you can either:
+- Use your host machine's actual IP address (e.g., `http://192.168.1.100:11434`)
+- Add `extra_hosts: ["host.docker.internal:host-gateway"]` to the simstudio service in your compose file
+
+#### Using vLLM
+
+Sim also supports [vLLM](https://docs.vllm.ai/) for self-hosted models with OpenAI-compatible API:
+
+```bash
+# Set these environment variables
+VLLM_BASE_URL=http://your-vllm-server:8000
+VLLM_API_KEY=your_optional_api_key  # Only if your vLLM instance requires auth
+```
+
+When running with Docker, use `host.docker.internal` if vLLM is on your host machine (same as Ollama above).
+
 ### Self-hosted: Dev Containers
 
 1. Open VS Code with the [Remote - Containers extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers)
@@ -83,6 +130,7 @@ docker compose -f docker-compose.ollama.yml exec ollama ollama pull llama3.1:8b
 
 **Requirements:**
 - [Bun](https://bun.sh/) runtime
+- [Node.js](https://nodejs.org/) v20+ (required for sandboxed code execution)
 - PostgreSQL 12+ with [pgvector extension](https://github.com/pgvector/pgvector) (required for AI embeddings)
 
 **Note:** Sim uses vector embeddings for AI features like knowledge bases and semantic search, which requires the `pgvector` PostgreSQL extension.
@@ -140,6 +188,7 @@ DATABASE_URL="postgresql://postgres:your_password@localhost:5432/simstudio"
 
 Then run the migrations:
 ```bash
+cd packages/db # Required so drizzle picks correct .env file
 bunx drizzle-kit migrate --config=./drizzle.config.ts
 ```
 
@@ -173,6 +222,46 @@ Copilot is a Sim-managed service. To use Copilot on a self-hosted instance:
 - Go to https://sim.ai → Settings → Copilot and generate a Copilot API key
 - Set `COPILOT_API_KEY` environment variable in your self-hosted apps/sim/.env file to that value
 
+## Environment Variables
+
+Key environment variables for self-hosted deployments (see `apps/sim/.env.example` for full list):
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `DATABASE_URL` | Yes | PostgreSQL connection string with pgvector |
+| `BETTER_AUTH_SECRET` | Yes | Auth secret (`openssl rand -hex 32`) |
+| `BETTER_AUTH_URL` | Yes | Your app URL (e.g., `http://localhost:3000`) |
+| `NEXT_PUBLIC_APP_URL` | Yes | Public app URL (same as above) |
+| `ENCRYPTION_KEY` | Yes | Encryption key (`openssl rand -hex 32`) |
+| `OLLAMA_URL` | No | Ollama server URL (default: `http://localhost:11434`) |
+| `VLLM_BASE_URL` | No | vLLM server URL for self-hosted models |
+| `COPILOT_API_KEY` | No | API key from sim.ai for Copilot features |
+
+## Troubleshooting
+
+### Ollama models not showing in dropdown (Docker)
+
+If you're running Ollama on your host machine and Sim in Docker, change `OLLAMA_URL` from `localhost` to `host.docker.internal`:
+
+```bash
+OLLAMA_URL=http://host.docker.internal:11434 docker compose -f docker-compose.prod.yml up -d
+```
+
+See [Using an External Ollama Instance](#using-an-external-ollama-instance) for details.
+
+### Database connection issues
+
+Ensure PostgreSQL has the pgvector extension installed. When using Docker, wait for the database to be healthy before running migrations.
+
+### Port conflicts
+
+If ports 3000, 3002, or 5432 are in use, configure alternatives:
+
+```bash
+# Custom ports
+NEXT_PUBLIC_APP_URL=http://localhost:3100 POSTGRES_PORT=5433 docker compose up -d
+```
+
 ## Tech Stack
 
 - **Framework**: [Next.js](https://nextjs.org/) (App Router)

apps/docs/app/[lang]/[[...slug]]/page.tsx

@@ -1,20 +1,25 @@
-import { findNeighbour } from 'fumadocs-core/server'
+import type React from 'react'
+import { findNeighbour } from 'fumadocs-core/page-tree'
 import defaultMdxComponents from 'fumadocs-ui/mdx'
 import { DocsBody, DocsDescription, DocsPage, DocsTitle } from 'fumadocs-ui/page'
 import { ChevronLeft, ChevronRight } from 'lucide-react'
 import Link from 'next/link'
 import { notFound } from 'next/navigation'
+import { PageNavigationArrows } from '@/components/docs-layout/page-navigation-arrows'
+import { TOCFooter } from '@/components/docs-layout/toc-footer'
+import { LLMCopyButton } from '@/components/page-actions'
 import { StructuredData } from '@/components/structured-data'
-import { source } from '@/lib/source'
-
-export const dynamic = 'force-dynamic'
+import { CodeBlock } from '@/components/ui/code-block'
+import { Heading } from '@/components/ui/heading'
+import { type PageData, source } from '@/lib/source'
 
 export default async function Page(props: { params: Promise<{ slug?: string[]; lang: string }> }) {
   const params = await props.params
   const page = source.getPage(params.slug, params.lang)
   if (!page) notFound()
 
-  const MDX = page.data.body
+  const data = page.data as PageData
+  const MDX = data.body
   const baseUrl = 'https://docs.sim.ai'
 
   const pageTreeRecord = source.pageTree as Record<string, any>
@@ -22,54 +27,172 @@ export default async function Page(props: { params: Promise<{ slug?: string[]; l
     pageTreeRecord[params.lang] ?? pageTreeRecord.en ?? Object.values(pageTreeRecord)[0]
   const neighbours = pageTree ? findNeighbour(pageTree, page.url) : null
 
-  const CustomFooter = () => (
-    <div className='mt-12 flex items-center justify-between border-border border-t py-8'>
-      {neighbours?.previous ? (
-        <Link
-          href={neighbours.previous.url}
-          className='group flex items-center gap-2 text-muted-foreground transition-colors hover:text-foreground'
-        >
-          <ChevronLeft className='group-hover:-translate-x-1 h-4 w-4 transition-transform' />
-          <span className='font-medium'>{neighbours.previous.name}</span>
-        </Link>
-      ) : (
-        <div />
-      )}
+  const generateBreadcrumbs = () => {
+    const breadcrumbs: Array<{ name: string; url: string }> = [
+      {
+        name: 'Home',
+        url: baseUrl,
+      },
+    ]
 
-      {neighbours?.next ? (
+    const urlParts = page.url.split('/').filter(Boolean)
+    let currentPath = ''
+
+    urlParts.forEach((part, index) => {
+      if (index === 0 && ['en', 'es', 'fr', 'de', 'ja', 'zh'].includes(part)) {
+        currentPath = `/${part}`
+        return
+      }
+
+      currentPath += `/${part}`
+
+      const name = part
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ')
+
+      if (index === urlParts.length - 1) {
+        breadcrumbs.push({
+          name: data.title,
+          url: `${baseUrl}${page.url}`,
+        })
+      } else {
+        breadcrumbs.push({
+          name: name,
+          url: `${baseUrl}${currentPath}`,
+        })
+      }
+    })
+
+    return breadcrumbs
+  }
+
+  const breadcrumbs = generateBreadcrumbs()
+
+  const CustomFooter = () => (
+    <div className='mt-12'>
+      {/* Navigation links */}
+      <div className='flex items-center justify-between py-8'>
+        {neighbours?.previous ? (
+          <Link
+            href={neighbours.previous.url}
+            className='group flex items-center gap-2 text-muted-foreground transition-colors hover:text-foreground'
+          >
+            <ChevronLeft className='group-hover:-translate-x-1 h-4 w-4 transition-transform' />
+            <span className='font-medium'>{neighbours.previous.name}</span>
+          </Link>
+        ) : (
+          <div />
+        )}
+
+        {neighbours?.next ? (
+          <Link
+            href={neighbours.next.url}
+            className='group flex items-center gap-2 text-muted-foreground transition-colors hover:text-foreground'
+          >
+            <span className='font-medium'>{neighbours.next.name}</span>
+            <ChevronRight className='h-4 w-4 transition-transform group-hover:translate-x-1' />
+          </Link>
+        ) : (
+          <div />
+        )}
+      </div>
+
+      {/* Divider line */}
+      <div className='border-border border-t' />
+
+      {/* Social icons */}
+      <div className='flex items-center gap-4 py-6'>
         <Link
-          href={neighbours.next.url}
-          className='group flex items-center gap-2 text-muted-foreground transition-colors hover:text-foreground'
+          href='https://x.com/simdotai'
+          target='_blank'
+          rel='noopener noreferrer'
+          aria-label='X (Twitter)'
         >
-          <span className='font-medium'>{neighbours.next.name}</span>
-          <ChevronRight className='h-4 w-4 transition-transform group-hover:translate-x-1' />
+          <div
+            className='h-5 w-5 bg-gray-400 transition-colors hover:bg-gray-500 dark:bg-gray-500 dark:hover:bg-gray-400'
+            style={{
+              maskImage:
+                "url('data:image/svg+xml,%3Csvg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 24 24%22%3E%3Cpath d=%22M18.244 2.25h3.308l-7.227 8.26 8.502 11.24H16.17l-5.214-6.817L4.99 21.75H1.68l7.73-8.835L1.254 2.25H8.08l4.713 6.231zm-1.161 17.52h1.833L7.084 4.126H5.117z%22/%3E%3C/svg%3E')",
+              maskRepeat: 'no-repeat',
+              maskPosition: 'center center',
+              WebkitMaskImage:
+                "url('data:image/svg+xml,%3Csvg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 24 24%22%3E%3Cpath d=%22M18.244 2.25h3.308l-7.227 8.26 8.502 11.24H16.17l-5.214-6.817L4.99 21.75H1.68l7.73-8.835L1.254 2.25H8.08l4.713 6.231zm-1.161 17.52h1.833L7.084 4.126H5.117z%22/%3E%3C/svg%3E')",
+              WebkitMaskRepeat: 'no-repeat',
+              WebkitMaskPosition: 'center center',
+            }}
+          />
         </Link>
-      ) : (
-        <div />
-      )}
+        <Link
+          href='https://github.com/simstudioai/sim'
+          target='_blank'
+          rel='noopener noreferrer'
+          aria-label='GitHub'
+        >
+          <div
+            className='h-5 w-5 bg-gray-400 transition-colors hover:bg-gray-500 dark:bg-gray-500 dark:hover:bg-gray-400'
+            style={{
+              maskImage:
+                "url('data:image/svg+xml,%3Csvg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 24 24%22%3E%3Cpath d=%22M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z%22/%3E%3C/svg%3E')",
+              maskRepeat: 'no-repeat',
+              maskPosition: 'center center',
+              WebkitMaskImage:
+                "url('data:image/svg+xml,%3Csvg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 24 24%22%3E%3Cpath d=%22M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z%22/%3E%3C/svg%3E')",
+              WebkitMaskRepeat: 'no-repeat',
+              WebkitMaskPosition: 'center center',
+            }}
+          />
+        </Link>
+        <Link
+          href='https://discord.gg/Hr4UWYEcTT'
+          target='_blank'
+          rel='noopener noreferrer'
+          aria-label='Discord'
+        >
+          <div
+            className='h-5 w-5 bg-gray-400 transition-colors hover:bg-gray-500 dark:bg-gray-500 dark:hover:bg-gray-400'
+            style={{
+              maskImage:
+                "url('data:image/svg+xml,%3Csvg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 24 24%22%3E%3Cpath d=%22M20.317 4.37a19.791 19.791 0 0 0-4.885-1.515a.074.074 0 0 0-.079.037c-.21.375-.444.864-.608 1.25a18.27 18.27 0 0 0-5.487 0a12.64 12.64 0 0 0-.617-1.25a.077.077 0 0 0-.079-.037A19.736 19.736 0 0 0 3.677 4.37a.07.07 0 0 0-.032.027C.533 9.046-.32 13.58.099 18.057a.082.082 0 0 0 .031.057a19.9 19.9 0 0 0 5.993 3.03a.078.078 0 0 0 .084-.028a14.09 14.09 0 0 0 1.226-1.994a.076.076 0 0 0-.041-.106a13.107 13.107 0 0 1-1.872-.892a.077.077 0 0 1-.008-.128a10.2 10.2 0 0 0 .372-.292a.074.074 0 0 1 .077-.01c3.928 1.793 8.18 1.793 12.062 0a.074.074 0 0 1 .078.01c.12.098.246.198.373.292a.077.077 0 0 1-.006.127a12.299 12.299 0 0 1-1.873.892a.077.077 0 0 0-.041.107c.36.698.772 1.362 1.225 1.993a.076.076 0 0 0 .084.028a19.839 19.839 0 0 0 6.002-3.03a.077.077 0 0 0 .032-.054c.5-5.177-.838-9.674-3.549-13.66a.061.061 0 0 0-.031-.03zM8.02 15.33c-1.183 0-2.157-1.085-2.157-2.419c0-1.333.956-2.419 2.157-2.419c1.21 0 2.176 1.096 2.157 2.42c0 1.333-.956 2.418-2.157 2.418zm7.975 0c-1.183 0-2.157-1.085-2.157-2.419c0-1.333.955-2.419 2.157-2.419c1.21 0 2.176 1.096 2.157 2.42c0 1.333-.946 2.418-2.157 2.418z%22/%3E%3C/svg%3E')",
+              maskRepeat: 'no-repeat',
+              maskPosition: 'center center',
+              WebkitMaskImage:
+                "url('data:image/svg+xml,%3Csvg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 24 24%22%3E%3Cpath d=%22M20.317 4.37a19.791 19.791 0 0 0-4.885-1.515a.074.074 0 0 0-.079.037c-.21.375-.444.864-.608 1.25a18.27 18.27 0 0 0-5.487 0a12.64 12.64 0 0 0-.617-1.25a.077.077 0 0 0-.079-.037A19.736 19.736 0 0 0 3.677 4.37a.07.07 0 0 0-.032.027C.533 9.046-.32 13.58.099 18.057a.082.082 0 0 0 .031.057a19.9 19.9 0 0 0 5.993 3.03a.078.078 0 0 0 .084-.028a14.09 14.09 0 0 0 1.226-1.994a.076.076 0 0 0-.041-.106a13.107 13.107 0 0 1-1.872-.892a.077.077 0 0 1-.008-.128a10.2 10.2 0 0 0 .372-.292a.074.074 0 0 1 .077-.01c3.928 1.793 8.18 1.793 12.062 0a.074.074 0 0 1 .078.01c.12.098.246.198.373.292a.077.077 0 0 1-.006.127a12.299 12.299 0 0 1-1.873.892a.077.077 0 0 0-.041.107c.36.698.772 1.362 1.225 1.993a.076.076 0 0 0 .084.028a19.839 19.839 0 0 0 6.002-3.03a.077.077 0 0 0 .032-.054c.5-5.177-.838-9.674-3.549-13.66a.061.061 0 0 0-.031-.03zM8.02 15.33c-1.183 0-2.157-1.085-2.157-2.419c0-1.333.956-2.419 2.157-2.419c1.21 0 2.176 1.096 2.157 2.42c0 1.333-.956 2.418-2.157 2.418zm7.975 0c-1.183 0-2.157-1.085-2.157-2.419c0-1.333.955-2.419 2.157-2.419c1.21 0 2.176 1.096 2.157 2.42c0 1.333-.946 2.418-2.157 2.418z%22/%3E%3C/svg%3E')",
+              WebkitMaskRepeat: 'no-repeat',
+              WebkitMaskPosition: 'center center',
+            }}
+          />
+        </Link>
+      </div>
     </div>
   )
 
   return (
     <>
       <StructuredData
-        title={page.data.title}
-        description={page.data.description || ''}
+        title={data.title}
+        description={data.description || ''}
         url={`${baseUrl}${page.url}`}
         lang={params.lang}
+        breadcrumb={breadcrumbs}
       />
       <DocsPage
-        toc={page.data.toc}
-        full={page.data.full}
+        toc={data.toc}
+        full={data.full}
+        breadcrumb={{
+          enabled: false,
+        }}
         tableOfContent={{
           style: 'clerk',
           enabled: true,
-          header: <div className='mb-2 font-medium text-sm'>On this page</div>,
+          header: (
+            <div key='toc-header' className='mb-2 font-medium text-sm'>
+              On this page
+            </div>
+          ),
+          footer: <TOCFooter />,
           single: false,
         }}
-        article={{
-          className: 'scroll-smooth max-sm:pb-16',
-        }}
         tableOfContentPopover={{
           style: 'clerk',
           enabled: true,
@@ -79,10 +202,41 @@ export default async function Page(props: { params: Promise<{ slug?: string[]; l
           component: <CustomFooter />,
         }}
       >
-        <DocsTitle>{page.data.title}</DocsTitle>
-        <DocsDescription>{page.data.description}</DocsDescription>
+        <div className='relative mt-6 sm:mt-0'>
+          <div className='absolute top-1 right-0 flex items-center gap-2'>
+            <div className='hidden sm:flex'>
+              <LLMCopyButton markdownUrl={`${page.url}.mdx`} />
+            </div>
+            <PageNavigationArrows previous={neighbours?.previous} next={neighbours?.next} />
+          </div>
+          <DocsTitle>{data.title}</DocsTitle>
+          <DocsDescription>{data.description}</DocsDescription>
+        </div>
         <DocsBody>
-          <MDX components={defaultMdxComponents} />
+          <MDX
+            components={{
+              ...defaultMdxComponents,
+              CodeBlock,
+              h1: (props: React.HTMLAttributes<HTMLHeadingElement>) => (
+                <Heading as='h1' {...props} />
+              ),
+              h2: (props: React.HTMLAttributes<HTMLHeadingElement>) => (
+                <Heading as='h2' {...props} />
+              ),
+              h3: (props: React.HTMLAttributes<HTMLHeadingElement>) => (
+                <Heading as='h3' {...props} />
+              ),
+              h4: (props: React.HTMLAttributes<HTMLHeadingElement>) => (
+                <Heading as='h4' {...props} />
+              ),
+              h5: (props: React.HTMLAttributes<HTMLHeadingElement>) => (
+                <Heading as='h5' {...props} />
+              ),
+              h6: (props: React.HTMLAttributes<HTMLHeadingElement>) => (
+                <Heading as='h6' {...props} />
+              ),
+            }}
+          />
         </DocsBody>
       </DocsPage>
     </>
@@ -100,13 +254,17 @@ export async function generateMetadata(props: {
   const page = source.getPage(params.slug, params.lang)
   if (!page) notFound()
 
+  const data = page.data as PageData
   const baseUrl = 'https://docs.sim.ai'
   const fullUrl = `${baseUrl}${page.url}`
 
+  const description = data.description || ''
+  const ogImageUrl = `${baseUrl}/api/og?title=${encodeURIComponent(data.title)}&category=DOCUMENTATION${description ? `&description=${encodeURIComponent(description)}` : ''}`
+
   return {
-    title: page.data.title,
+    title: data.title,
     description:
-      page.data.description || 'Sim visual workflow builder for AI applications documentation',
+      data.description || 'Sim visual workflow builder for AI applications documentation',
     keywords: [
       'AI workflow builder',
       'visual workflow editor',
@@ -115,27 +273,40 @@ export async function generateMetadata(props: {
       'AI agents',
       'no-code AI',
       'drag and drop workflows',
-      page.data.title?.toLowerCase().split(' '),
+      data.title?.toLowerCase().split(' '),
     ]
       .flat()
       .filter(Boolean),
     authors: [{ name: 'Sim Team' }],
     category: 'Developer Tools',
     openGraph: {
-      title: page.data.title,
+      title: data.title,
       description:
-        page.data.description || 'Sim visual workflow builder for AI applications documentation',
+        data.description || 'Sim visual workflow builder for AI applications documentation',
       url: fullUrl,
       siteName: 'Sim Documentation',
       type: 'article',
-      locale: params.lang,
-      alternateLocale: ['en', 'fr', 'zh'].filter((lang) => lang !== params.lang),
+      locale: params.lang === 'en' ? 'en_US' : `${params.lang}_${params.lang.toUpperCase()}`,
+      alternateLocale: ['en', 'es', 'fr', 'de', 'ja', 'zh']
+        .filter((lang) => lang !== params.lang)
+        .map((lang) => (lang === 'en' ? 'en_US' : `${lang}_${lang.toUpperCase()}`)),
+      images: [
+        {
+          url: ogImageUrl,
+          width: 1200,
+          height: 630,
+          alt: data.title,
+        },
+      ],
     },
     twitter: {
-      card: 'summary',
-      title: page.data.title,
+      card: 'summary_large_image',
+      title: data.title,
       description:
-        page.data.description || 'Sim visual workflow builder for AI applications documentation',
+        data.description || 'Sim visual workflow builder for AI applications documentation',
+      images: [ogImageUrl],
+      creator: '@simdotai',
+      site: '@simdotai',
     },
     robots: {
       index: true,
@@ -152,8 +323,12 @@ export async function generateMetadata(props: {
     alternates: {
       canonical: fullUrl,
       languages: {
-        en: `${baseUrl}/en${page.url.replace(`/${params.lang}`, '')}`,
+        'x-default': `${baseUrl}${page.url.replace(`/${params.lang}`, '')}`,
+        en: `${baseUrl}${page.url.replace(`/${params.lang}`, '')}`,
+        es: `${baseUrl}/es${page.url.replace(`/${params.lang}`, '')}`,
         fr: `${baseUrl}/fr${page.url.replace(`/${params.lang}`, '')}`,
+        de: `${baseUrl}/de${page.url.replace(`/${params.lang}`, '')}`,
+        ja: `${baseUrl}/ja${page.url.replace(`/${params.lang}`, '')}`,
         zh: `${baseUrl}/zh${page.url.replace(`/${params.lang}`, '')}`,
       },
     },

apps/docs/app/[lang]/layout.tsx

@@ -2,18 +2,26 @@ import type { ReactNode } from 'react'
 import { defineI18nUI } from 'fumadocs-ui/i18n'
 import { DocsLayout } from 'fumadocs-ui/layouts/docs'
 import { RootProvider } from 'fumadocs-ui/provider/next'
-import { ExternalLink, GithubIcon } from 'lucide-react'
-import { Inter } from 'next/font/google'
+import { Geist_Mono, Inter } from 'next/font/google'
 import Image from 'next/image'
-import Link from 'next/link'
-import { LanguageDropdown } from '@/components/ui/language-dropdown'
+import {
+  SidebarFolder,
+  SidebarItem,
+  SidebarSeparator,
+} from '@/components/docs-layout/sidebar-components'
+import { Navbar } from '@/components/navbar/navbar'
 import { i18n } from '@/lib/i18n'
 import { source } from '@/lib/source'
 import '../global.css'
-import { Analytics } from '@vercel/analytics/next'
 
 const inter = Inter({
   subsets: ['latin'],
+  variable: '--font-geist-sans',
+})
+
+const geistMono = Geist_Mono({
+  subsets: ['latin'],
+  variable: '--font-geist-mono',
 })
 
 const { provider } = defineI18nUI(i18n, {
@@ -27,25 +35,18 @@ const { provider } = defineI18nUI(i18n, {
     fr: {
       displayName: 'Français',
     },
+    de: {
+      displayName: 'Deutsch',
+    },
+    ja: {
+      displayName: '日本語',
+    },
     zh: {
       displayName: '简体中文',
     },
   },
 })
 
-const GitHubLink = () => (
-  <div className='fixed right-4 bottom-4 z-50'>
-    <Link
-      href='https://github.com/simstudioai/sim'
-      target='_blank'
-      rel='noopener noreferrer'
-      className='flex h-8 w-8 items-center justify-center rounded-full border border-border bg-background transition-colors hover:bg-muted'
-    >
-      <GithubIcon className='h-4 w-4' />
-    </Link>
-  </div>
-)
-
 type LayoutProps = {
   children: ReactNode
   params: Promise<{ lang: string }>
@@ -54,44 +55,81 @@ type LayoutProps = {
 export default async function Layout({ children, params }: LayoutProps) {
   const { lang } = await params
 
+  const structuredData = {
+    '@context': 'https://schema.org',
+    '@type': 'WebSite',
+    name: 'Sim Documentation',
+    description:
+      'Comprehensive documentation for Sim - the visual workflow builder for AI Agent Workflows.',
+    url: 'https://docs.sim.ai',
+    publisher: {
+      '@type': 'Organization',
+      name: 'Sim',
+      url: 'https://sim.ai',
+      logo: {
+        '@type': 'ImageObject',
+        url: 'https://docs.sim.ai/static/logo.png',
+      },
+    },
+    inLanguage: lang,
+    potentialAction: {
+      '@type': 'SearchAction',
+      target: {
+        '@type': 'EntryPoint',
+        urlTemplate: 'https://docs.sim.ai/api/search?q={search_term_string}',
+      },
+      'query-input': 'required name=search_term_string',
+    },
+  }
+
   return (
-    <html lang={lang} className={inter.className} suppressHydrationWarning>
-      <body className='flex min-h-screen flex-col'>
+    <html
+      lang={lang}
+      className={`${inter.variable} ${geistMono.variable}`}
+      suppressHydrationWarning
+    >
+      <head>
+        <script
+          type='application/ld+json'
+          dangerouslySetInnerHTML={{ __html: JSON.stringify(structuredData) }}
+        />
+        {/* OneDollarStats Analytics - CDN script handles everything automatically */}
+        <script defer src='https://assets.onedollarstats.com/stonks.js' />
+      </head>
+      <body className='flex min-h-screen flex-col font-sans'>
         <RootProvider i18n={provider(lang)}>
+          <Navbar />
           <DocsLayout
             tree={source.pageTree[lang]}
             nav={{
               title: (
-                <div className='flex items-center gap-3'>
-                  <Image
-                    src='/static/logo.png'
-                    alt='Sim'
-                    width={60}
-                    height={24}
-                    className='h-6 w-auto'
-                  />
-                  <LanguageDropdown />
-                </div>
+                <Image
+                  src='/static/logo.png'
+                  alt='Sim'
+                  width={72}
+                  height={28}
+                  className='h-7 w-auto'
+                  priority
+                />
               ),
             }}
-            links={[
-              {
-                text: 'Visit Sim',
-                url: 'https://sim.ai',
-                icon: <ExternalLink className='h-4 w-4' />,
-              },
-            ]}
             sidebar={{
               defaultOpenLevel: 0,
-              collapsible: true,
+              collapsible: false,
               footer: null,
               banner: null,
+              components: {
+                Item: SidebarItem,
+                Folder: SidebarFolder,
+                Separator: SidebarSeparator,
+              },
+            }}
+            containerProps={{
+              className: '!pt-0',
             }}
           >
             {children}
           </DocsLayout>
-          <GitHubLink />
-          <Analytics />
         </RootProvider>
       </body>
     </html>

apps/docs/app/[lang]/not-found.tsx

@@ -0,0 +1,23 @@
+import { DocsBody, DocsPage } from 'fumadocs-ui/page'
+
+export const metadata = {
+  title: 'Page Not Found',
+}
+
+export default function NotFound() {
+  return (
+    <DocsPage>
+      <DocsBody>
+        <div className='flex min-h-[60vh] flex-col items-center justify-center text-center'>
+          <h1 className='mb-4 bg-gradient-to-b from-[#8357FF] to-[#6F3DFA] bg-clip-text font-bold text-8xl text-transparent'>
+            404
+          </h1>
+          <h2 className='mb-2 font-semibold text-2xl text-foreground'>Page Not Found</h2>
+          <p className='text-muted-foreground'>
+            The page you're looking for doesn't exist or has been moved.
+          </p>
+        </div>
+      </DocsBody>
+    </DocsPage>
+  )
+}

apps/docs/app/api/og/route.tsx

@@ -0,0 +1,185 @@
+import { ImageResponse } from 'next/og'
+import type { NextRequest } from 'next/server'
+
+export const runtime = 'edge'
+
+const TITLE_FONT_SIZE = {
+  large: 64,
+  medium: 56,
+  small: 48,
+} as const
+
+function getTitleFontSize(title: string): number {
+  if (title.length > 45) return TITLE_FONT_SIZE.small
+  if (title.length > 30) return TITLE_FONT_SIZE.medium
+  return TITLE_FONT_SIZE.large
+}
+
+/**
+ * Loads a Google Font dynamically by fetching the CSS and extracting the font URL.
+ */
+async function loadGoogleFont(font: string, weights: string, text: string): Promise<ArrayBuffer> {
+  const url = `https://fonts.googleapis.com/css2?family=${font}:wght@${weights}&text=${encodeURIComponent(text)}`
+  const css = await (await fetch(url)).text()
+  const resource = css.match(/src: url\((.+)\) format\('(opentype|truetype)'\)/)
+
+  if (resource) {
+    const response = await fetch(resource[1])
+    if (response.status === 200) {
+      return await response.arrayBuffer()
+    }
+  }
+
+  throw new Error('Failed to load font data')
+}
+
+/**
+ * Generates dynamic Open Graph images for documentation pages.
+ */
+export async function GET(request: NextRequest) {
+  const { searchParams } = new URL(request.url)
+  const title = searchParams.get('title') || 'Documentation'
+  const category = searchParams.get('category') || 'DOCUMENTATION'
+  const description = searchParams.get('description') || ''
+
+  const baseUrl = new URL(request.url).origin
+
+  const allText = `${title}${category}${description}docs.sim.ai`
+  const fontData = await loadGoogleFont('Geist', '400;500;600', allText)
+
+  return new ImageResponse(
+    <div
+      style={{
+        height: '100%',
+        width: '100%',
+        display: 'flex',
+        flexDirection: 'column',
+        background: '#0c0c0c',
+        position: 'relative',
+        fontFamily: 'Geist',
+      }}
+    >
+      {/* Base gradient layer - very subtle purple tint across the entire image */}
+      <div
+        style={{
+          position: 'absolute',
+          top: 0,
+          left: 0,
+          width: '100%',
+          height: '100%',
+          background:
+            'radial-gradient(ellipse 150% 100% at 50% 100%, rgba(88, 28, 135, 0.15) 0%, rgba(88, 28, 135, 0.08) 25%, rgba(88, 28, 135, 0.03) 50%, transparent 80%)',
+          display: 'flex',
+        }}
+      />
+
+      {/* Secondary glow - adds depth without harsh edges */}
+      <div
+        style={{
+          position: 'absolute',
+          top: 0,
+          left: 0,
+          width: '100%',
+          height: '100%',
+          background:
+            'radial-gradient(ellipse 100% 80% at 80% 90%, rgba(112, 31, 252, 0.12) 0%, rgba(112, 31, 252, 0.04) 40%, transparent 70%)',
+          display: 'flex',
+        }}
+      />
+
+      {/* Top darkening - creates natural vignette */}
+      <div
+        style={{
+          position: 'absolute',
+          top: 0,
+          left: 0,
+          width: '100%',
+          height: '100%',
+          background:
+            'linear-gradient(180deg, rgba(0, 0, 0, 0.3) 0%, transparent 40%, transparent 100%)',
+          display: 'flex',
+        }}
+      />
+
+      {/* Content */}
+      <div
+        style={{
+          display: 'flex',
+          flexDirection: 'column',
+          padding: '56px 72px',
+          height: '100%',
+          justifyContent: 'space-between',
+        }}
+      >
+        {/* Logo */}
+        <img src={`${baseUrl}/static/logo.png`} alt='sim' height={32} />
+
+        {/* Category + Title + Description */}
+        <div
+          style={{
+            display: 'flex',
+            flexDirection: 'column',
+            gap: 12,
+          }}
+        >
+          <span
+            style={{
+              fontSize: 15,
+              fontWeight: 600,
+              color: '#802fff',
+              letterSpacing: '0.02em',
+            }}
+          >
+            {category}
+          </span>
+          <span
+            style={{
+              fontSize: getTitleFontSize(title),
+              fontWeight: 600,
+              color: '#ffffff',
+              lineHeight: 1.1,
+              letterSpacing: '-0.02em',
+            }}
+          >
+            {title}
+          </span>
+          {description && (
+            <span
+              style={{
+                fontSize: 18,
+                fontWeight: 400,
+                color: '#a1a1aa',
+                lineHeight: 1.4,
+                marginTop: 4,
+              }}
+            >
+              {description.length > 100 ? `${description.slice(0, 100)}...` : description}
+            </span>
+          )}
+        </div>
+
+        {/* Footer */}
+        <span
+          style={{
+            fontSize: 15,
+            fontWeight: 500,
+            color: '#52525b',
+          }}
+        >
+          docs.sim.ai
+        </span>
+      </div>
+    </div>,
+    {
+      width: 1200,
+      height: 630,
+      fonts: [
+        {
+          name: 'Geist',
+          data: fontData,
+          style: 'normal',
+        },
+      ],
+    }
+  )
+}

apps/docs/app/api/search/route.ts

@@ -1,4 +1,16 @@
 import { createFromSource } from 'fumadocs-core/search/server'
 import { source } from '@/lib/source'
 
-export const { GET } = createFromSource(source)
+export const revalidate = 3600 // Revalidate every hour
+
+export const { GET } = createFromSource(source, {
+  localeMap: {
+    en: { language: 'english' },
+    es: { language: 'spanish' },
+    fr: { language: 'french' },
+    de: { language: 'german' },
+    // ja and zh are not supported by the stemmer library, so we'll skip language config for them
+    ja: {},
+    zh: {},
+  },
+})

apps/docs/app/global.css

@@ -2,8 +2,27 @@
 @import "fumadocs-ui/css/neutral.css";
 @import "fumadocs-ui/css/preset.css";
 
+/* Prevent overscroll bounce effect on the page */
+html,
+body {
+  overscroll-behavior: none;
+}
+
 @theme {
   --color-fd-primary: #802fff; /* Purple from control-bar component */
+  --font-geist-sans: var(--font-geist-sans);
+  --font-geist-mono: var(--font-geist-mono);
+}
+
+/* Font family utilities */
+.font-sans {
+  font-family: var(--font-geist-sans), ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont,
+    "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+}
+
+.font-mono {
+  font-family: var(--font-geist-mono), ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas,
+    "Liberation Mono", "Courier New", monospace;
 }
 
 /* Target any potential border classes */
@@ -15,139 +34,462 @@
 :root {
   --fd-border: transparent !important;
   --fd-border-sidebar: transparent !important;
+  --fd-nav-height: 64px; /* Custom navbar height (h-16 = 4rem = 64px) */
+  /* Content container width used to center main content */
+  --spacing-fd-container: 1400px;
+  /* Edge gutter = leftover space on each side of centered container */
+  --edge-gutter: max(1rem, calc((100vw - var(--spacing-fd-container)) / 2));
+  /* Shift the sidebar slightly left from the content edge for extra breathing room */
+  --sidebar-shift: 90px;
+  --sidebar-offset: max(0px, calc(var(--edge-gutter) - var(--sidebar-shift)));
+  /* Shift TOC slightly right to match sidebar spacing for symmetry */
+  --toc-shift: 90px;
+  --toc-offset: max(0px, calc(var(--edge-gutter) - var(--toc-shift)));
+  /* Sidebar and TOC have 20px internal padding - navbar accounts for this directly */
+  /* Extra gap between sidebar/TOC and the main text content */
+  --content-gap: 1.75rem;
 }
 
-/* Sidebar improvements for cleaner design */
-[data-sidebar] {
-  --fd-sidebar-width: 280px;
-  background-color: rgb(255 255 255);
-  padding-top: 16px;
+/* Remove custom layout variable overrides to fallback to fumadocs defaults */
+
+/* ============================================
+   Navbar Light Mode Styling
+   ============================================ */
+
+/* Light mode navbar and search styling */
+:root:not(.dark) nav {
+  background-color: hsla(0, 0%, 96%, 0.85) !important;
 }
 
-/* Clean sidebar container */
-[data-sidebar] > div {
-  padding: 0 16px;
+:root:not(.dark) nav button[type="button"] {
+  background-color: hsla(0, 0%, 93%, 0.85) !important;
+  backdrop-filter: blur(33px) saturate(180%) !important;
+  -webkit-backdrop-filter: blur(33px) saturate(180%) !important;
+  color: rgba(0, 0, 0, 0.6) !important;
 }
 
-/* Section headers/separators styling */
-[data-sidebar] .text-sm.font-medium.text-muted-foreground,
-[data-sidebar] [data-separator] {
-  font-size: 11px;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
-  margin-top: 20px;
-  margin-bottom: 6px;
-  padding-left: 12px;
-  padding-right: 12px;
-  color: rgb(115 115 115);
-  border: none;
-  background: none;
+:root:not(.dark) nav button[type="button"] kbd {
+  color: rgba(0, 0, 0, 0.6) !important;
 }
 
-/* First separator should have less top margin */
-[data-sidebar] [data-separator]:first-of-type {
-  margin-top: 12px;
+/* Dark mode navbar and search styling */
+:root.dark nav {
+  background-color: hsla(0, 0%, 7.04%, 0.92) !important;
+  backdrop-filter: blur(25px) saturate(180%) brightness(0.6) !important;
+  -webkit-backdrop-filter: blur(25px) saturate(180%) brightness(0.6) !important;
 }
 
-/* Clean sidebar item styling */
-[data-sidebar] a {
-  padding: 8px 12px;
-  margin: 1px 0;
-  border-radius: 6px;
-  font-size: 14px;
-  font-weight: 400;
-  line-height: 1.4;
-  transition: all 0.15s ease;
+/* ============================================
+   Custom Sidebar Styling (Turborepo-inspired)
+   ============================================ */
+
+/* Floating sidebar appearance - remove background */
+[data-sidebar-container],
+#nd-sidebar {
+  background: transparent !important;
+  background-color: transparent !important;
+  border: none !important;
+  --color-fd-muted: transparent !important;
+  --color-fd-card: transparent !important;
+  --color-fd-secondary: transparent !important;
+}
+
+aside[data-sidebar],
+aside#nd-sidebar {
+  background: transparent !important;
+  background-color: transparent !important;
+  border: none !important;
+  border-right: none !important;
+}
+
+/* Fumadocs v16: Add sidebar placeholder styling for grid area */
+[data-sidebar-placeholder] {
+  background: transparent !important;
+}
+
+/* Fumadocs v16: Hide sidebar panel (floating collapse button) */
+[data-sidebar-panel] {
+  display: none !important;
+}
+
+/* Mobile only: Reduce gap between navbar and content */
+@media (max-width: 1023px) {
+  #nd-docs-layout {
+    margin-top: -25px;
+  }
+}
+
+/* Desktop only: Apply custom navbar offset, sidebar width and margin offsets */
+/* On mobile, let fumadocs handle the layout natively */
+@media (min-width: 1024px) {
+  :root {
+    --fd-banner-height: 64px !important;
+  }
+
+  #nd-docs-layout {
+    --fd-docs-height: calc(100dvh - 64px) !important;
+    --fd-sidebar-width: 300px !important;
+    margin-left: var(--sidebar-offset) !important;
+    margin-right: var(--toc-offset) !important;
+  }
+
+  /* Hide fumadocs nav on desktop - we use custom navbar there */
+  #nd-docs-layout > header {
+    display: none !important;
+  }
+}
+
+/* Sidebar spacing - compact like turborepo */
+/* Fumadocs v16: [data-sidebar-viewport] doesn't exist, target #nd-sidebar > div instead */
+[data-sidebar-viewport],
+#nd-sidebar > div {
+  padding: 0.5rem 12px 12px;
+  background: transparent !important;
+  background-color: transparent !important;
+}
+
+/* Override sidebar item styling to match Raindrop */
+/* Target Link and button elements in sidebar - override Fumadocs itemVariants */
+/* Exclude the small chevron-only toggle buttons */
+/* Using html prefix for higher specificity over Tailwind v4 utilities */
+html #nd-sidebar a,
+html #nd-sidebar button:not([aria-label*="ollapse"]):not([aria-label*="xpand"]) {
+  font-size: 0.9375rem !important; /* 15px to match Raindrop */
+  line-height: 1.4 !important;
+  padding: 0.5rem 0.75rem !important; /* More compact like Raindrop */
+  font-weight: 400 !important;
+  border-radius: 0.75rem !important; /* More rounded like Raindrop */
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial,
+    sans-serif !important;
+}
+
+/* Dark mode sidebar text */
+html.dark #nd-sidebar a,
+html.dark #nd-sidebar button:not([aria-label*="ollapse"]):not([aria-label*="xpand"]) {
+  color: rgba(255, 255, 255, 0.6) !important;
+}
+
+/* Light mode sidebar text */
+html:not(.dark) #nd-sidebar a,
+html:not(.dark) #nd-sidebar button:not([aria-label*="ollapse"]):not([aria-label*="xpand"]) {
+  color: rgba(0, 0, 0, 0.6) !important;
+}
+
+/* Make sure chevron icons are visible and properly styled */
+#nd-sidebar svg {
+  display: inline-block !important;
+  opacity: 0.6 !important;
+  flex-shrink: 0 !important;
+  width: 0.75rem !important;
+  height: 0.75rem !important;
+}
+
+/* Ensure the small chevron toggle buttons are visible */
+#nd-sidebar button[aria-label*="ollapse"],
+#nd-sidebar button[aria-label*="xpand"] {
+  display: flex !important;
+  opacity: 1 !important;
+  padding: 0.25rem !important;
+}
+
+/* Root-level spacing now handled by [data-sidebar-viewport] > * rule below */
+
+/* Add tiny gap between nested items */
+#nd-sidebar ul li {
+  margin-bottom: 0.0625rem !important;
+}
+
+#nd-sidebar ul li:last-child {
+  margin-bottom: 0 !important;
+}
+
+/* Section headers should be slightly larger */
+/* Fumadocs v16: Also target #nd-sidebar for compatibility */
+[data-sidebar-viewport] [data-separator],
+#nd-sidebar [data-separator],
+#nd-sidebar p {
+  font-size: 0.75rem !important;
+  font-weight: 600 !important;
+  text-transform: uppercase !important;
+  letter-spacing: 0.05em !important;
+}
+
+/* Override active state (NO PURPLE) */
+#nd-sidebar a[data-active="true"],
+#nd-sidebar button[data-active="true"],
+#nd-sidebar a.bg-fd-primary\/10,
+#nd-sidebar a.text-fd-primary,
+#nd-sidebar a[class*="bg-fd-primary"],
+#nd-sidebar a[class*="text-fd-primary"],
+/* Override custom sidebar purple classes */
+  #nd-sidebar
+  a.bg-purple-50\/80,
+#nd-sidebar a.text-purple-600,
+#nd-sidebar a[class*="bg-purple"],
+#nd-sidebar a[class*="text-purple"] {
+  background-image: none !important;
+}
+
+/* Dark mode active state */
+html.dark #nd-sidebar a[data-active="true"],
+html.dark #nd-sidebar button[data-active="true"],
+html.dark #nd-sidebar a.bg-fd-primary\/10,
+html.dark #nd-sidebar a.text-fd-primary,
+html.dark #nd-sidebar a[class*="bg-fd-primary"],
+html.dark #nd-sidebar a[class*="text-fd-primary"],
+html.dark #nd-sidebar a.bg-purple-50\/80,
+html.dark #nd-sidebar a.text-purple-600,
+html.dark #nd-sidebar a[class*="bg-purple"],
+html.dark #nd-sidebar a[class*="text-purple"] {
+  background-color: rgba(255, 255, 255, 0.15) !important;
+  color: rgba(255, 255, 255, 1) !important;
+}
+
+/* Light mode active state */
+html:not(.dark) #nd-sidebar a[data-active="true"],
+html:not(.dark) #nd-sidebar button[data-active="true"],
+html:not(.dark) #nd-sidebar a.bg-fd-primary\/10,
+html:not(.dark) #nd-sidebar a.text-fd-primary,
+html:not(.dark) #nd-sidebar a[class*="bg-fd-primary"],
+html:not(.dark) #nd-sidebar a[class*="text-fd-primary"],
+html:not(.dark) #nd-sidebar a.bg-purple-50\/80,
+html:not(.dark) #nd-sidebar a.text-purple-600,
+html:not(.dark) #nd-sidebar a[class*="bg-purple"],
+html:not(.dark) #nd-sidebar a[class*="text-purple"] {
+  background-color: rgba(0, 0, 0, 0.07) !important;
+  color: rgba(0, 0, 0, 0.9) !important;
+}
+
+/* Dark mode hover state */
+html.dark #nd-sidebar a:hover:not([data-active="true"]),
+html.dark #nd-sidebar button:hover:not([data-active="true"]) {
+  background-color: rgba(255, 255, 255, 0.08) !important;
+}
+
+/* Light mode hover state */
+html:not(.dark) #nd-sidebar a:hover:not([data-active="true"]),
+html:not(.dark) #nd-sidebar button:hover:not([data-active="true"]) {
+  background-color: rgba(0, 0, 0, 0.03) !important;
+}
+
+/* Dark mode - ensure active/selected items don't change on hover */
+html.dark #nd-sidebar a.bg-purple-50\/80:hover,
+html.dark #nd-sidebar a[class*="bg-purple"]:hover,
+html.dark #nd-sidebar a[data-active="true"]:hover,
+html.dark #nd-sidebar button[data-active="true"]:hover {
+  background-color: rgba(255, 255, 255, 0.15) !important;
+  color: rgba(255, 255, 255, 1) !important;
+}
+
+/* Light mode - ensure active/selected items don't change on hover */
+html:not(.dark) #nd-sidebar a.bg-purple-50\/80:hover,
+html:not(.dark) #nd-sidebar a[class*="bg-purple"]:hover,
+html:not(.dark) #nd-sidebar a[data-active="true"]:hover,
+html:not(.dark) #nd-sidebar button[data-active="true"]:hover {
+  background-color: rgba(0, 0, 0, 0.07) !important;
+  color: rgba(0, 0, 0, 0.9) !important;
+}
+
+/* Hide search, platform, and collapse button from sidebar completely */
+[data-sidebar] [data-search],
+[data-sidebar] .search-toggle,
+#nd-sidebar [data-search],
+#nd-sidebar .search-toggle,
+[data-sidebar-viewport] [data-search],
+[data-sidebar-viewport] button[data-search],
+aside[data-sidebar] [role="button"]:has([data-search]),
+aside[data-sidebar] > div > button:first-child,
+#nd-sidebar > div > button:first-child,
+[data-sidebar] a[href*="sim.ai"],
+#nd-sidebar a[href*="sim.ai"],
+[data-sidebar-viewport] a[href*="sim.ai"],
+/* Hide search buttons (but NOT folder chevron buttons) */
+  aside[data-sidebar] > div:first-child
+  > button:not([aria-label="Collapse"]):not([aria-label="Expand"]),
+#nd-sidebar > div:first-child > button:not([aria-label="Collapse"]):not([aria-label="Expand"]),
+/* Hide sidebar collapse button (panel icon) - direct children only */
+aside[data-sidebar] > button:first-of-type:not([aria-label="Collapse"]):not([aria-label="Expand"]),
+[data-sidebar]
+  > button[type="button"]:first-of-type:not([aria-label="Collapse"]):not([aria-label="Expand"]),
+button[data-collapse]:not([aria-label="Collapse"]):not([aria-label="Expand"]),
+[data-sidebar-header] button,
+/* Hide theme toggle from sidebar footer */
+aside[data-sidebar] [data-theme-toggle],
+[data-sidebar-footer],
+[data-sidebar] footer,
+footer button[aria-label*="heme"],
+aside[data-sidebar] > div:last-child:has(button[aria-label*="heme"]),
+aside[data-sidebar] button[aria-label*="heme"],
+[data-sidebar] button[aria-label*="Theme"],
+/* Additional theme toggle selectors */
+  aside[data-sidebar] > *:last-child
+  button,
+[data-sidebar-viewport] ~ *,
+aside[data-sidebar] > div:not([data-sidebar-viewport]),
+/* Aggressive theme toggle hiding */
+aside[data-sidebar] svg[class*="sun"],
+aside[data-sidebar] svg[class*="moon"],
+aside[data-sidebar] button[type="button"]:last-child,
+aside button:has(svg:only-child),
+[data-sidebar] div:has(> button[type="button"]:only-child:last-child),
+/* Hide theme toggle and other non-content elements */
+aside[data-sidebar] > *:not([data-sidebar-viewport]) {
+  display: none !important;
+  visibility: hidden !important;
+  opacity: 0 !important;
+  height: 0 !important;
+  max-height: 0 !important;
+  overflow: hidden !important;
+  pointer-events: none !important;
+  position: absolute !important;
+  left: -9999px !important;
+}
+
+/* Desktop only: Hide sidebar toggle buttons and nav title/logo (keep visible on mobile) */
+@media (min-width: 1025px) {
+  [data-sidebar-container] > button,
+  [data-sidebar-container] [data-toggle],
+  aside[data-sidebar] [data-sidebar-toggle],
+  button[data-sidebar-toggle],
+  nav button[data-sidebar-toggle],
+  button[aria-label="Toggle Sidebar"],
+  button[aria-label="Collapse Sidebar"],
+  /* Hide nav title/logo in sidebar on desktop - target all possible locations */
+  aside[data-sidebar] a[href="/"],
+  aside[data-sidebar] a[href="/"] img,
+  aside[data-sidebar] > a:first-child,
+  aside[data-sidebar] > div > a:first-child,
+  aside[data-sidebar] img[alt="Sim"],
+  [data-sidebar-header],
+  [data-sidebar] [data-title],
+  #nd-sidebar > a:first-child,
+  #nd-sidebar > div:first-child > a:first-child,
+  #nd-sidebar img[alt="Sim"],
+  /* Hide theme toggle at bottom of sidebar on desktop */
+    #nd-sidebar
+    > footer,
+  #nd-sidebar footer,
+  aside#nd-sidebar > *:last-child:not(div),
+  #nd-sidebar > button:last-child,
+  #nd-sidebar button[aria-label*="theme" i],
+  #nd-sidebar button[aria-label*="Theme"],
+  #nd-sidebar > div:last-child > button {
+    display: none !important;
+    visibility: hidden !important;
+    height: 0 !important;
+    max-height: 0 !important;
+    overflow: hidden !important;
+  }
+}
+
+/* Extra aggressive - hide everything after the viewport */
+aside[data-sidebar] [data-sidebar-viewport] ~ * {
+  display: none !important;
+}
+
+/* Tighter spacing for sidebar content */
+[data-sidebar-viewport] > * {
+  margin-bottom: 0.0625rem;
+}
+
+[data-sidebar-viewport] > *:last-child {
+  margin-bottom: 0;
+}
+
+[data-sidebar-viewport] ul {
+  margin: 0;
+  padding: 0;
+}
+
+/* Ensure sidebar starts with content immediately */
+aside[data-sidebar] > div:first-child {
+  padding-top: 0;
+}
+
+/* Remove all sidebar borders and backgrounds */
+[data-sidebar-container],
+aside[data-sidebar],
+[data-sidebar],
+[data-sidebar] *,
+#nd-sidebar,
+#nd-sidebar * {
+  border: none !important;
+  border-right: none !important;
+  border-left: none !important;
+  border-top: none !important;
+  border-bottom: none !important;
+}
+
+/* Override fumadocs background colors for sidebar */
+.dark #nd-sidebar,
+.dark [data-sidebar-container],
+.dark aside[data-sidebar] {
+  --color-fd-muted: transparent !important;
+  --color-fd-secondary: transparent !important;
+  background: transparent !important;
+  background-color: transparent !important;
+}
+
+/* Force normal text flow in sidebar */
+[data-sidebar],
+[data-sidebar] *,
+[data-sidebar-viewport],
+[data-sidebar-viewport] * {
+  writing-mode: horizontal-tb !important;
+}
+
+/* ============================================
+   Code Block Styling (Improved)
+   ============================================ */
+
+/* Apply Geist Mono to code elements */
+code,
+pre,
+pre code {
+  font-family: var(--font-geist-mono), ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas,
+    "Liberation Mono", "Courier New", monospace;
+}
+
+/* Inline code */
+:not(pre) > code {
+  padding: 0.2em 0.4em;
+  border-radius: 0.25rem;
+  font-size: 0.875em;
+  font-weight: 500;
+}
+
+/* Light mode inline code */
+:root:not(.dark) :not(pre) > code {
+  background-color: rgb(243 244 246);
+  color: rgb(220 38 38);
+  border: 1px solid rgb(229 231 235);
+}
+
+/* Dark mode inline code */
+.dark :not(pre) > code {
+  background-color: rgb(31 41 55);
+  color: rgb(248 113 113);
+  border: 1px solid rgb(55 65 81);
+}
+
+/* Code block container improvements */
+pre {
+  font-size: 0.875rem;
+  line-height: 1.7;
+  tab-size: 2;
+  -webkit-overflow-scrolling: touch;
+}
+
+pre code {
   display: block;
-  color: rgb(71 85 105);
-  text-decoration: none;
+  width: fit-content;
+  min-width: 100%;
 }
 
-[data-sidebar] a[data-active="true"] {
-  background-color: rgba(128, 47, 255, 0.08);
-  color: var(--color-fd-primary);
-  font-weight: 500;
-}
-
-[data-sidebar] a:hover:not([data-active="true"]) {
-  background-color: rgb(248 250 252);
-  color: rgb(51 65 85);
-}
-
-/* Improve spacing between sidebar items */
-[data-sidebar] nav > * + * {
-  margin-top: 2px;
-}
-
-/* Section group styling */
-[data-sidebar] [data-folder] {
-  margin-bottom: 4px;
-}
-
-[data-sidebar] [data-folder] > div:first-child {
-  font-weight: 500;
-  font-size: 13px;
-  color: rgb(15 23 42);
-  padding: 6px 12px;
-  margin-bottom: 4px;
-}
-
-/* Clean up folder toggle buttons */
-[data-sidebar] button[data-folder-toggle] {
-  padding: 4px 8px 4px 12px;
-  border-radius: 6px;
-  font-size: 13px;
-  font-weight: 500;
-  color: rgb(51 65 85);
-}
-
-[data-sidebar] button[data-folder-toggle]:hover {
-  background-color: rgb(248 250 252);
-}
-
-/* Nested item indentation */
-[data-sidebar] [data-folder] a {
-  padding-left: 24px;
-  font-size: 14px;
-}
-
-/* Dark mode adjustments */
-@media (prefers-color-scheme: dark) {
-  [data-sidebar] {
-    background-color: rgb(2 8 23);
-  }
-
-  [data-sidebar] a {
-    color: rgb(148 163 184);
-  }
-
-  [data-sidebar] a:hover:not([data-active="true"]) {
-    background-color: rgb(30 41 59);
-    color: rgb(226 232 240);
-  }
-
-  [data-sidebar] a[data-active="true"] {
-    background-color: rgba(128, 47, 255, 0.15);
-    color: var(--color-fd-primary);
-  }
-
-  [data-sidebar] .text-sm.font-medium.text-muted-foreground,
-  [data-sidebar] [data-separator] {
-    color: rgb(148 163 184);
-  }
-
-  [data-sidebar] [data-folder] > div:first-child {
-    color: rgb(226 232 240);
-  }
-
-  [data-sidebar] button[data-folder-toggle] {
-    color: rgb(148 163 184);
-  }
-
-  [data-sidebar] button[data-folder-toggle]:hover {
-    background-color: rgb(30 41 59);
-  }
+/* Syntax highlighting adjustments for better readability */
+pre code .line {
+  padding-left: 0;
+  padding-right: 0;
 }
 
 /* Custom text highlighting styles */
@@ -162,15 +504,55 @@
 
 /* Add bottom spacing to prevent abrupt page endings */
 [data-content] {
+  padding-top: 1.5rem !important;
   padding-bottom: 4rem;
 }
 
 /* Alternative fallback for different Fumadocs versions */
 main article,
 .docs-page main {
+  padding-top: 1.5rem !important;
   padding-bottom: 4rem;
 }
 
+/* ============================================
+   Center and Constrain Main Content Width
+   ============================================ */
+
+/* Main content area - center and constrain like turborepo/raindrop */
+/* Note: --sidebar-offset and --toc-offset are now applied at #nd-docs-layout level */
+main[data-main] {
+  max-width: var(--spacing-fd-container, 1400px);
+  margin-left: auto;
+  margin-right: auto;
+  padding-top: 1rem;
+  padding-left: var(--content-gap);
+  padding-right: var(--content-gap);
+  order: 1 !important;
+}
+
+/* Adjust for smaller screens */
+@media (max-width: 768px) {
+  main[data-main] {
+    padding-left: 1rem;
+    padding-right: 1rem;
+  }
+}
+
+/* Ensure docs page content is properly constrained */
+[data-docs-page] {
+  max-width: 1400px;
+  margin-left: auto;
+  margin-right: auto;
+  padding-top: 1.5rem !important;
+}
+
+/* Override Fumadocs default content padding */
+article[data-content],
+div[data-content] {
+  padding-top: 1.5rem !important;
+}
+
 /* Remove any unwanted borders/outlines from video elements */
 video {
   outline: none !important;

apps/docs/app/layout.tsx

@@ -22,9 +22,15 @@ export const metadata = {
     'drag and drop workflows',
     'AI integrations',
     'workflow canvas',
-    'AI development platform',
+    'AI Agent Workflow Builder',
+    'workflow orchestration',
+    'agent builder',
+    'AI workflow automation',
+    'visual programming',
   ],
   authors: [{ name: 'Sim Team', url: 'https://sim.ai' }],
+  creator: 'Sim',
+  publisher: 'Sim',
   category: 'Developer Tools',
   classification: 'Developer Documentation',
   manifest: '/favicon/site.webmanifest',
@@ -44,19 +50,29 @@ export const metadata = {
   openGraph: {
     type: 'website',
     locale: 'en_US',
-    alternateLocale: ['fr_FR', 'zh_CN'],
+    alternateLocale: ['es_ES', 'fr_FR', 'de_DE', 'ja_JP', 'zh_CN'],
     url: 'https://docs.sim.ai',
     siteName: 'Sim Documentation',
     title: 'Sim Documentation - Visual Workflow Builder for AI Applications',
     description:
       'Comprehensive documentation for Sim - the visual workflow builder for AI applications. Create powerful AI agents, automation workflows, and data processing pipelines.',
+    images: [
+      {
+        url: 'https://docs.sim.ai/api/og?title=Sim%20Documentation&category=DOCUMENTATION',
+        width: 1200,
+        height: 630,
+        alt: 'Sim Documentation',
+      },
+    ],
   },
   twitter: {
-    card: 'summary',
+    card: 'summary_large_image',
     title: 'Sim Documentation - Visual Workflow Builder for AI Applications',
     description:
       'Comprehensive documentation for Sim - the visual workflow builder for AI applications.',
-    creator: '@sim_ai',
+    creator: '@simdotai',
+    site: '@simdotai',
+    images: ['https://docs.sim.ai/api/og?title=Sim%20Documentation&category=DOCUMENTATION'],
   },
   robots: {
     index: true,
@@ -72,9 +88,13 @@ export const metadata = {
   alternates: {
     canonical: 'https://docs.sim.ai',
     languages: {
-      en: '/en',
-      fr: '/fr',
-      zh: '/zh',
+      'x-default': 'https://docs.sim.ai',
+      en: 'https://docs.sim.ai',
+      es: 'https://docs.sim.ai/es',
+      fr: 'https://docs.sim.ai/fr',
+      de: 'https://docs.sim.ai/de',
+      ja: 'https://docs.sim.ai/ja',
+      zh: 'https://docs.sim.ai/zh',
     },
   },
 }

apps/docs/app/llms-full.txt/route.ts

@@ -0,0 +1,31 @@
+import { getLLMText } from '@/lib/llms'
+import { source } from '@/lib/source'
+
+export const revalidate = false
+
+export async function GET() {
+  try {
+    const pages = source.getPages().filter((page) => {
+      if (!page || !page.data || !page.url) return false
+
+      const pathParts = page.url.split('/').filter(Boolean)
+      const hasLangPrefix = pathParts[0] && ['es', 'fr', 'de', 'ja', 'zh'].includes(pathParts[0])
+
+      return !hasLangPrefix
+    })
+
+    const scan = pages.map((page) => getLLMText(page))
+    const scanned = await Promise.all(scan)
+
+    const filtered = scanned.filter((text) => text && text.length > 0)
+
+    return new Response(filtered.join('\n\n---\n\n'), {
+      headers: {
+        'Content-Type': 'text/plain; charset=utf-8',
+      },
+    })
+  } catch (error) {
+    console.error('Error generating LLM full text:', error)
+    return new Response('Error generating full documentation text', { status: 500 })
+  }
+}

apps/docs/app/llms.mdx/[[...slug]]/route.ts

@@ -1,16 +1,33 @@
 import { notFound } from 'next/navigation'
 import { type NextRequest, NextResponse } from 'next/server'
+import { i18n } from '@/lib/i18n'
 import { getLLMText } from '@/lib/llms'
 import { source } from '@/lib/source'
 
 export const revalidate = false
 
-export async function GET(_req: NextRequest, { params }: { params: Promise<{ slug?: string[] }> }) {
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ slug?: string[] }> }
+) {
   const { slug } = await params
-  const page = source.getPage(slug)
+
+  let lang: (typeof i18n.languages)[number] = i18n.defaultLanguage
+  let pageSlug = slug
+
+  if (slug && slug.length > 0 && i18n.languages.includes(slug[0] as typeof lang)) {
+    lang = slug[0] as typeof lang
+    pageSlug = slug.slice(1)
+  }
+
+  const page = source.getPage(pageSlug, lang)
   if (!page) notFound()
 
-  return new NextResponse(await getLLMText(page))
+  return new NextResponse(await getLLMText(page), {
+    headers: {
+      'Content-Type': 'text/markdown',
+    },
+  })
 }
 
 export function generateStaticParams() {

apps/docs/app/llms.txt/route.ts

@@ -1,11 +1,87 @@
-import { getLLMText } from '@/lib/llms'
 import { source } from '@/lib/source'
 
 export const revalidate = false
 
 export async function GET() {
-  const scan = source.getPages().map(getLLMText)
-  const scanned = await Promise.all(scan)
+  const baseUrl = 'https://docs.sim.ai'
 
-  return new Response(scanned.join('\n\n'))
+  try {
+    const pages = source.getPages().filter((page) => {
+      if (!page || !page.data || !page.url) return false
+
+      const pathParts = page.url.split('/').filter(Boolean)
+      const hasLangPrefix = pathParts[0] && ['es', 'fr', 'de', 'ja', 'zh'].includes(pathParts[0])
+
+      return !hasLangPrefix
+    })
+
+    const sections: Record<string, Array<{ title: string; url: string; description?: string }>> = {}
+
+    pages.forEach((page) => {
+      const pathParts = page.url.split('/').filter(Boolean)
+      const section =
+        pathParts[0] && ['en', 'es', 'fr', 'de', 'ja', 'zh'].includes(pathParts[0])
+          ? pathParts[1] || 'root'
+          : pathParts[0] || 'root'
+
+      if (!sections[section]) {
+        sections[section] = []
+      }
+
+      sections[section].push({
+        title: page.data.title || 'Untitled',
+        url: `${baseUrl}${page.url}`,
+        description: page.data.description,
+      })
+    })
+
+    const manifest = `# Sim Documentation
+
+> Visual Workflow Builder for AI Applications
+
+Sim is a visual workflow builder for AI applications that lets you build AI agent workflows visually. Create powerful AI agents, automation workflows, and data processing pipelines by connecting blocks on a canvas—no coding required.
+
+## Documentation Overview
+
+This file provides an overview of our documentation. For full content of all pages, see ${baseUrl}/llms-full.txt
+
+## Main Sections
+
+${Object.entries(sections)
+  .map(([section, items]) => {
+    const sectionTitle = section
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ')
+    return `### ${sectionTitle}\n\n${items.map((item) => `- ${item.title}: ${item.url}${item.description ? `\n  ${item.description}` : ''}`).join('\n')}`
+  })
+  .join('\n\n')}
+
+## Additional Resources
+
+- Full documentation content: ${baseUrl}/llms-full.txt
+- Individual page content: ${baseUrl}/llms.mdx/[page-path]
+- API documentation: ${baseUrl}/sdks/
+- Tool integrations: ${baseUrl}/tools/
+
+## Statistics
+
+- Total pages: ${pages.length} (English only)
+- Other languages available at: ${baseUrl}/[lang]/ (es, fr, de, ja, zh)
+
+---
+
+Generated: ${new Date().toISOString()}
+Format: llms.txt v0.1.0
+See: https://llmstxt.org for specification`
+
+    return new Response(manifest, {
+      headers: {
+        'Content-Type': 'text/plain; charset=utf-8',
+      },
+    })
+  } catch (error) {
+    console.error('Error generating LLM manifest:', error)
+    return new Response('Error generating documentation manifest', { status: 500 })
+  }
 }

apps/docs/app/robots.txt/route.ts

@@ -9,14 +9,26 @@ export async function GET() {
 User-agent: *
 Allow: /
 
-# Allow all well-behaved crawlers
+# Search engine crawlers
 User-agent: Googlebot
 Allow: /
 
 User-agent: Bingbot
 Allow: /
 
-# AI and LLM crawlers
+User-agent: Slurp
+Allow: /
+
+User-agent: DuckDuckBot
+Allow: /
+
+User-agent: Baiduspider
+Allow: /
+
+User-agent: YandexBot
+Allow: /
+
+# AI and LLM crawlers - explicitly allowed for documentation indexing
 User-agent: GPTBot
 Allow: /
 
@@ -32,6 +44,21 @@ Allow: /
 User-agent: Claude-Web
 Allow: /
 
+User-agent: Applebot
+Allow: /
+
+User-agent: PerplexityBot
+Allow: /
+
+User-agent: Diffbot
+Allow: /
+
+User-agent: FacebookBot
+Allow: /
+
+User-agent: cohere-ai
+Allow: /
+
 # Disallow admin and internal paths (if any exist)
 Disallow: /.next/
 Disallow: /api/internal/
@@ -41,14 +68,29 @@ Disallow: /admin/
 # Allow but don't prioritize these
 Allow: /api/search
 Allow: /llms.txt
+Allow: /llms-full.txt
 Allow: /llms.mdx/
 
 # Sitemaps
 Sitemap: ${baseUrl}/sitemap.xml
 
+# Crawl delay for aggressive bots (optional)
+# Crawl-delay: 1
+
 # Additional resources for AI indexing
 # See https://github.com/AnswerDotAI/llms-txt for more info
-# LLM-friendly content available at: ${baseUrl}/llms.txt`
+# LLM-friendly content:
+#   Manifest: ${baseUrl}/llms.txt
+#   Full content: ${baseUrl}/llms-full.txt
+#   Individual pages: ${baseUrl}/llms.mdx/[page-path]
+
+# Multi-language documentation available at:
+# ${baseUrl}/en - English
+# ${baseUrl}/es - Español
+# ${baseUrl}/fr - Français
+# ${baseUrl}/de - Deutsch
+# ${baseUrl}/ja - 日本語
+# ${baseUrl}/zh - 简体中文`
 
   return new Response(robotsTxt, {
     headers: {

apps/docs/app/sitemap.xml/route.ts

@@ -8,6 +8,14 @@ export async function GET() {
 
   const allPages = source.getPages()
 
+  const getPriority = (url: string): string => {
+    if (url === '/introduction' || url === '/') return '1.0'
+    if (url === '/getting-started') return '0.9'
+    if (url.match(/^\/[^/]+$/)) return '0.8'
+    if (url.includes('/sdks/') || url.includes('/tools/')) return '0.7'
+    return '0.6'
+  }
+
   const urls = allPages
     .flatMap((page) => {
       const urlWithoutLang = page.url.replace(/^\/[a-z]{2}\//, '/')
@@ -22,7 +30,7 @@ export async function GET() {
     <loc>${url}</loc>
     <lastmod>${new Date().toISOString().split('T')[0]}</lastmod>
     <changefreq>weekly</changefreq>
-    <priority>${urlWithoutLang === '/introduction' ? '1.0' : '0.8'}</priority>
+    <priority>${getPriority(urlWithoutLang)}</priority>
     ${i18n.languages.length > 1 ? generateAlternateLinks(baseUrl, urlWithoutLang) : ''}
   </url>`
       })
@@ -37,6 +45,7 @@ ${urls}
   return new Response(sitemap, {
     headers: {
       'Content-Type': 'application/xml',
+      'Cache-Control': 'public, max-age=3600, s-maxage=3600',
     },
   })
 }

apps/docs/cli.json

@@ -0,0 +1,11 @@
+{
+  "aliases": {
+    "uiDir": "./components/ui",
+    "componentsDir": "./components",
+    "blockDir": "./components",
+    "cssDir": "./styles",
+    "libDir": "./lib"
+  },
+  "baseDir": "",
+  "commands": {}
+}

apps/docs/components/docs-layout/page-navigation-arrows.tsx

@@ -0,0 +1,42 @@
+'use client'
+
+import { ChevronLeft, ChevronRight } from 'lucide-react'
+import Link from 'next/link'
+
+interface PageNavigationArrowsProps {
+  previous?: {
+    url: string
+  }
+  next?: {
+    url: string
+  }
+}
+
+export function PageNavigationArrows({ previous, next }: PageNavigationArrowsProps) {
+  if (!previous && !next) return null
+
+  return (
+    <div className='flex items-center gap-2'>
+      {previous && (
+        <Link
+          href={previous.url}
+          className='inline-flex items-center justify-center gap-1.5 rounded-lg border border-border/40 bg-background px-2.5 py-1.5 text-muted-foreground/60 text-sm transition-all hover:border-border hover:bg-accent/50 hover:text-muted-foreground'
+          aria-label='Previous page'
+          title='Previous page'
+        >
+          <ChevronLeft className='h-4 w-4' />
+        </Link>
+      )}
+      {next && (
+        <Link
+          href={next.url}
+          className='inline-flex items-center justify-center gap-1.5 rounded-lg border border-border/40 bg-background px-2.5 py-1.5 text-muted-foreground/60 text-sm transition-all hover:border-border hover:bg-accent/50 hover:text-muted-foreground'
+          aria-label='Next page'
+          title='Next page'
+        >
+          <ChevronRight className='h-4 w-4' />
+        </Link>
+      )}
+    </div>
+  )
+}

apps/docs/components/docs-layout/sidebar-components.tsx

@@ -0,0 +1,206 @@
+'use client'
+
+import { type ReactNode, useEffect, useState } from 'react'
+import type { Folder, Item, Separator } from 'fumadocs-core/page-tree'
+import { ChevronRight } from 'lucide-react'
+import Link from 'next/link'
+import { usePathname } from 'next/navigation'
+import { cn } from '@/lib/utils'
+
+const LANG_PREFIXES = ['/en', '/es', '/fr', '/de', '/ja', '/zh']
+
+function stripLangPrefix(path: string): string {
+  for (const prefix of LANG_PREFIXES) {
+    if (path === prefix) return '/'
+    if (path.startsWith(`${prefix}/`)) return path.slice(prefix.length)
+  }
+  return path
+}
+
+function isActive(url: string, pathname: string, nested = true): boolean {
+  const normalizedPathname = stripLangPrefix(pathname)
+  const normalizedUrl = stripLangPrefix(url)
+  return (
+    normalizedUrl === normalizedPathname ||
+    (nested && normalizedPathname.startsWith(`${normalizedUrl}/`))
+  )
+}
+
+export function SidebarItem({ item }: { item: Item }) {
+  const pathname = usePathname()
+  const active = isActive(item.url, pathname, false)
+
+  return (
+    <Link
+      href={item.url}
+      data-active={active}
+      className={cn(
+        // Mobile styles (default)
+        'flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-sm transition-colors',
+        'text-fd-muted-foreground hover:bg-fd-accent/50 hover:text-fd-accent-foreground',
+        active && 'bg-fd-primary/10 font-medium text-fd-primary',
+        // Desktop styles (lg+)
+        'lg:mb-[0.0625rem] lg:block lg:rounded-md lg:px-2.5 lg:py-1.5 lg:font-normal lg:text-[13px] lg:leading-tight',
+        'lg:text-gray-600 lg:dark:text-gray-400',
+        !active && 'lg:hover:bg-gray-100/60 lg:dark:hover:bg-gray-800/40',
+        active &&
+          'lg:bg-purple-50/80 lg:font-normal lg:text-purple-600 lg:dark:bg-purple-900/15 lg:dark:text-purple-400'
+      )}
+    >
+      {item.name}
+    </Link>
+  )
+}
+
+export function SidebarFolder({ item, children }: { item: Folder; children: ReactNode }) {
+  const pathname = usePathname()
+  const hasActiveChild = checkHasActiveChild(item, pathname)
+  const hasChildren = item.children.length > 0
+  const [open, setOpen] = useState(hasActiveChild)
+
+  useEffect(() => {
+    setOpen(hasActiveChild)
+  }, [hasActiveChild])
+
+  const active = item.index ? isActive(item.index.url, pathname, false) : false
+
+  if (item.index && !hasChildren) {
+    return (
+      <Link
+        href={item.index.url}
+        data-active={active}
+        className={cn(
+          // Mobile styles (default)
+          'flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-sm transition-colors',
+          'text-fd-muted-foreground hover:bg-fd-accent/50 hover:text-fd-accent-foreground',
+          active && 'bg-fd-primary/10 font-medium text-fd-primary',
+          // Desktop styles (lg+)
+          'lg:mb-[0.0625rem] lg:block lg:rounded-md lg:px-2.5 lg:py-1.5 lg:font-normal lg:text-[13px] lg:leading-tight',
+          'lg:text-gray-600 lg:dark:text-gray-400',
+          !active && 'lg:hover:bg-gray-100/60 lg:dark:hover:bg-gray-800/40',
+          active &&
+            'lg:bg-purple-50/80 lg:font-normal lg:text-purple-600 lg:dark:bg-purple-900/15 lg:dark:text-purple-400'
+        )}
+      >
+        {item.name}
+      </Link>
+    )
+  }
+
+  return (
+    <div className='flex flex-col lg:mb-[0.0625rem]'>
+      <div className='flex w-full items-center lg:gap-0.5'>
+        {item.index ? (
+          <Link
+            href={item.index.url}
+            data-active={active}
+            className={cn(
+              // Mobile styles (default)
+              'flex flex-1 items-center gap-2 rounded-md px-2 py-1.5 text-sm transition-colors',
+              'text-fd-muted-foreground hover:bg-fd-accent/50 hover:text-fd-accent-foreground',
+              active && 'bg-fd-primary/10 font-medium text-fd-primary',
+              // Desktop styles (lg+)
+              'lg:block lg:flex-1 lg:rounded-md lg:px-2.5 lg:py-1.5 lg:font-medium lg:text-[13px] lg:leading-tight',
+              'lg:text-gray-800 lg:dark:text-gray-200',
+              !active && 'lg:hover:bg-gray-100/60 lg:dark:hover:bg-gray-800/40',
+              active &&
+                'lg:bg-purple-50/80 lg:text-purple-600 lg:dark:bg-purple-900/15 lg:dark:text-purple-400'
+            )}
+          >
+            {item.name}
+          </Link>
+        ) : (
+          <button
+            onClick={() => setOpen(!open)}
+            className={cn(
+              // Mobile styles (default)
+              'flex flex-1 items-center gap-2 rounded-md px-2 py-1.5 text-sm transition-colors',
+              'text-fd-muted-foreground hover:bg-fd-accent/50',
+              // Desktop styles (lg+)
+              'lg:flex lg:w-full lg:cursor-pointer lg:items-center lg:justify-between lg:rounded-md lg:px-2.5 lg:py-1.5 lg:text-left lg:font-medium lg:text-[13px] lg:leading-tight',
+              'lg:text-gray-800 lg:hover:bg-gray-100/60 lg:dark:text-gray-200 lg:dark:hover:bg-gray-800/40'
+            )}
+          >
+            <span>{item.name}</span>
+            {/* Desktop-only chevron for non-index folders */}
+            <ChevronRight
+              className={cn(
+                'ml-auto hidden h-3 w-3 flex-shrink-0 text-gray-400 transition-transform duration-200 ease-in-out lg:block dark:text-gray-500',
+                open && 'rotate-90'
+              )}
+            />
+          </button>
+        )}
+        {hasChildren && (
+          <button
+            onClick={() => setOpen(!open)}
+            className={cn(
+              // Mobile styles
+              'rounded p-1 hover:bg-fd-accent/50',
+              // Desktop styles
+              'lg:cursor-pointer lg:rounded lg:p-1 lg:transition-colors lg:hover:bg-gray-100/60 lg:dark:hover:bg-gray-800/40'
+            )}
+            aria-label={open ? 'Collapse' : 'Expand'}
+          >
+            <ChevronRight
+              className={cn(
+                // Mobile styles
+                'h-4 w-4 transition-transform',
+                // Desktop styles
+                'lg:h-3 lg:w-3 lg:text-gray-400 lg:duration-200 lg:ease-in-out lg:dark:text-gray-500',
+                open && 'rotate-90'
+              )}
+            />
+          </button>
+        )}
+      </div>
+      {hasChildren && (
+        <div
+          className={cn(
+            'overflow-hidden transition-all duration-200 ease-in-out',
+            open ? 'max-h-[10000px] opacity-100' : 'max-h-0 opacity-0'
+          )}
+        >
+          {/* Mobile: simple indent */}
+          <div className='ml-4 flex flex-col gap-0.5 lg:hidden'>{children}</div>
+          {/* Desktop: styled with border */}
+          <ul className='mt-0.5 ml-2 hidden space-y-[0.0625rem] border-gray-200/60 border-l pl-2.5 lg:block dark:border-gray-700/60'>
+            {children}
+          </ul>
+        </div>
+      )}
+    </div>
+  )
+}
+
+export function SidebarSeparator({ item }: { item: Separator }) {
+  return (
+    <p
+      className={cn(
+        // Mobile styles
+        'mt-4 mb-2 px-2 font-medium text-fd-muted-foreground text-xs',
+        // Desktop styles
+        'lg:mt-4 lg:mb-1.5 lg:px-2.5 lg:font-semibold lg:text-[10px] lg:text-gray-500/80 lg:uppercase lg:tracking-wide lg:dark:text-gray-500'
+      )}
+    >
+      {item.name}
+    </p>
+  )
+}
+
+function checkHasActiveChild(node: Folder, pathname: string): boolean {
+  if (node.index && isActive(node.index.url, pathname)) {
+    return true
+  }
+
+  for (const child of node.children) {
+    if (child.type === 'page' && isActive(child.url, pathname)) {
+      return true
+    }
+    if (child.type === 'folder' && checkHasActiveChild(child, pathname)) {
+      return true
+    }
+  }
+
+  return false
+}

apps/docs/components/docs-layout/toc-footer.tsx

@@ -0,0 +1,41 @@
+'use client'
+
+import { useState } from 'react'
+import { ArrowRight, ChevronRight } from 'lucide-react'
+import Link from 'next/link'
+
+export function TOCFooter() {
+  const [isHovered, setIsHovered] = useState(false)
+
+  return (
+    <div className='sticky bottom-0 mt-6'>
+      <div className='flex flex-col gap-2 rounded-lg border border-border bg-secondary p-6 text-sm'>
+        <div className='text-balance font-semibold text-base leading-tight'>
+          Start building today
+        </div>
+        <div className='text-muted-foreground'>Trusted by over 60,000 builders.</div>
+        <div className='text-muted-foreground'>
+          Build Agentic workflows visually on a drag-and-drop canvas or with natural language.
+        </div>
+        <Link
+          href='https://sim.ai/signup'
+          target='_blank'
+          rel='noopener noreferrer'
+          onMouseEnter={() => setIsHovered(true)}
+          onMouseLeave={() => setIsHovered(false)}
+          className='group mt-2 inline-flex h-8 w-fit items-center justify-center gap-1 whitespace-nowrap rounded-[10px] border border-[#6F3DFA] bg-gradient-to-b from-[#8357FF] to-[#6F3DFA] px-3 pr-[10px] pl-[12px] font-medium text-sm text-white shadow-[inset_0_2px_4px_0_#9B77FF] outline-none transition-all hover:shadow-lg focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50'
+          aria-label='Get started with Sim - Sign up for free'
+        >
+          <span>Get started</span>
+          <span className='inline-flex transition-transform duration-200 group-hover:translate-x-0.5'>
+            {isHovered ? (
+              <ArrowRight className='h-4 w-4' aria-hidden='true' />
+            ) : (
+              <ChevronRight className='h-4 w-4' aria-hidden='true' />
+            )}
+          </span>
+        </Link>
+      </div>
+    </div>
+  )
+}

apps/docs/components/navbar/navbar.tsx

@@ -0,0 +1,66 @@
+'use client'
+
+import Image from 'next/image'
+import Link from 'next/link'
+import { LanguageDropdown } from '@/components/ui/language-dropdown'
+import { SearchTrigger } from '@/components/ui/search-trigger'
+import { ThemeToggle } from '@/components/ui/theme-toggle'
+
+export function Navbar() {
+  return (
+    <nav
+      className='sticky top-0 z-50 border-border/50 border-b'
+      style={{
+        backdropFilter: 'blur(25px) saturate(180%)',
+        WebkitBackdropFilter: 'blur(25px) saturate(180%)',
+      }}
+    >
+      {/* Desktop: Single row layout */}
+      <div className='hidden h-16 w-full items-center lg:flex'>
+        <div
+          className='relative flex w-full items-center justify-between'
+          style={{
+            paddingLeft: 'calc(var(--sidebar-offset) + 32px)',
+            paddingRight: 'calc(var(--toc-offset) + 60px)',
+          }}
+        >
+          {/* Left cluster: logo */}
+          <div className='flex items-center'>
+            <Link href='/' className='flex min-w-[100px] items-center'>
+              <Image
+                src='/static/logo.png'
+                alt='Sim'
+                width={72}
+                height={28}
+                className='h-7 w-auto'
+              />
+            </Link>
+          </div>
+
+          {/* Center cluster: search - absolutely positioned to center */}
+          <div className='-translate-x-1/2 absolute left-1/2 flex items-center justify-center'>
+            <SearchTrigger />
+          </div>
+
+          {/* Right cluster aligns with TOC edge */}
+          <div className='flex items-center gap-4'>
+            <Link
+              href='https://sim.ai'
+              target='_blank'
+              rel='noopener noreferrer'
+              className='rounded-xl px-3 py-2 font-normal text-[0.9375rem] text-foreground/60 leading-[1.4] transition-colors hover:bg-foreground/8 hover:text-foreground'
+              style={{
+                fontFamily:
+                  '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif',
+              }}
+            >
+              Platform
+            </Link>
+            <LanguageDropdown />
+            <ThemeToggle />
+          </div>
+        </div>
+      </div>
+    </nav>
+  )
+}

apps/docs/components/page-actions.tsx

@@ -0,0 +1,60 @@
+'use client'
+
+import { useState } from 'react'
+import { useCopyButton } from 'fumadocs-ui/utils/use-copy-button'
+import { Check, Copy } from 'lucide-react'
+
+const cache = new Map<string, string>()
+
+export function LLMCopyButton({
+  markdownUrl,
+}: {
+  /**
+   * A URL to fetch the raw Markdown/MDX content of page
+   */
+  markdownUrl: string
+}) {
+  const [isLoading, setLoading] = useState(false)
+  const [checked, onClick] = useCopyButton(async () => {
+    const cached = cache.get(markdownUrl)
+    if (cached) return navigator.clipboard.writeText(cached)
+
+    setLoading(true)
+
+    try {
+      await navigator.clipboard.write([
+        new ClipboardItem({
+          'text/plain': fetch(markdownUrl).then(async (res) => {
+            const content = await res.text()
+            cache.set(markdownUrl, content)
+
+            return content
+          }),
+        }),
+      ])
+    } finally {
+      setLoading(false)
+    }
+  })
+
+  return (
+    <button
+      disabled={isLoading}
+      onClick={onClick}
+      className='flex cursor-pointer items-center gap-1.5 rounded-lg border border-border/40 bg-background px-2.5 py-2 text-muted-foreground/60 text-sm leading-none transition-all hover:border-border hover:bg-accent/50 hover:text-muted-foreground'
+      aria-label={checked ? 'Copied to clipboard' : 'Copy page content'}
+    >
+      {checked ? (
+        <>
+          <Check className='h-3.5 w-3.5' />
+          <span>Copied</span>
+        </>
+      ) : (
+        <>
+          <Copy className='h-3.5 w-3.5' />
+          <span>Copy page</span>
+        </>
+      )}
+    </button>
+  )
+}

apps/docs/components/structured-data.tsx

@@ -88,7 +88,7 @@ export function StructuredData({
       },
       'query-input': 'required name=search_term_string',
     },
-    inLanguage: ['en', 'fr', 'zh'],
+    inLanguage: ['en', 'es', 'fr', 'de', 'ja', 'zh'],
   }
 
   const faqStructuredData = title.toLowerCase().includes('faq') && {

apps/docs/components/ui/block-info-card.tsx

@@ -1,44 +1,40 @@
 'use client'
 
 import type * as React from 'react'
+import { blockTypeToIconMap } from '@/components/ui/icon-mapping'
 
 interface BlockInfoCardProps {
   type: string
   color: string
-  icon?: boolean
-  iconSvg?: string
+  icon?: React.ComponentType<{ className?: string }>
+  iconSvg?: string // Deprecated: Use automatic icon resolution instead
 }
 
 export function BlockInfoCard({
   type,
   color,
-  icon = false,
+  icon: IconComponent,
   iconSvg,
 }: BlockInfoCardProps): React.ReactNode {
+  // Auto-resolve icon component from block type if not explicitly provided
+  const ResolvedIcon = IconComponent || blockTypeToIconMap[type] || null
+
   return (
     <div className='mb-6 overflow-hidden rounded-lg border border-border'>
       <div className='flex items-center justify-center p-6'>
         <div
           className='flex h-20 w-20 items-center justify-center rounded-lg'
-          style={{ backgroundColor: color }}
+          style={{ background: color }}
         >
-          {iconSvg ? (
+          {ResolvedIcon ? (
+            <ResolvedIcon className='h-10 w-10 text-white' />
+          ) : iconSvg ? (
             <div className='h-10 w-10 text-white' dangerouslySetInnerHTML={{ __html: iconSvg }} />
           ) : (
             <div className='font-mono text-xl opacity-70'>{type.substring(0, 2)}</div>
           )}
         </div>
       </div>
-      {icon && (
-        <style jsx global>{`
-          .block-icon {
-            width: 80px;
-            height: 80px;
-            margin: 1rem auto;
-            display: block;
-          }
-        `}</style>
-      )}
     </div>
   )
 }

apps/docs/components/ui/button.tsx

@@ -0,0 +1,27 @@
+import { cva, type VariantProps } from 'class-variance-authority'
+
+const variants = {
+  primary: 'bg-fd-primary text-fd-primary-foreground hover:bg-fd-primary/80',
+  outline: 'border hover:bg-fd-accent hover:text-fd-accent-foreground',
+  ghost: 'hover:bg-fd-accent hover:text-fd-accent-foreground',
+  secondary:
+    'border bg-fd-secondary text-fd-secondary-foreground hover:bg-fd-accent hover:text-fd-accent-foreground',
+} as const
+
+export const buttonVariants = cva(
+  'inline-flex items-center justify-center rounded-md p-2 text-sm font-medium transition-colors duration-100 disabled:pointer-events-none disabled:opacity-50 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fd-ring',
+  {
+    variants: {
+      variant: variants,
+      color: variants,
+      size: {
+        sm: 'gap-1 px-2 py-1.5 text-xs',
+        icon: 'p-1.5 [&_svg]:size-5',
+        'icon-sm': 'p-1.5 [&_svg]:size-4.5',
+        'icon-xs': 'p-1 [&_svg]:size-4',
+      },
+    },
+  }
+)
+
+export type ButtonProps = VariantProps<typeof buttonVariants>

apps/docs/components/ui/code-block.tsx

@@ -0,0 +1,50 @@
+'use client'
+
+import { useState } from 'react'
+import { CodeBlock as FumadocsCodeBlock } from 'fumadocs-ui/components/codeblock'
+import { Check, Copy } from 'lucide-react'
+import { cn } from '@/lib/utils'
+
+export function CodeBlock(props: React.ComponentProps<typeof FumadocsCodeBlock>) {
+  const [copied, setCopied] = useState(false)
+
+  const handleCopy = async (text: string) => {
+    await navigator.clipboard.writeText(text)
+    setCopied(true)
+    setTimeout(() => setCopied(false), 2000)
+  }
+
+  return (
+    <FumadocsCodeBlock
+      {...props}
+      Actions={({ children, className }) => (
+        <div className={cn('empty:hidden', className)}>
+          {/* Custom copy button */}
+          <button
+            type='button'
+            aria-label={copied ? 'Copied Text' : 'Copy Text'}
+            onClick={(e) => {
+              const pre = (e.currentTarget as HTMLElement)
+                .closest('.nd-codeblock')
+                ?.querySelector('pre')
+              if (pre) handleCopy(pre.textContent || '')
+            }}
+            className={cn(
+              'cursor-pointer rounded-md p-2 transition-all',
+              'border border-border bg-background/80 hover:bg-muted',
+              'backdrop-blur-sm'
+            )}
+          >
+            <span className='flex items-center justify-center'>
+              {copied ? (
+                <Check size={16} className='text-green-600 dark:text-green-400' />
+              ) : (
+                <Copy size={16} className='text-muted-foreground' />
+              )}
+            </span>
+          </button>
+        </div>
+      )}
+    />
+  )
+}

apps/docs/components/ui/heading.tsx

@@ -0,0 +1,58 @@
+'use client'
+
+import { type ComponentPropsWithoutRef, useState } from 'react'
+import { Check, Link } from 'lucide-react'
+import { cn } from '@/lib/utils'
+
+type HeadingTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'
+
+interface HeadingProps extends ComponentPropsWithoutRef<'h1'> {
+  as?: HeadingTag
+}
+
+export function Heading({ as, className, ...props }: HeadingProps) {
+  const [copied, setCopied] = useState(false)
+  const As = as ?? 'h1'
+
+  if (!props.id) {
+    return <As className={className} {...props} />
+  }
+
+  const handleClick = async (e: React.MouseEvent) => {
+    e.preventDefault()
+
+    const url = `${window.location.origin}${window.location.pathname}#${props.id}`
+
+    try {
+      await navigator.clipboard.writeText(url)
+      setCopied(true)
+
+      // Update URL hash without scrolling
+      window.history.pushState(null, '', `#${props.id}`)
+
+      setTimeout(() => setCopied(false), 2000)
+    } catch {
+      // Fallback: just navigate to the anchor
+      window.location.hash = props.id as string
+    }
+  }
+
+  return (
+    <As className={cn('group flex scroll-m-28 flex-row items-center gap-2', className)} {...props}>
+      <a data-card='' href={`#${props.id}`} className='peer' onClick={handleClick}>
+        {props.children}
+      </a>
+      {copied ? (
+        <Check
+          aria-hidden
+          className='size-3.5 shrink-0 text-green-500 opacity-100 transition-opacity'
+        />
+      ) : (
+        <Link
+          aria-hidden
+          className='size-3.5 shrink-0 text-fd-muted-foreground opacity-0 transition-opacity group-hover:opacity-100 peer-hover:opacity-100'
+        />
+      )}
+    </As>
+  )
+}

apps/docs/components/ui/icon-mapping.ts

@@ -0,0 +1,236 @@
+// Auto-generated file - do not edit manually
+// Generated by scripts/generate-docs.ts
+// Maps block types to their icon component references
+
+import type { ComponentType, SVGProps } from 'react'
+import {
+  AhrefsIcon,
+  AirtableIcon,
+  ApifyIcon,
+  ApolloIcon,
+  ArxivIcon,
+  AsanaIcon,
+  BrainIcon,
+  BrowserUseIcon,
+  CalendlyIcon,
+  ClayIcon,
+  ConfluenceIcon,
+  CursorIcon,
+  DatadogIcon,
+  DiscordIcon,
+  DocumentIcon,
+  DropboxIcon,
+  DuckDuckGoIcon,
+  DynamoDBIcon,
+  ElasticsearchIcon,
+  ElevenLabsIcon,
+  ExaAIIcon,
+  EyeIcon,
+  FirecrawlIcon,
+  GithubIcon,
+  GitLabIcon,
+  GmailIcon,
+  GoogleCalendarIcon,
+  GoogleDocsIcon,
+  GoogleDriveIcon,
+  GoogleFormsIcon,
+  GoogleGroupsIcon,
+  GoogleIcon,
+  GoogleSheetsIcon,
+  GoogleSlidesIcon,
+  GoogleVaultIcon,
+  GrafanaIcon,
+  HubspotIcon,
+  HuggingFaceIcon,
+  HunterIOIcon,
+  ImageIcon,
+  IncidentioIcon,
+  IntercomIcon,
+  JinaAIIcon,
+  JiraIcon,
+  KalshiIcon,
+  LinearIcon,
+  LinkedInIcon,
+  LinkupIcon,
+  MailchimpIcon,
+  MailgunIcon,
+  Mem0Icon,
+  MicrosoftExcelIcon,
+  MicrosoftOneDriveIcon,
+  MicrosoftPlannerIcon,
+  MicrosoftSharepointIcon,
+  MicrosoftTeamsIcon,
+  MistralIcon,
+  MongoDBIcon,
+  MySQLIcon,
+  Neo4jIcon,
+  NotionIcon,
+  OpenAIIcon,
+  OutlookIcon,
+  PackageSearchIcon,
+  ParallelIcon,
+  PerplexityIcon,
+  PineconeIcon,
+  PipedriveIcon,
+  PolymarketIcon,
+  PostgresIcon,
+  PosthogIcon,
+  QdrantIcon,
+  RDSIcon,
+  RedditIcon,
+  ResendIcon,
+  S3Icon,
+  SalesforceIcon,
+  SearchIcon,
+  SendgridIcon,
+  SentryIcon,
+  SerperIcon,
+  ServiceNowIcon,
+  SftpIcon,
+  ShopifyIcon,
+  SlackIcon,
+  SmtpIcon,
+  SpotifyIcon,
+  SQSIcon,
+  SshIcon,
+  STTIcon,
+  StagehandIcon,
+  StripeIcon,
+  SupabaseIcon,
+  TavilyIcon,
+  TelegramIcon,
+  TranslateIcon,
+  TrelloIcon,
+  TTSIcon,
+  TwilioIcon,
+  TypeformIcon,
+  VideoIcon,
+  WealthboxIcon,
+  WebflowIcon,
+  WhatsAppIcon,
+  WikipediaIcon,
+  WordpressIcon,
+  xIcon,
+  YouTubeIcon,
+  ZendeskIcon,
+  ZepIcon,
+  ZoomIcon,
+} from '@/components/icons'
+
+type IconComponent = ComponentType<SVGProps<SVGSVGElement>>
+
+export const blockTypeToIconMap: Record<string, IconComponent> = {
+  ahrefs: AhrefsIcon,
+  airtable: AirtableIcon,
+  apify: ApifyIcon,
+  apollo: ApolloIcon,
+  arxiv: ArxivIcon,
+  asana: AsanaIcon,
+  browser_use: BrowserUseIcon,
+  calendly: CalendlyIcon,
+  clay: ClayIcon,
+  confluence: ConfluenceIcon,
+  cursor: CursorIcon,
+  datadog: DatadogIcon,
+  discord: DiscordIcon,
+  dropbox: DropboxIcon,
+  duckduckgo: DuckDuckGoIcon,
+  dynamodb: DynamoDBIcon,
+  elasticsearch: ElasticsearchIcon,
+  elevenlabs: ElevenLabsIcon,
+  exa: ExaAIIcon,
+  file: DocumentIcon,
+  firecrawl: FirecrawlIcon,
+  github: GithubIcon,
+  gitlab: GitLabIcon,
+  gmail: GmailIcon,
+  google_calendar: GoogleCalendarIcon,
+  google_docs: GoogleDocsIcon,
+  google_drive: GoogleDriveIcon,
+  google_forms: GoogleFormsIcon,
+  google_groups: GoogleGroupsIcon,
+  google_search: GoogleIcon,
+  google_sheets: GoogleSheetsIcon,
+  google_slides: GoogleSlidesIcon,
+  google_vault: GoogleVaultIcon,
+  grafana: GrafanaIcon,
+  hubspot: HubspotIcon,
+  huggingface: HuggingFaceIcon,
+  hunter: HunterIOIcon,
+  image_generator: ImageIcon,
+  incidentio: IncidentioIcon,
+  intercom: IntercomIcon,
+  jina: JinaAIIcon,
+  jira: JiraIcon,
+  kalshi: KalshiIcon,
+  knowledge: PackageSearchIcon,
+  linear: LinearIcon,
+  linkedin: LinkedInIcon,
+  linkup: LinkupIcon,
+  mailchimp: MailchimpIcon,
+  mailgun: MailgunIcon,
+  mem0: Mem0Icon,
+  memory: BrainIcon,
+  microsoft_excel: MicrosoftExcelIcon,
+  microsoft_planner: MicrosoftPlannerIcon,
+  microsoft_teams: MicrosoftTeamsIcon,
+  mistral_parse: MistralIcon,
+  mongodb: MongoDBIcon,
+  mysql: MySQLIcon,
+  neo4j: Neo4jIcon,
+  notion: NotionIcon,
+  onedrive: MicrosoftOneDriveIcon,
+  openai: OpenAIIcon,
+  outlook: OutlookIcon,
+  parallel_ai: ParallelIcon,
+  perplexity: PerplexityIcon,
+  pinecone: PineconeIcon,
+  pipedrive: PipedriveIcon,
+  polymarket: PolymarketIcon,
+  postgresql: PostgresIcon,
+  posthog: PosthogIcon,
+  qdrant: QdrantIcon,
+  rds: RDSIcon,
+  reddit: RedditIcon,
+  resend: ResendIcon,
+  s3: S3Icon,
+  salesforce: SalesforceIcon,
+  search: SearchIcon,
+  sendgrid: SendgridIcon,
+  sentry: SentryIcon,
+  serper: SerperIcon,
+  servicenow: ServiceNowIcon,
+  sftp: SftpIcon,
+  sharepoint: MicrosoftSharepointIcon,
+  shopify: ShopifyIcon,
+  slack: SlackIcon,
+  smtp: SmtpIcon,
+  spotify: SpotifyIcon,
+  sqs: SQSIcon,
+  ssh: SshIcon,
+  stagehand: StagehandIcon,
+  stripe: StripeIcon,
+  stt: STTIcon,
+  supabase: SupabaseIcon,
+  tavily: TavilyIcon,
+  telegram: TelegramIcon,
+  thinking: BrainIcon,
+  translate: TranslateIcon,
+  trello: TrelloIcon,
+  tts: TTSIcon,
+  twilio_sms: TwilioIcon,
+  twilio_voice: TwilioIcon,
+  typeform: TypeformIcon,
+  video_generator: VideoIcon,
+  vision: EyeIcon,
+  wealthbox: WealthboxIcon,
+  webflow: WebflowIcon,
+  whatsapp: WhatsAppIcon,
+  wikipedia: WikipediaIcon,
+  wordpress: WordpressIcon,
+  x: xIcon,
+  youtube: YouTubeIcon,
+  zendesk: ZendeskIcon,
+  zep: ZepIcon,
+  zoom: ZoomIcon,
+}

apps/docs/components/ui/image.tsx

@@ -2,8 +2,8 @@
 
 import { useState } from 'react'
 import NextImage, { type ImageProps as NextImageProps } from 'next/image'
+import { Lightbox } from '@/components/ui/lightbox'
 import { cn } from '@/lib/utils'
-import { Lightbox } from './lightbox'
 
 interface ImageProps extends Omit<NextImageProps, 'className'> {
   className?: string

apps/docs/components/ui/language-dropdown.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import { useEffect, useState } from 'react'
-import { Check, ChevronDown } from 'lucide-react'
+import { Check, ChevronRight } from 'lucide-react'
 import { useParams, usePathname, useRouter } from 'next/navigation'
 
 const languages = {
@@ -82,15 +82,14 @@ export function LanguageDropdown() {
         aria-haspopup='listbox'
         aria-expanded={isOpen}
         aria-controls='language-menu'
-        className='flex items-center gap-1.5 rounded-lg border border-border/30 bg-muted/40 px-2.5 py-1.5 text-sm shadow-sm backdrop-blur-sm transition-colors hover:bg-muted focus:outline-none focus-visible:ring-2 focus-visible:ring-ring'
+        className='flex cursor-pointer items-center gap-1.5 rounded-xl px-3 py-2 font-normal text-[0.9375rem] text-foreground/60 leading-[1.4] transition-colors hover:bg-foreground/8 hover:text-foreground focus:outline-none focus-visible:ring-2 focus-visible:ring-ring'
+        style={{
+          fontFamily:
+            '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif',
+        }}
       >
-        <span className='text-sm'>{languages[currentLang as keyof typeof languages]?.flag}</span>
-        <span className='font-medium text-foreground'>
-          {languages[currentLang as keyof typeof languages]?.name}
-        </span>
-        <ChevronDown
-          className={`h-3 w-3 text-muted-foreground transition-transform ${isOpen ? 'rotate-180' : ''}`}
-        />
+        <span>{languages[currentLang as keyof typeof languages]?.name}</span>
+        <ChevronRight className='h-3.5 w-3.5' />
       </button>
 
       {isOpen && (
@@ -99,7 +98,7 @@ export function LanguageDropdown() {
           <div
             id='language-menu'
             role='listbox'
-            className='absolute top-full left-0 z-[1001] mt-1 max-h-[75vh] w-56 overflow-auto rounded-xl border border-border/50 bg-white shadow-2xl md:w-44 md:bg-background/95 md:backdrop-blur-md dark:bg-neutral-950 md:dark:bg-background/95'
+            className='absolute top-full right-0 z-[1001] mt-1 max-h-[75vh] w-56 overflow-auto rounded-xl border border-border/50 bg-white shadow-2xl md:w-44 md:bg-background/95 md:backdrop-blur-md dark:bg-neutral-950 md:dark:bg-background/95'
           >
             {Object.entries(languages).map(([code, lang]) => (
               <button
@@ -111,7 +110,7 @@ export function LanguageDropdown() {
                 }}
                 role='option'
                 aria-selected={currentLang === code}
-                className={`flex w-full items-center gap-3 px-3 py-3 text-base transition-colors first:rounded-t-xl last:rounded-b-xl hover:bg-muted/80 focus:outline-none focus-visible:ring-2 focus-visible:ring-ring md:gap-2 md:px-2.5 md:py-2 md:text-sm ${
+                className={`flex w-full cursor-pointer items-center gap-3 px-3 py-3 text-base transition-colors first:rounded-t-xl last:rounded-b-xl hover:bg-muted/80 focus:outline-none focus-visible:ring-2 focus-visible:ring-ring md:gap-2 md:px-2.5 md:py-2 md:text-sm ${
                   currentLang === code ? 'bg-muted/60 font-medium text-primary' : 'text-foreground'
                 }`}
               >

apps/docs/components/ui/lightbox.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import { useEffect, useRef } from 'react'
-import { getVideoUrl } from '@/lib/utils'
+import { getAssetUrl } from '@/lib/utils'
 
 interface LightboxProps {
   isOpen: boolean
@@ -60,7 +60,7 @@ export function Lightbox({ isOpen, onClose, src, alt, type }: LightboxProps) {
           />
         ) : (
           <video
-            src={getVideoUrl(src)}
+            src={getAssetUrl(src)}
             autoPlay
             loop
             muted

apps/docs/components/ui/search-trigger.tsx

@@ -0,0 +1,38 @@
+'use client'
+
+import { Search } from 'lucide-react'
+
+export function SearchTrigger() {
+  const handleClick = () => {
+    const event = new KeyboardEvent('keydown', {
+      key: 'k',
+      metaKey: true,
+      bubbles: true,
+    })
+    document.dispatchEvent(event)
+  }
+
+  return (
+    <button
+      type='button'
+      className='flex h-10 w-[460px] cursor-pointer items-center gap-2 rounded-xl border border-border/50 px-3 py-2 text-sm backdrop-blur-xl transition-colors hover:border-border'
+      style={{
+        backgroundColor: 'hsla(0, 0%, 5%, 0.85)',
+        backdropFilter: 'blur(33px) saturate(180%)',
+        WebkitBackdropFilter: 'blur(33px) saturate(180%)',
+        color: 'rgba(255, 255, 255, 0.6)',
+      }}
+      onClick={handleClick}
+    >
+      <Search className='h-4 w-4' />
+      <span>Search...</span>
+      <kbd
+        className='ml-auto flex items-center gap-0.5 font-medium'
+        style={{ color: 'rgba(255, 255, 255, 0.6)' }}
+      >
+        <span style={{ fontSize: '15px', lineHeight: '1' }}>⌘</span>
+        <span style={{ fontSize: '13px', lineHeight: '1' }}>K</span>
+      </kbd>
+    </button>
+  )
+}

apps/docs/components/ui/theme-toggle.tsx

@@ -0,0 +1,32 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import { Moon, Sun } from 'lucide-react'
+import { useTheme } from 'next-themes'
+
+export function ThemeToggle() {
+  const { theme, setTheme } = useTheme()
+  const [mounted, setMounted] = useState(false)
+
+  useEffect(() => {
+    setMounted(true)
+  }, [])
+
+  if (!mounted) {
+    return (
+      <button className='flex cursor-pointer items-center justify-center rounded-md p-1 text-muted-foreground'>
+        <Moon className='h-4 w-4' />
+      </button>
+    )
+  }
+
+  return (
+    <button
+      onClick={() => setTheme(theme === 'dark' ? 'light' : 'dark')}
+      className='flex cursor-pointer items-center justify-center rounded-md p-1 text-muted-foreground transition-colors hover:text-foreground'
+      aria-label='Toggle theme'
+    >
+      {theme === 'dark' ? <Moon className='h-4 w-4' /> : <Sun className='h-4 w-4' />}
+    </button>
+  )
+}

apps/docs/components/ui/video.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import { useState } from 'react'
-import { getVideoUrl } from '@/lib/utils'
+import { getAssetUrl } from '@/lib/utils'
 import { Lightbox } from './lightbox'
 
 interface VideoProps {
@@ -39,7 +39,7 @@ export function Video({
         muted={muted}
         playsInline={playsInline}
         className={`${className} ${enableLightbox ? 'cursor-pointer transition-opacity hover:opacity-90' : ''}`}
-        src={getVideoUrl(src)}
+        src={getAssetUrl(src)}
         onClick={handleVideoClick}
       />
 

apps/docs/content/docs/de/blocks/agent.mdx

@@ -3,12 +3,10 @@ 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.
+Der Agent-Block verbindet deinen Workflow mit Large Language Models (LLMs). Er verarbeitet natürlichsprachliche Eingaben, ruft externe Tools auf und generiert strukturierte oder unstrukturierte Ausgaben.
 
 <div className="flex justify-center">
   <Image
@@ -18,26 +16,7 @@ Der Agent-Block dient als Schnittstelle zwischen Ihrem Workflow und Large Langua
     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> 
+</div> 
 
 ## Konfigurationsoptionen
 
@@ -57,44 +36,25 @@ Der Benutzer-Prompt stellt die primären Eingabedaten für die Inferenzverarbeit
 
 - **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
+- **Laufzeitgenerierung**: Programmatisch generierte 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>
+- **OpenAI**: GPT-5.1, GPT-5, GPT-4o, o1, o3, o4-mini, gpt-4.1
+- **Anthropic**: Claude 4.5 Sonnet, Claude Opus 4.1
+- **Google**: Gemini 2.5 Pro, Gemini 2.0 Flash
+- **Andere Anbieter**: Groq, Cerebras, xAI, Azure OpenAI, OpenRouter
+- **Lokale Modelle**: Ollama oder VLLM-kompatible Modelle
 
 ### Temperatur
 
-Steuern Sie die Kreativität und Zufälligkeit der Antworten:
+Steuert die Zufälligkeit und Kreativität 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>
+- **Niedrig (0-0,3)**: Deterministisch und fokussiert. Am besten für faktische Aufgaben und Genauigkeit.
+- **Mittel (0,3-0,7)**: Ausgewogene Kreativität und Fokus. Gut für allgemeine Verwendung.
+- **Hoch (0,7-2,0)**: Kreativ und abwechslungsreich. Ideal für Brainstorming und Content-Generierung.
 
 ### API-Schlüssel
 
@@ -102,179 +62,93 @@ Ihr API-Schlüssel für den ausgewählten LLM-Anbieter. Dieser wird sicher gespe
 
 ### 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.
+Erweitern Sie die Fähigkeiten des Agenten mit externen Integrationen. Wählen Sie aus über 60 vorgefertigten Tools oder definieren Sie benutzerdefinierte Funktionen.
 
-**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**:
+**Verfügbare 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
+- **Entwicklung**: GitHub, Jira, Linear
 - **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>
+**Ausführungsmodi:**
+- **Auto**: Modell entscheidet kontextbasiert, wann Tools verwendet werden
+- **Erforderlich**: Tool muss bei jeder Anfrage aufgerufen werden
+- **Keine**: Tool verfügbar, aber dem Modell nicht vorgeschlagen
 
 ### 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:
+Der Parameter für das Antwortformat erzwingt die Generierung strukturierter Ausgaben 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
-      }
+  "type": "object",
+  "properties": {
+    "sentiment": {
+      "type": "string",
+      "enum": ["positive", "neutral", "negative"]
     },
-    "required": ["sentiment", "confidence"]
-  }
+    "summary": {
+      "type": "string",
+      "description": "Brief summary of the content"
+    }
+  },
+  "required": ["sentiment", "summary"]
 }
 ```
 
-Diese Konfiguration beschränkt die Ausgabe des Modells auf die Einhaltung des angegebenen Schemas, verhindert Freitext-Antworten und stellt eine strukturierte Datengenerierung sicher.
+Diese Konfiguration beschränkt die Ausgabe des Modells auf die Einhaltung des angegebenen Schemas, verhindert Freitextantworten und stellt die Generierung strukturierter Daten 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)
+- **response**: Der Antworttext oder die strukturierten Daten des Agenten
+- **usage**: Token-Nutzungsstatistiken (Prompt, Completion, Gesamt)
+- **toolExecutions**: Details zu allen Tools, die der Agent während der Ausführung verwendet hat
+- **estimatedCost**: 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.
+Verwenden Sie einen memory Block mit einer konsistenten memoryId (zum Beispiel, conversationHistory), 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
 
-Siehe die [`Memory`](/tools/memory) Blockreferenz für Details.
+Siehe den [`Memory`](/tools/memory) Blockverweis für Details.
 
-## Eingaben und Ausgaben
+## Ausgaben
 
-<Tabs items={['Konfiguration', 'Variablen', 'Ergebnisse']}>
-  <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>Benutzer-Prompt</strong>: Eingabetext oder zu verarbeitende Daten
-      </li>
-      <li>
-        <strong>Modell</strong>: KI-Modellauswahl (OpenAI, Anthropic, Google, usw.)
-      </li>
-      <li>
-        <strong>Temperatur</strong>: Steuerung der Zufälligkeit der Antwort (0-2)
-      </li>
-      <li>
-        <strong>Tools</strong>: Array verfügbarer Tools für Funktionsaufrufe
-      </li>
-      <li>
-        <strong>Antwortformat</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>
+- **`<agent.content>`**: Antworttext des Agenten
+- **`<agent.tokens>`**: Token-Nutzungsstatistiken
+- **`<agent.tool_calls>`**: Details zur Tool-Ausführung
+- **`<agent.cost>`**: Geschätzte Kosten des API-Aufrufs
 
 ## Beispielanwendungsfälle
 
-### Automatisierung des Kundenservice
+**Automatisierung des Kundenservice** - Bearbeitung von Anfragen mit Datenbank- und Tool-Zugriff
 
-<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 erstellt eine klare E-Mail-Antwort</li>
-    <li>Gmail sendet die Antwort an den Kunden</li>
-    <li>Konversation wird im Memory gespeichert, um den Verlauf für zukünftige Nachrichten beizubehalten</li>
-  </ol>
-</div>
+```
+API (Ticket) → Agent (Postgres, KB, Linear) → Gmail (Reply) → Memory (Save)
+```
 
-### Multi-Modell-Inhaltsanalyse
+**Multi-Modell-Inhaltsanalyse** - Analyse von Inhalten mit verschiedenen KI-Modellen
 
-<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>
+```
+Function (Process) → Agent (GPT-4o Technical) → Agent (Claude Sentiment) → Function (Report)
+```
 
-### Werkzeuggestützter Forschungsassistent
+**Tool-gestützter Rechercheassistent** - Recherche mit Websuche und Dokumentenzugriff
 
-<div className="mb-4 rounded-md border p-4">
-  <h4 className="font-medium">Szenario: Forschungsassistent 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-Suchwerkzeug</li>
-    <li>Agent greift auf Notion-Datenbank für interne Dokumente zu</li>
-    <li>Agent erstellt umfassenden Forschungsbericht</li>
-  </ol>
-</div>
+```
+Input → Agent (Google Search, Notion) → Function (Compile Report)
+```
 
 ## Bewährte Praktiken
 
 - **Sei spezifisch in System-Prompts**: Definiere die Rolle, den Ton 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 Werkzeuge effektiv**: Integriere Werkzeuge, die den Zweck des Agenten ergänzen und seine Fähigkeiten verbessern. Sei selektiv bei der Auswahl der Werkzeuge, um den Agenten nicht zu überfordern. Für Aufgaben mit wenig Überschneidung verwende einen anderen Agent-Block für die besten Ergebnisse.
+- **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 vielfältigere 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.

apps/docs/content/docs/de/blocks/api.mdx

@@ -3,11 +3,10 @@ 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.
+Der API-Block verbindet Ihren Workflow mit externen Diensten durch HTTP-Anfragen. Unterstützt GET, POST, PUT, DELETE und PATCH Methoden für die Interaktion mit REST-APIs.
 
 <div className="flex justify-center">
   <Image
@@ -19,39 +18,11 @@ Der API-Block ermöglicht es Ihnen, Ihren Workflow über API-Endpunkte mit exter
   />
 </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:
+Die Endpunkt-URL für die API-Anfrage. Diese kann sein:
 
 - Eine statische URL, die direkt im Block eingegeben wird
 - Eine dynamische URL, die mit der Ausgabe eines anderen Blocks verbunden ist
@@ -79,7 +50,7 @@ Key: limit
 Value: 10
 ```
 
-Diese würden der URL als `?apiKey=your_api_key_here&limit=10` hinzugefügt werden.
+Diese würden der URL als `?apiKey=your_api_key_here&limit=10` hinzugefügt.
 
 ### Header
 
@@ -93,13 +64,13 @@ Key: Authorization
 Value: Bearer your_token_here
 ```
 
-### Anfrage-Body
+### Anfragekörper
 
-Für Methoden, die einen Anfrage-Body unterstützen (POST, PUT, PATCH), können Sie die zu sendenden Daten definieren. Der Body kann sein:
+Für Methoden, die einen Anfragekörper unterstützen (POST, PUT, PATCH), können Sie die zu sendenden Daten definieren. Der Körper 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
+- Dynamisch während der Workflow-Ausführung generiert
 
 ### Zugriff auf Ergebnisse
 
@@ -114,7 +85,7 @@ Nach Abschluss einer API-Anfrage können Sie auf folgende Ausgaben zugreifen:
 
 ### Dynamische URL-Konstruktion
 
-Bauen Sie URLs dynamisch mit Variablen aus vorherigen Blöcken:
+Erstellen Sie URLs dynamisch mit Variablen aus vorherigen Blöcken:
 
 ```javascript
 // In a Function block before the API
@@ -124,9 +95,9 @@ const apiUrl = `https://api.example.com/users/${userId}/profile`;
 
 ### Anfrage-Wiederholungen
 
-Der API-Block behandelt automatisch:
+Der API-Block verarbeitet automatisch:
 - Netzwerk-Timeouts mit exponentiellem Backoff
-- Rate-Limit-Antworten (429-Statuscodes)
+- Antworten bei Ratenbegrenzung (429-Statuscodes)
 - Serverfehler (5xx-Statuscodes) mit Wiederholungslogik
 - Verbindungsfehler mit Wiederverbindungsversuchen
 
@@ -145,88 +116,30 @@ if (<api.status> === 200) {
 }
 ```
 
-## Eingaben und Ausgaben
+## 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>
+- **`<api.data>`**: Antwortdaten vom API
+- **`<api.status>`**: HTTP-Statuscode
+- **`<api.headers>`**: Antwort-Header
+- **`<api.error>`**: Fehlerdetails bei fehlgeschlagener Anfrage
 
-## Beispielanwendungsfälle
+## Anwendungsbeispiele
 
-### Benutzerprofildaten abrufen
+**Benutzerprofildaten abrufen** - Benutzerinformationen von externem Dienst 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/&#123;id&#125; Endpunkt auf</li>
-    <li>Funktionsblock verarbeitet und formatiert Benutzerdaten</li>
-    <li>Antwortblock gibt formatiertes Profil zurück</li>
-  </ol>
-</div>
+```
+Function (Build ID) → API (GET /users/{id}) → Function (Format) → Response
+```
 
-### Zahlungsabwicklung
+**Zahlungsabwicklung** - Zahlung über die Stripe-API verarbeiten
 
-<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>
+```
+Function (Validate) → API (Stripe) → Condition (Success) → Supabase (Update)
+```
 
-## Best Practices
+## Bewährte Praktiken
 
-- **Umgebungsvariablen für sensible Daten verwenden**: Keine API-Schlüssel oder Anmeldedaten im Code hinterlegen
+- **Umgebungsvariablen für sensible Daten verwenden**: Keine API-Schlüssel oder Anmeldedaten im Code festlegen
 - **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
+- **Antworten validieren**: Statuscode und Antwortformate vor der Datenverarbeitung prüfen
+- **Ratenbegrenzungen respektieren**: Achten Sie auf API-Ratenbegrenzungen und implementieren Sie angemessene Drosselung

apps/docs/content/docs/de/blocks/condition.mdx

@@ -3,64 +3,29 @@ 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.
+Der Bedingungsblock verzweigt die Workflow-Ausführung basierend auf booleschen Ausdrücken. Bewerten Sie Bedingungen anhand vorheriger Block-Ausgaben und leiten Sie zu verschiedenen Pfaden weiter, ohne dass ein LLM erforderlich ist.
 
 <div className="flex justify-center">
   <Image
     src="/static/blocks/condition.png"
     alt="Bedingungsblock"
     width={500}
-    height={350}
+    height={400}
     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
+- **Ausdruck**: Ein JavaScript/TypeScript-Ausdruck, der zu wahr oder falsch ausgewertet wird
+- **Pfad**: Der Zielblock, zu dem weitergeleitet werden soll, wenn die Bedingung wahr 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.
@@ -100,10 +65,10 @@ Bedingungen verwenden JavaScript-Syntax und können auf Eingabewerte aus vorheri
 
 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
+- **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
 
@@ -148,95 +113,37 @@ Bedingungen behandeln automatisch:
 - Ungültige Ausdrücke mit Fehlerprotokollierung
 - Fehlende Variablen mit Standardwerten
 
-## Eingaben und Ausgaben
+## 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>
+- **`<condition.result>`**: Boolesches Ergebnis der Auswertung
+- **`<condition.matched_condition>`**: ID der übereinstimmenden Bedingung
+- **`<condition.content>`**: Beschreibung des Auswertungsergebnisses
+- **`<condition.path>`**: Details zum gewählten Routing-Ziel
 
 ## Beispielanwendungsfälle
 
-### Routing im Kundenservice
+**Kundenservice-Routing** - Tickets basierend auf Priorität weiterleiten
 
-<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>
+```
+API (Ticket) → Condition (priority === 'high') → Agent (Escalation) or Agent (Standard)
+```
 
-### Inhaltsmoderation
+**Inhaltsmoderation** - Inhalte basierend auf Analysen filtern
 
-<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>
+```
+Agent (Analyze) → Condition (toxicity > 0.7) → Moderation or Publish
+```
 
-### Benutzer-Onboarding-Prozess
+**Benutzer-Onboarding-Ablauf** - Onboarding basierend auf Benutzertyp personalisieren
 
-<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>
+```
+Function (Process) → Condition (account_type === 'enterprise') → Advanced or Simple
+```
 
-## Best Practices
+## Bewährte Praktiken
 
-- **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
+- **Bedingungen korrekt anordnen**: Platzieren Sie spezifischere Bedingungen vor allgemeinen, um sicherzustellen, dass spezifische Logik Vorrang vor Fallbacks hat
+- **Verwenden Sie den Else-Zweig bei Bedarf**: Wenn keine Bedingungen übereinstimmen und der Else-Zweig nicht verbunden ist, endet der Workflow-Zweig ordnungsgemäß. Verbinden Sie den Else-Zweig, wenn Sie einen Fallback-Pfad für nicht übereinstimmende Fälle benötigen
+- **Halten Sie Ausdrücke einfach**: 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

apps/docs/content/docs/de/blocks/evaluator.mdx

@@ -3,12 +3,10 @@ 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.
+Der Evaluator-Block nutzt KI, um die Inhaltsqualität anhand benutzerdefinierter Metriken zu bewerten. Perfekt für Qualitätskontrolle, A/B-Tests und um sicherzustellen, dass KI-Ausgaben bestimmte Standards erfüllen.
 
 <div className="flex justify-center">
   <Image
@@ -20,42 +18,14 @@ Der Evaluator-Block nutzt KI, um die Inhaltsqualität anhand anpassbarer Bewertu
   />
 </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:
+Definieren Sie 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
+- **Beschreibung**: Eine detaillierte Erklärung, was die Metrik misst
 - **Bereich**: Der numerische Bereich für die Bewertung (z.B. 1-5, 0-10)
 
 Beispielmetriken:
@@ -78,122 +48,49 @@ Der zu bewertende Inhalt. Dies kann sein:
 
 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
+- **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**: Ollama oder VLLM-kompatible Modelle
 
-<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.
+Verwenden Sie Modelle mit starken Argumentationsfähigkeiten wie GPT-4o oder Claude 3.7 Sonnet für beste Ergebnisse.
 
 ### 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
+**Bewertung der Inhaltsqualität** - Inhalte vor der Veröffentlichung bewerten
 
-<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>
+```
+Agent (Generate) → Evaluator (Score) → Condition (Check threshold) → Publish or Revise
+```
 
-### A/B-Testing von Inhalten
+**A/B-Tests von Inhalten** - Vergleich mehrerer KI-generierter Antworten
 
-<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>
+```
+Parallel (Variations) → Evaluator (Score Each) → Function (Select Best) → Response
+```
 
-### Qualitätskontrolle im Kundensupport
+**Qualitätskontrolle im Kundenservice** - Sicherstellen, dass Antworten Qualitätsstandards erfüllen
 
-<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>
+```
+Agent (Support Response) → Evaluator (Score) → Function (Log) → Condition (Review if Low)
+```
 
-## Eingaben und Ausgaben
+## 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>
+- **`<evaluator.content>`**: Zusammenfassung der Bewertung mit Punktzahlen
+- **`<evaluator.model>`**: Für die Bewertung verwendetes Modell
+- **`<evaluator.tokens>`**: Statistik zur Token-Nutzung
+- **`<evaluator.cost>`**: Geschätzte Bewertungskosten
 
 ## 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
+- **Wählen Sie geeignete Bereiche**: Wählen Sie Bewertungsbereiche, die ausreichend Granularität bieten, ohne zu 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
+- **Kombinieren Sie mehrere Metriken**: Verwenden Sie verschiedene Metriken, um eine umfassende Bewertung zu erhalten

apps/docs/content/docs/de/blocks/function.mdx

@@ -2,124 +2,44 @@
 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.
+Der Funktionsblock führt benutzerdefinierten JavaScript- oder TypeScript-Code in Ihren Workflows aus. Transformieren Sie Daten, führen Sie Berechnungen durch oder implementieren Sie benutzerdefinierte Logik.
 
 <div className="flex justify-center">
   <Image
     src="/static/blocks/function.png"
     alt="Funktionsblock mit Code-Editor"
     width={500}
-    height={350}
+    height={400}
     className="my-6"
   />
 </div>
 
-## Überblick
+## Ausgaben
 
-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>
+- **`<function.result>`**: Der von Ihrer Funktion zurückgegebene Wert
+- **`<function.stdout>`**: Console.log()-Ausgabe Ihres Codes
 
 ## Beispielanwendungsfälle
 
-### Datenverarbeitungspipeline
+**Datenverarbeitungspipeline** - Transformation von API-Antworten in strukturierte Daten
 
-<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>
+```
+API (Fetch) → Function (Process & Validate) → Function (Calculate Metrics) → Response
+```
 
-### Implementierung von Geschäftslogik
+**Implementierung von Geschäftslogik** - Berechnung von Treuepunkten und Stufen
 
-<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>
+```
+Agent (Get History) → Function (Calculate Score) → Function (Determine Tier) → Condition (Route)
+```
 
-### Datenvalidierung und -bereinigung
+**Datenvalidierung und -bereinigung** - Validierung und Bereinigung von Benutzereingaben
 
-<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>
+```
+Input → Function (Validate & Sanitize) → API (Save to Database)
+```
 
 ### Beispiel: Treuepunkte-Rechner
 
@@ -152,5 +72,5 @@ return {
 - **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
+- **Für 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

apps/docs/content/docs/de/blocks/guardrails.mdx

@@ -0,0 +1,207 @@
+---
+title: Guardrails
+---
+
+import { Callout } from 'fumadocs-ui/components/callout'
+import { Image } from '@/components/ui/image'
+import { Video } from '@/components/ui/video'
+
+Der Guardrails-Block validiert und schützt Ihre KI-Workflows, indem er Inhalte anhand mehrerer Validierungstypen überprüft. Stellen Sie die Datenqualität sicher, verhindern Sie Halluzinationen, erkennen Sie personenbezogene Daten und erzwingen Sie Formatanforderungen, bevor Inhalte durch Ihren Workflow fließen.
+
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/guardrails.png"
+    alt="Guardrails-Block"
+    width={500}
+    height={400}
+    className="my-6"
+  />
+</div>
+
+## Validierungstypen
+
+### JSON-Validierung
+
+Überprüft, ob der Inhalt korrekt formatiertes JSON ist. Perfekt, um sicherzustellen, dass strukturierte LLM-Ausgaben sicher geparst werden können.
+
+**Anwendungsfälle:**
+- Validierung von JSON-Antworten aus Agent-Blöcken vor dem Parsen
+- Sicherstellen, dass API-Payloads korrekt formatiert sind
+- Überprüfung der Integrität strukturierter Daten
+
+**Ausgabe:**
+- `passed`: `true` bei gültigem JSON, sonst `false`
+- `error`: Fehlermeldung bei fehlgeschlagener Validierung (z.B. "Ungültiges JSON: Unerwartetes Token...")
+
+### Regex-Validierung
+
+Prüft, ob der Inhalt einem bestimmten regulären Ausdrucksmuster entspricht.
+
+**Anwendungsfälle:**
+- Validierung von E-Mail-Adressen
+- Überprüfung von Telefonnummernformaten
+- Verifizierung von URLs oder benutzerdefinierten Kennungen
+- Durchsetzung spezifischer Textmuster
+
+**Konfiguration:**
+- **Regex-Muster**: Der reguläre Ausdruck, gegen den geprüft wird (z.B. `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$` für E-Mails)
+
+**Ausgabe:**
+- `passed`: `true` wenn der Inhalt dem Muster entspricht, sonst `false`
+- `error`: Fehlermeldung bei fehlgeschlagener Validierung
+
+### Halluzinationserkennung
+
+Verwendet Retrieval-Augmented Generation (RAG) mit LLM-Bewertung, um zu erkennen, wann KI-generierte Inhalte im Widerspruch zu Ihrer Wissensdatenbank stehen oder nicht darin begründet sind.
+
+**Funktionsweise:**
+1. Abfrage Ihrer Wissensdatenbank nach relevantem Kontext
+2. Übermittlung sowohl der KI-Ausgabe als auch des abgerufenen Kontexts an ein LLM
+3. LLM weist einen Konfidenzwert zu (Skala 0-10)
+   - **0** = Vollständige Halluzination (völlig unbegründet)
+   - **10** = Vollständig begründet (komplett durch die Wissensdatenbank gestützt)
+4. Validierung besteht, wenn der Wert ≥ Schwellenwert ist (Standard: 3)
+
+**Konfiguration:**
+- **Wissensdatenbank**: Wählen Sie aus Ihren vorhandenen Wissensdatenbanken
+- **Modell**: Wählen Sie LLM für die Bewertung (erfordert starkes Denkvermögen - GPT-4o, Claude 3.7 Sonnet empfohlen)
+- **API-Schlüssel**: Authentifizierung für den ausgewählten LLM-Anbieter (automatisch ausgeblendet für gehostete/Ollama oder VLLM-kompatible Modelle)
+- **Vertrauensschwelle**: Mindestpunktzahl zum Bestehen (0-10, Standard: 3)
+- **Top K** (Erweitert): Anzahl der abzurufenden Wissensdatenbank-Chunks (Standard: 10)
+
+**Ausgabe:**
+- `passed`: `true` wenn Konfidenzwert ≥ Schwellenwert
+- `score`: Konfidenzwert (0-10)
+- `reasoning`: Erklärung des LLM für den Wert
+- `error`: Fehlermeldung bei fehlgeschlagener Validierung
+
+**Anwendungsfälle:**
+- Validierung von Agent-Antworten anhand der Dokumentation
+- Sicherstellung der faktischen Richtigkeit von Kundendienstantworten
+- Überprüfung, ob generierte Inhalte mit dem Quellmaterial übereinstimmen
+- Qualitätskontrolle für RAG-Anwendungen
+
+### PII-Erkennung
+
+Erkennt personenbezogene Daten mithilfe von Microsoft Presidio. Unterstützt über 40 Entitätstypen in mehreren Ländern und Sprachen.
+
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/guardrails-2.png"
+    alt="PII-Erkennungskonfiguration"
+    width={700}
+    height={450}
+    className="my-6"
+  />
+</div>
+
+**Funktionsweise:**
+1. Übergabe des zu validierenden Inhalts (z.B. `<agent1.content>`)
+2. Auswahl der zu erkennenden PII-Typen über den Modal-Selektor
+3. Auswahl des Erkennungsmodus (Erkennen oder Maskieren)
+4. Inhalt wird auf übereinstimmende PII-Entitäten gescannt
+5. Gibt Erkennungsergebnisse und optional maskierten Text zurück
+
+<div className="mx-auto w-3/5 overflow-hidden rounded-lg">
+  <Video src="guardrails.mp4" width={500} height={350} />
+</div>
+
+**Konfiguration:**
+- **Zu erkennende PII-Typen**: Auswahl aus gruppierten Kategorien über Modal-Selektor
+  - **Allgemein**: Personenname, E-Mail, Telefon, Kreditkarte, IP-Adresse usw.
+  - **USA**: Sozialversicherungsnummer, Führerschein, Reisepass usw.
+  - **UK**: NHS-Nummer, Sozialversicherungsnummer
+  - **Spanien**: NIF, NIE, CIF
+  - **Italien**: Steuernummer, Führerschein, Umsatzsteuer-ID
+  - **Polen**: PESEL, NIP, REGON
+  - **Singapur**: NRIC/FIN, UEN
+  - **Australien**: ABN, ACN, TFN, Medicare
+  - **Indien**: Aadhaar, PAN, Reisepass, Wählernummer
+- **Modus**: 
+  - **Erkennen**: Nur PII identifizieren (Standard)
+  - **Maskieren**: Erkannte PII durch maskierte Werte ersetzen
+- **Sprache**: Erkennungssprache (Standard: Englisch)
+
+**Ausgabe:**
+- `passed`: `false` wenn ausgewählte PII-Typen erkannt werden
+- `detectedEntities`: Array erkannter PII mit Typ, Position und Konfidenz
+- `maskedText`: Inhalt mit maskierter PII (nur wenn Modus = "Mask")
+- `error`: Fehlermeldung bei fehlgeschlagener Validierung
+
+**Anwendungsfälle:**
+- Blockieren von Inhalten mit sensiblen persönlichen Informationen
+- Maskieren von personenbezogenen Daten vor der Protokollierung oder Speicherung
+- Einhaltung der DSGVO, HIPAA und anderer Datenschutzbestimmungen
+- Bereinigung von Benutzereingaben vor der Verarbeitung
+
+## Konfiguration
+
+### Zu validierende Inhalte
+
+Der zu validierende Eingabeinhalt. Dieser stammt typischerweise aus:
+- Ausgaben von Agent-Blöcken: `<agent.content>`
+- Ergebnisse von Funktionsblöcken: `<function.output>`
+- API-Antworten: `<api.output>`
+- Jede andere Blockausgabe
+
+### Validierungstyp
+
+Wählen Sie aus vier Validierungstypen:
+- **Gültiges JSON**: Prüfen, ob der Inhalt korrekt formatiertes JSON ist
+- **Regex-Übereinstimmung**: Überprüfen, ob der Inhalt einem Regex-Muster entspricht
+- **Halluzinationsprüfung**: Validierung gegen Wissensdatenbank mit LLM-Bewertung
+- **PII-Erkennung**: Erkennung und optional Maskierung personenbezogener Daten
+
+## Ausgaben
+
+Alle Validierungstypen geben zurück:
+
+- **`<guardrails.passed>`**: Boolescher Wert, der angibt, ob die Validierung bestanden wurde
+- **`<guardrails.validationType>`**: Der durchgeführte Validierungstyp
+- **`<guardrails.input>`**: Die ursprüngliche Eingabe, die validiert wurde
+- **`<guardrails.error>`**: Fehlermeldung, wenn die Validierung fehlgeschlagen ist (optional)
+
+Zusätzliche Ausgaben nach Typ:
+
+**Halluzinationsprüfung:**
+- **`<guardrails.score>`**: Konfidenzwert (0-10)
+- **`<guardrails.reasoning>`**: Erklärung des LLM
+
+**PII-Erkennung:**
+- **`<guardrails.detectedEntities>`**: Array erkannter PII-Entitäten
+- **`<guardrails.maskedText>`**: Inhalt mit maskierten PII (wenn Modus = "Mask")
+
+## Beispielanwendungsfälle
+
+**JSON vor dem Parsen validieren** - Stellen Sie sicher, dass die Agent-Ausgabe gültiges JSON ist
+
+```
+Agent (Generate) → Guardrails (Validate) → Condition (Check passed) → Function (Parse)
+```
+
+**Halluzinationen verhindern** - Validieren Sie Kundendienstantworten anhand der Wissensdatenbank
+
+```
+Agent (Response) → Guardrails (Check KB) → Condition (Score ≥ 3) → Send or Flag
+```
+
+**PII in Benutzereingaben blockieren** - Bereinigen Sie von Benutzern übermittelte Inhalte
+
+```
+Input → Guardrails (Detect PII) → Condition (No PII) → Process or Reject
+```
+
+## Bewährte Praktiken
+
+- **Verkettung mit Bedingungsblöcken**: Verwenden Sie `<guardrails.passed>`, um die Workflow-Logik basierend auf Validierungsergebnissen zu verzweigen
+- **JSON-Validierung vor dem Parsen verwenden**: Validieren Sie immer die JSON-Struktur, bevor Sie versuchen, LLM-Ausgaben zu parsen
+- **Geeignete PII-Typen auswählen**: Wählen Sie nur die für Ihren Anwendungsfall relevanten PII-Entitätstypen für bessere Leistung
+- **Angemessene Konfidenzgrenzwerte festlegen**: Passen Sie für die Halluzinationserkennung den Grenzwert an Ihre Genauigkeitsanforderungen an (höher = strenger)
+- **Starke Modelle für die Halluzinationserkennung verwenden**: GPT-4o oder Claude 3.7 Sonnet bieten genauere Konfidenzwerte
+- **PII für die Protokollierung maskieren**: Verwenden Sie den Modus "Mask", wenn Sie Inhalte protokollieren oder speichern müssen, die PII enthalten könnten
+- **Regex-Muster testen**: Validieren Sie Ihre Regex-Muster gründlich, bevor Sie sie in der Produktion einsetzen
+- **Validierungsfehler überwachen**: Verfolgen Sie `<guardrails.error>`Nachrichten, um häufige Validierungsprobleme zu identifizieren
+
+<Callout type="info">
+  Die Validierung von Guardrails erfolgt synchron in Ihrem Workflow. Für die Erkennung von Halluzinationen sollten Sie schnellere Modelle (wie GPT-4o-mini) wählen, wenn die Latenz kritisch ist.
+</Callout>

apps/docs/content/docs/de/blocks/human-in-the-loop.mdx

@@ -0,0 +1,188 @@
+---
+title: Human in the Loop
+---
+
+import { Callout } from 'fumadocs-ui/components/callout'
+import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
+import { Image } from '@/components/ui/image'
+import { Video } from '@/components/ui/video'
+
+Der Human in the Loop Block pausiert die Workflow-Ausführung und wartet auf menschliches Eingreifen, bevor er fortfährt. Verwenden Sie ihn, um Genehmigungspunkte hinzuzufügen, Feedback zu sammeln oder zusätzliche Eingaben an kritischen Entscheidungspunkten einzuholen.
+
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/hitl-1.png"
+    alt="Human in the Loop Block Konfiguration"
+    width={500}
+    height={400}
+    className="my-6"
+  />
+</div>
+
+Wenn die Ausführung diesen Block erreicht, pausiert der Workflow auf unbestimmte Zeit, bis ein Mensch über das Genehmigungsportal, die API oder den Webhook eine Eingabe macht.
+
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/hitl-2.png"
+    alt="Human in the Loop Genehmigungsportal"
+    width={700}
+    height={500}
+    className="my-6"
+  />
+</div>
+
+## Konfigurationsoptionen
+
+### Pausierte Ausgabe
+
+Definiert, welche Daten dem Genehmigenden angezeigt werden. Dies ist der Kontext, der im Genehmigungsportal angezeigt wird, um eine fundierte Entscheidung zu ermöglichen.
+
+Verwenden Sie den visuellen Builder oder den JSON-Editor, um die Daten zu strukturieren. Referenzieren Sie Workflow-Variablen mit der `<blockName.output>` Syntax.
+
+```json
+{
+  "customerName": "<agent1.content.name>",
+  "proposedAction": "<router1.selectedPath>",
+  "confidenceScore": "<evaluator1.score>",
+  "generatedEmail": "<agent2.content>"
+}
+```
+
+### Benachrichtigung
+
+Konfiguriert, wie Genehmigende benachrichtigt werden, wenn eine Genehmigung erforderlich ist. Unterstützte Kanäle sind:
+
+- **Slack** - Nachrichten an Kanäle oder DMs
+- **Gmail** - E-Mail mit Genehmigungslink
+- **Microsoft Teams** - Team-Kanal-Benachrichtigungen
+- **SMS** - Textwarnungen über Twilio
+- **Webhooks** - Benutzerdefinierte Benachrichtigungssysteme
+
+Fügen Sie die Genehmigungs-URL (`<blockId.url>`) in Ihre Benachrichtigungsnachrichten ein, damit Genehmigende auf das Portal zugreifen können.
+
+### Fortsetzungseingabe
+
+Definiert die Felder, die Genehmigende bei der Antwort ausfüllen. Diese Daten werden nach der Fortsetzung des Workflows für nachfolgende Blöcke verfügbar.
+
+```json
+{
+  "approved": {
+    "type": "boolean",
+    "description": "Approve or reject this request"
+  },
+  "comments": {
+    "type": "string",
+    "description": "Optional feedback or explanation"
+  }
+}
+```
+
+Greifen Sie in nachgelagerten Blöcken auf Wiederaufnahmedaten mit `<blockId.resumeInput.fieldName>` zu. 
+
+## Genehmigungsmethoden
+
+<Tabs items={['Genehmigungsportal', 'API', 'Webhook']}>
+  <Tab>
+    ### Genehmigungsportal
+    
+    Jeder Block generiert eine eindeutige Portal-URL (`<blockId.url>`) mit einer visuellen Oberfläche, die alle pausierten Ausgabedaten und Formularfelder für die Fortsetzungseingabe anzeigt. Mobilgerätekompatibel und sicher.
+    
+    Teilen Sie diese URL in Benachrichtigungen, damit Genehmiger die Anfragen prüfen und beantworten können.
+  </Tab>
+  <Tab>
+    ### REST API
+    
+    Workflows programmatisch fortsetzen:
+    
+
+    ```bash
+    POST /api/workflows/{workflowId}/executions/{executionId}/resume/{blockId}
+    
+    {
+      "approved": true,
+      "comments": "Looks good to proceed"
+    }
+    ```
+
+    
+    Erstellen Sie benutzerdefinierte Genehmigungs-UIs oder integrieren Sie bestehende Systeme.
+  </Tab>
+  <Tab>
+    ### Webhook
+    
+    Fügen Sie ein Webhook-Tool im Benachrichtigungsbereich hinzu, um Genehmigungsanfragen an externe Systeme zu senden. Integration mit Ticketing-Systemen wie Jira oder ServiceNow.
+  </Tab>
+</Tabs>
+
+## Häufige Anwendungsfälle
+
+**Inhaltsgenehmigung** - Überprüfung von KI-generierten Inhalten vor der Veröffentlichung
+
+```
+Agent → Human in the Loop → API (Publish)
+```
+
+**Mehrstufige Genehmigungen** - Verkettung mehrerer Genehmigungsschritte für wichtige Entscheidungen
+
+```
+Agent → Human in the Loop (Manager) → Human in the Loop (Director) → Execute
+```
+
+**Datenvalidierung** - Überprüfung extrahierter Daten vor der Verarbeitung
+
+```
+Agent (Extract) → Human in the Loop (Validate) → Function (Process)
+```
+
+**Qualitätskontrolle** - Überprüfung von KI-Ausgaben vor dem Versand an Kunden
+
+```
+Agent (Generate) → Human in the Loop (QA) → Gmail (Send)
+```
+
+## Block-Ausgaben
+
+**`url`** - Eindeutige URL für das Genehmigungsportal  
+**`resumeInput.*`** - Alle in der Fortsetzungseingabe definierten Felder werden verfügbar, nachdem der Workflow fortgesetzt wird
+
+Zugriff über `<blockId.resumeInput.fieldName>`.
+
+## Beispiel
+
+**Pausierte Ausgabe:**
+
+```json
+{
+  "title": "<agent1.content.title>",
+  "body": "<agent1.content.body>",
+  "qualityScore": "<evaluator1.score>"
+}
+```
+
+**Fortsetzungseingabe:**
+
+```json
+{
+  "approved": { "type": "boolean" },
+  "feedback": { "type": "string" }
+}
+```
+
+**Nachgelagerte Verwendung:**
+
+```javascript
+// Condition block
+<approval1.resumeInput.approved> === true
+```
+
+Das Beispiel unten zeigt ein Genehmigungsportal, wie es von einem Genehmiger gesehen wird, nachdem der Workflow angehalten wurde. Genehmiger können die Daten überprüfen und Eingaben als Teil der Workflow-Wiederaufnahme bereitstellen. Auf das Genehmigungsportal kann direkt über die eindeutige URL, `<blockId.url>`, zugegriffen werden.
+
+<div className="mx-auto w-full overflow-hidden rounded-lg my-6">
+  <Video src="hitl-resume.mp4" width={700} height={450} />
+</div>
+
+## Verwandte Blöcke
+
+- **[Bedingung](/blocks/condition)** - Verzweigung basierend auf Genehmigungsentscheidungen
+- **[Variablen](/blocks/variables)** - Speichern von Genehmigungsverlauf und Metadaten
+- **[Antwort](/blocks/response)** - Rückgabe von Workflow-Ergebnissen an API-Aufrufer

apps/docs/content/docs/de/blocks/index.mdx

@@ -1,5 +1,5 @@
 ---
-title: Blöcke
+title: Übersicht
 description: Die Bausteine deiner KI-Workflows
 ---
 
@@ -16,7 +16,7 @@ Blöcke sind die Bausteine, die du miteinander verbindest, um KI-Workflows zu er
 
 ## Grundlegende Blocktypen
 
-Sim bietet sieben grundlegende Blocktypen, die die wesentlichen Funktionen von KI-Workflows abdecken:
+Sim bietet wesentliche Blocktypen, die die Kernfunktionen von KI-Workflows abdecken:
 
 ### Verarbeitungsblöcke
 - **[Agent](/blocks/agent)** - Chatte mit KI-Modellen (OpenAI, Anthropic, Google, lokale Modelle)
@@ -28,16 +28,21 @@ Sim bietet sieben grundlegende Blocktypen, die die wesentlichen Funktionen von K
 - **[Router](/blocks/router)** - Nutze KI, um Anfragen intelligent auf verschiedene Pfade zu leiten
 - **[Evaluator](/blocks/evaluator)** - Bewerte und beurteile die Inhaltsqualität mit KI
 
+### Ablaufsteuerungsblöcke
+- **[Variablen](/blocks/variables)** - Workflow-bezogene Variablen setzen und verwalten
+- **[Warten](/blocks/wait)** - Workflow-Ausführung für eine bestimmte Zeitverzögerung pausieren
+- **[Mensch in der Schleife](/blocks/human-in-the-loop)** - Pausieren für menschliche Genehmigung und Feedback vor dem Fortfahren
+
 ### Ausgabeblöcke
-- **[Response](/blocks/response)** - Formatiere und gib endgültige Ergebnisse aus deinem Workflow zurück
+- **[Antwort](/blocks/response)** - Formatieren und Zurückgeben der endgültigen Ergebnisse aus Ihrem Workflow
 
 ## 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
+**Konfiguration**: Einstellungen, die steuern, wie der Block sich verhält
+**Ausgaben**: Daten, die der Block für andere Blöcke zur Verwendung erzeugt
 
 <Steps>
   <Step>
@@ -56,7 +61,7 @@ Jeder Block hat drei Hauptkomponenten:
 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
+- **Mehrfachverbindungen**: Eine Ausgabe kann mit mehreren Eingaben 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">
@@ -73,7 +78,7 @@ User Input → Agent → Function → Response
 ```
 
 ### Bedingte Verzweigung
-Verwenden Sie Bedingungsblöcke oder Router-Blöcke, um verschiedene Pfade zu erstellen:
+Verwenden Sie Bedingung- oder Router-Blöcke, um verschiedene Pfade zu erstellen:
 
 ```
 User Input → Router → Agent A (for questions)
@@ -93,37 +98,46 @@ Agent → Evaluator → Condition → Response (if good)
 Jeder Blocktyp hat spezifische Konfigurationsoptionen:
 
 **Alle Blöcke**:
-- Ein-/Ausgabeverbindungen
+- Eingabe-/Ausgabeverbindungen
 - Fehlerbehandlungsverhalten
-- Zeitüberschreitungseinstellungen für die Ausführung
+- Einstellungen für Ausführungs-Timeout
 
 **KI-Blöcke** (Agent, Router, Evaluator):
 - Modellauswahl (OpenAI, Anthropic, Google, lokal)
 - API-Schlüssel und Authentifizierung
-- Temperature und andere Modellparameter
+- Temperatur und andere Modellparameter
 - Systemaufforderungen und Anweisungen
 
-**Logikblöcke** (Bedingung, Funktion):
+**Logik-Blöcke** (Bedingung, Funktion):
 - Benutzerdefinierte Ausdrücke oder Code
 - Variablenreferenzen
-- Einstellungen für die Ausführungsumgebung
+- Einstellungen für Ausführungsumgebung
 
-**Integrationsblöcke** (API, Antwort):
+**Integrations-Blöcke** (API, Response):
 - Endpunktkonfiguration
 - Header und Authentifizierung
 - Anfrage-/Antwortformatierung
 
 <Cards>
-  <Card title="Agent Block" href="/blocks/agent">
-    Verbindung zu KI-Modellen herstellen und intelligente Antworten erzeugen
+  <Card title="Agent-Block" href="/blocks/agent">
+    Verbindung zu KI-Modellen herstellen und intelligente Antworten erstellen
   </Card>
-  <Card title="Function Block" href="/blocks/function">
+  <Card title="Funktionsblock" href="/blocks/function">
     Benutzerdefinierten Code ausführen, um Daten zu verarbeiten und zu transformieren
   </Card>
-  <Card title="API Block" href="/blocks/api">
+  <Card title="API-Block" href="/blocks/api">
     Integration mit externen Diensten und APIs
   </Card>
-  <Card title="Condition Block" href="/blocks/condition">
+  <Card title="Bedingungsblock" href="/blocks/condition">
     Verzweigende Logik basierend auf Datenbewertung erstellen
   </Card>
+  <Card title="Mensch-in-der-Schleife-Block" href="/blocks/human-in-the-loop">
+    Pausieren für menschliche Genehmigung und Feedback vor dem Fortfahren
+  </Card>
+  <Card title="Variablenblock" href="/blocks/variables">
+    Workflow-bezogene Variablen setzen und verwalten
+  </Card>
+  <Card title="Warteblock" href="/blocks/wait">
+    Workflow-Ausführung für bestimmte Zeitverzögerungen pausieren
+  </Card>
 </Cards>

apps/docs/content/docs/de/blocks/loop.mdx

@@ -3,67 +3,36 @@ 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:
+Der Schleifenblock ist ein Container, der Blöcke wiederholt ausführt. Iteriere über Sammlungen, wiederhole Operationen eine festgelegte Anzahl von Malen oder fahre fort, solange eine Bedingung erfüllt ist.
 
 <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.
+  Schleifenblöcke sind Container-Knoten, die andere Blöcke in sich enthalten. Die enthaltenen Blöcke werden mehrfach ausgeführt, basierend auf deiner Konfiguration.
 </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:
+Wähle zwischen vier Arten von Schleifen:
 
-<Tabs items={['For Loop', 'ForEach Loop']}>
+<Tabs items={['For-Schleife', 'ForEach-Schleife', 'While-Schleife', 'Do-While-Schleife']}>
   <Tab>
-    **For Loop (Iterationen)** - Eine numerische Schleife, die eine feste Anzahl von Malen ausgeführt wird:
+    **For-Schleife (Iterationen)** - Eine numerische Schleife, die eine festgelegte Anzahl von Malen ausgeführt wird:
     
     <div className="flex justify-center">
       <Image
         src="/static/blocks/loop-1.png"
-        alt="For Loop mit Iterationen"
+        alt="For-Schleife mit Iterationen"
         width={500}
         height={400}
         className="my-6"
       />
     </div>
     
-    Verwende diese Option, wenn du eine Operation eine bestimmte Anzahl von Malen wiederholen musst.
+    Verwende diese, wenn du eine Operation eine bestimmte Anzahl von Malen wiederholen musst.
     
 
     ```
@@ -100,6 +69,56 @@ Wähle zwischen zwei Arten von Schleifen:
     ```
 
   </Tab>
+  <Tab>
+    **While-Schleife (Bedingungsbasiert)** - Wird ausgeführt, solange eine Bedingung als wahr ausgewertet wird:
+    
+    <div className="flex justify-center">
+      <Image
+        src="/static/blocks/loop-3.png"
+        alt="While-Schleife mit Bedingung"
+        width={500}
+        height={400}
+        className="my-6"
+      />
+    </div>
+    
+    Verwende diese, wenn du eine Schleife benötigst, die läuft, bis eine bestimmte Bedingung erfüllt ist. Die Bedingung wird **vor** jeder Iteration überprüft.
+
+    ```
+    Example: While {"<variable.i>"} < 10
+    - Check condition → Execute if true
+    - Inside loop: Increment {"<variable.i>"}
+    - Inside loop: Variables assigns i = {"<variable.i>"} + 1
+    - Check condition → Execute if true
+    - Check condition → Exit if false
+    ```
+
+  </Tab>
+  <Tab>
+    **Do-While-Schleife (Bedingungsbasiert)** - Wird mindestens einmal ausgeführt und dann fortgesetzt, solange eine Bedingung wahr ist:
+    
+    <div className="flex justify-center">
+      <Image
+        src="/static/blocks/loop-4.png"
+        alt="Do-While-Schleife mit Bedingung"
+        width={500}
+        height={400}
+        className="my-6"
+      />
+    </div>
+    
+    Verwende diese, wenn du eine Operation mindestens einmal ausführen musst und dann die Schleife fortsetzen willst, bis eine Bedingung erfüllt ist. Die Bedingung wird **nach** jeder Iteration überprüft.
+
+    ```
+    Example: Do-while {"<variable.i>"} < 10
+    - Execute blocks
+    - Inside loop: Increment {"<variable.i>"}
+    - Inside loop: Variables assigns i = {"<variable.i>"} + 1
+    - Check condition → Continue if true
+    - Check condition → Exit if false
+    ```
+
+  </Tab>
 </Tabs>
 
 ## Wie man Schleifen verwendet
@@ -115,33 +134,57 @@ Wähle zwischen zwei Arten von Schleifen:
 
 Nach Abschluss einer Schleife kannst du auf aggregierte Ergebnisse zugreifen:
 
-- **`<loop.results>`**: Array von Ergebnissen aus allen Schleifendurchläufen
+- **loop.results**: Array mit Ergebnissen aller Schleifendurchläufe
 
 ## Beispielanwendungsfälle
 
-### Verarbeitung von API-Ergebnissen
+**Verarbeitung von API-Ergebnissen** - ForEach-Schleife verarbeitet Kundendatensätze aus einer API
 
-<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>
+```javascript
+// Beispiel: ForEach-Schleife für API-Ergebnisse
+const customers = await api.getCustomers();
 
-### Iterative Inhaltserstellung
+loop.forEach(customers, (customer) => {
+  // Verarbeite jeden Kunden
+  if (customer.status === 'active') {
+    sendEmail(customer.email, 'Sonderangebot');
+  }
+});
+```
 
-<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>
+**Iterative Inhaltsgenerierung** - For-Schleife generiert mehrere Inhaltsvariationen
+
+```javascript
+// Beispiel: For-Schleife für Inhaltsgenerierung
+const variations = [];
+
+loop.for(5, (i) => {
+  // Generiere 5 verschiedene Variationen
+  const content = ai.generateContent({
+    prompt: `Variation ${i+1} für Produktbeschreibung`,
+    temperature: 0.7 + (i * 0.1)
+  });
+  variations.push(content);
+});
+```
+
+**Zähler mit While-Schleife** - While-Schleife verarbeitet Elemente mit Zähler
+
+```javascript
+// Beispiel: While-Schleife mit Zähler
+let counter = 0;
+let processedItems = 0;
+
+loop.while(() => counter < items.length, () => {
+  if (items[counter].isValid) {
+    processItem(items[counter]);
+    processedItems++;
+  }
+  counter++;
+});
+
+console.log(`${processedItems} gültige Elemente verarbeitet`);
+```
 
 ## Erweiterte Funktionen
 
@@ -150,23 +193,23 @@ Nach Abschluss einer Schleife kannst du auf aggregierte Ergebnisse zugreifen:
 <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 Parallel-Block 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.
+  Schleifen werden sequentiell ausgeführt, nicht parallel. Wenn du eine gleichzeitige Ausführung benötigst, verwende stattdessen den Parallel-Block.
 </Callout>
 
 ## Eingaben und Ausgaben
 
-<Tabs items={['Konfiguration', 'Variablen', 'Ergebnisse']}>
+<Tabs items={['Configuration', 'Variables', 'Results']}>
   <Tab>
     <ul className="list-disc space-y-2 pl-6">
       <li>
-        <strong>Schleifentyp</strong>: Wählen Sie zwischen 'for' oder 'forEach'
+        <strong>Schleifentyp</strong>: Wähle zwischen 'for', 'forEach', 'while' oder 'doWhile'
       </li>
       <li>
         <strong>Iterationen</strong>: Anzahl der Ausführungen (für for-Schleifen)
@@ -174,6 +217,9 @@ Nach Abschluss einer Schleife kannst du auf aggregierte Ergebnisse zugreifen:
       <li>
         <strong>Sammlung</strong>: Array oder Objekt zum Durchlaufen (für forEach-Schleifen)
       </li>
+      <li>
+        <strong>Bedingung</strong>: Boolescher Ausdruck zur Auswertung (für while/do-while-Schleifen)
+      </li>
     </ul>
   </Tab>
   <Tab>
@@ -185,7 +231,7 @@ Nach Abschluss einer Schleife kannst du auf aggregierte Ergebnisse zugreifen:
         <strong>loop.index</strong>: Aktuelle Iterationsnummer (0-basiert)
       </li>
       <li>
-        <strong>loop.items</strong>: Vollständige Sammlung (forEach-Schleifen)
+        <strong>loop.items</strong>: Vollständige Sammlung (für forEach-Schleifen)
       </li>
     </ul>
   </Tab>
@@ -204,8 +250,8 @@ Nach Abschluss einer Schleife kannst du auf aggregierte Ergebnisse zugreifen:
   </Tab>
 </Tabs>
 
-## Best Practices
+## Bewährte Praktiken
 
 - **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
+- **Verwenden Sie ForEach für Sammlungen**: Verwenden Sie beim Verarbeiten von Arrays oder Objekten ForEach anstelle von For-Schleifen
+- **Behandeln Sie Fehler elegant**: Erwägen Sie, Fehlerbehandlung innerhalb von Schleifen hinzuzufügen, um robuste Workflows zu gewährleisten

apps/docs/content/docs/de/blocks/parallel.mdx

@@ -3,46 +3,24 @@ 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:
+Der Parallel-Block ist ein Container, der mehrere Instanzen gleichzeitig ausführt, um Workflows schneller zu verarbeiten. Verarbeiten Sie Elemente simultan statt sequentiell.
 
 <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:
+Wählen Sie 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:
+    **Anzahlbasierte Parallelisierung** - Führen Sie eine feste Anzahl paralleler Instanzen aus:
     
     <div className="flex justify-center">
       <Image
@@ -54,21 +32,24 @@ Wähle zwischen zwei Arten der parallelen Ausführung:
       />
     </div>
     
-    Verwende dies, wenn du dieselbe Operation mehrmals gleichzeitig ausführen musst.
+    Verwenden Sie diese Option, wenn Sie dieselbe Operation mehrmals gleichzeitig ausführen müssen.
     
 
-    ```
-    Example: Run 5 parallel instances
-    - Instance 1 ┐
-    - Instance 2 ├─ All execute simultaneously
-    - Instance 3 │
-    - Instance 4 │
-    - Instance 5 ┘
-    ```
+```javascript
+// Beispiel: 3 parallele Instanzen ausführen
+const results = await blocks.parallel({
+  type: 'count',
+  count: 3,
+  async process(index) {
+    // Jede Instanz erhält einen eindeutigen Index (0, 1, 2)
+    return `Ergebnis von Instanz ${index}`;
+  }
+});
+```
 
   </Tab>
   <Tab>
-    **Sammlungsbasierte Parallelität** - Verteile eine Sammlung auf parallele Instanzen:
+    **Sammlungsbasierte Parallelisierung** - Verteilen Sie eine Sammlung auf parallele Instanzen:
     
     <div className="flex justify-center">
       <Image
@@ -83,45 +64,57 @@ Wähle zwischen zwei Arten der parallelen Ausführung:
     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" ┘
-    ```
+```javascript
+// Beispiel: Eine Liste von URLs parallel verarbeiten
+const urls = [
+  'https://example.com/api/1',
+  'https://example.com/api/2',
+  'https://example.com/api/3'
+];
+
+const results = await blocks.parallel({
+  type: 'collection',
+  items: urls,
+  async process(url, index) {
+    // Jede Instanz verarbeitet eine URL
+    const response = await fetch(url);
+    return response.json();
+  }
+});
+```
 
   </Tab>
 </Tabs>
 
-## Wie man Parallel-Blöcke verwendet
+## Verwendung von Parallel-Blöcken
 
-### Einen Parallel-Block erstellen
+### Erstellen eines Parallel-Blocks
 
-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
+1. Ziehen Sie einen Parallel-Block aus der Symbolleiste auf Ihre Leinwand
+2. Konfigurieren Sie den Parallel-Typ und die Parameter
+3. Ziehen Sie einen einzelnen Block in den Parallel-Container
+4. Verbinden Sie den Block nach Bedarf
 
-### Auf Ergebnisse zugreifen
+### Zugriff auf Ergebnisse
 
-Nach Abschluss eines parallelen Blocks können Sie auf aggregierte Ergebnisse zugreifen:
+Nach Abschluss eines Parallel-Blocks können Sie auf aggregierte Ergebnisse zugreifen:
 
-- **`<parallel.results>`**: Array mit Ergebnissen aus allen parallelen Instanzen
+- **`results`**: Array von Ergebnissen aus allen parallelen Instanzen
 
 ## Beispielanwendungsfälle
 
-### Batch-API-Verarbeitung
+**Batch-API-Verarbeitung** - Verarbeiten Sie mehrere API-Aufrufe gleichzeitig
 
 <div className="mb-4 rounded-md border p-4">
-  <h4 className="font-medium">Szenario: Mehrere API-Aufrufe gleichzeitig verarbeiten</h4>
+  <h4 className="font-medium">Szenario: Mehrere API-Endpunkte abfragen</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>
+    <li>Sammlungsbasierte Parallelisierung über eine Liste von API-Endpunkten</li>
+    <li>Jede Instanz führt einen API-Aufruf durch und verarbeitet die Antwort</li>
+    <li>Ergebnisse werden in einem Array gesammelt und können weiterverarbeitet werden</li>
   </ol>
 </div>
 
-### Multi-Modell-KI-Verarbeitung
+**Multi-Modell-KI-Verarbeitung** - Erhalten Sie Antworten von mehreren KI-Modellen gleichzeitig
 
 <div className="mb-4 rounded-md border p-4">
   <h4 className="font-medium">Szenario: Antworten von mehreren KI-Modellen erhalten</h4>
@@ -138,11 +131,7 @@ Nach Abschluss eines parallelen Blocks können Sie auf aggregierte Ergebnisse zu
 
 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, ...]
-```
+### Anwendungsbeispiele
 
 ### Instanzisolierung
 
@@ -155,27 +144,23 @@ Jede parallele Instanz läuft unabhängig:
 
 <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 Schleifenblock in einen Parallelblock platzieren
+  - Sie können keinen weiteren Parallelblock in einen Parallelblock 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:
+  Während die parallele Ausführung schneller ist, beachten Sie bitte:
   - API-Ratenbegrenzungen bei gleichzeitigen Anfragen
-  - Speichernutzung bei großen Datensätzen
+  - Speicherverbrauch bei großen Datensätzen
   - Maximum von 20 gleichzeitigen Instanzen, um Ressourcenerschöpfung zu vermeiden
 </Callout>
 
-## Parallel vs. Loop
+## Parallel vs. Schleife
 
-Verstehen, wann was zu verwenden ist:
+Wann Sie welche Methode verwenden sollten:
 
-| Funktion | Parallel | Loop |
+| Funktion | Parallel | Schleife |
 |---------|----------|------|
 | Ausführung | Gleichzeitig | Sequentiell |
 | Geschwindigkeit | Schneller für unabhängige Operationen | Langsamer, aber geordnet |
@@ -185,17 +170,17 @@ Verstehen, wann was zu verwenden ist:
 
 ## Eingaben und Ausgaben
 
-<Tabs items={['Konfiguration', 'Variablen', 'Ergebnisse']}>
+<Tabs items={['Configuration', 'Variables', 'Results']}>
   <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)
+        <strong>Anzahl</strong>: Anzahl der auszuführenden Instanzen (anzahlbasiert)
       </li>
       <li>
-        <strong>Collection</strong>: Array oder Objekt zur Verteilung (sammlungsbasiert)
+        <strong>Sammlung</strong>: Array oder Objekt zur Verteilung (sammlungsbasiert)
       </li>
     </ul>
   </Tab>
@@ -218,7 +203,7 @@ Verstehen, wann was zu verwenden ist:
         <strong>parallel.results</strong>: Array aller Instanzergebnisse
       </li>
       <li>
-        <strong>Access</strong>: Verfügbar in Blöcken nach dem Parallel
+        <strong>Zugriff</strong>: Verfügbar in Blöcken nach der Parallelausführung
       </li>
     </ul>
   </Tab>
@@ -227,5 +212,5 @@ Verstehen, wann was zu verwenden ist:
 ## 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
+- **Ratenbegrenzungen berücksichtigen**: Fügen Sie Verzögerungen oder Drosselungen für API-intensive Workflows hinzu
 - **Fehlerbehandlung**: Jede Instanz sollte ihre eigenen Fehler angemessen behandeln

apps/docs/content/docs/de/blocks/response.mdx

@@ -3,11 +3,10 @@ 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.
+Der Response-Block formatiert und sendet strukturierte HTTP-Antworten zurück an API-Aufrufer. Verwenden Sie ihn, um Workflow-Ergebnisse mit korrekten Statuscodes und Headern zurückzugeben.
 
 <div className="flex justify-center">
   <Image
@@ -20,57 +19,9 @@ Der Antwort-Block ist der letzte Schritt in deinem Workflow, der eine strukturie
 </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.
+  Response-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
@@ -78,42 +29,29 @@ JSON direkt schreiben:
 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
+- 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:
+Legen Sie den HTTP-Statuscode für die Antwort fest (standardmäßig 200):
 
-<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>
+**Erfolg (2xx):**
+- **200**: OK - Standard-Erfolgsantwort
+- **201**: Erstellt - Ressource erfolgreich erstellt
+- **204**: Kein Inhalt - Erfolg ohne Antworttext
 
-<div className="mt-4 text-sm text-gray-600 dark:text-gray-400">
-  Der Standard-Statuscode ist 200, wenn nicht anders angegeben.
-</div>
+**Client-Fehler (4xx):**
+- **400**: Ungültige Anfrage - Ungültige Anfrageparameter
+- **401**: Nicht autorisiert - Authentifizierung erforderlich
+- **404**: Nicht gefunden - Ressource existiert nicht
+- **422**: Nicht verarbeitbare Entität - Validierungsfehler
+
+**Server-Fehler (5xx):**
+- **500**: Interner Serverfehler - Serverseitiger Fehler
+- **502**: Bad Gateway - Fehler eines externen Dienstes
+- **503**: Dienst nicht verfügbar - Dienst vorübergehend nicht erreichbar
 
 ### Antwort-Header
 
@@ -129,91 +67,27 @@ Header werden als Schlüssel-Wert-Paare konfiguriert:
 
 ## Beispielanwendungsfälle
 
-### API-Endpunkt-Antwort
+**API-Endpunkt-Antwort** - Strukturierte Daten von einer Such-API zurückgeben
 
-<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>
+```
+Agent (Search) → Function (Format & Paginate) → Response (200, JSON)
+```
 
-### Webhook-Bestätigung
+**Webhook-Bestätigung** - Bestätigung des Webhook-Empfangs und der Verarbeitung
 
-<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>
+```
+Webhook Trigger → Function (Process) → Response (200, Confirmation)
+```
 
-### Fehlerantwort-Behandlung
+**Fehlerantwort-Behandlung** - Angemessene Fehlerantworten zurückgeben
 
-<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>
+```
+Condition (Error Detected) → Router → Response (400/500, Error Details)
+```
 
-## Eingaben und Ausgaben
+## 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>
+Antwortblöcke sind endgültig - sie beenden die Workflow-Ausführung und senden die HTTP-Antwort an den API-Aufrufer. Es stehen keine Ausgaben für nachgelagerte Blöcke zur Verfügung.
 
 ## Variablenreferenzen
 
@@ -240,7 +114,7 @@ Verwenden Sie die `<variable.name>` Syntax, um Workflow-Variablen dynamisch in I
 ## 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
+- **Strukturieren Sie Ihre Antworten einheitlich**: Behalten Sie eine konsistente JSON-Struktur über alle Ihre API-Endpunkte bei, um eine bessere Entwicklererfahrung zu gewährleisten
+- **Fügen Sie relevante Metadaten hinzu**: Fügen Sie Zeitstempel und Versionsinformationen hinzu, um bei der Fehlerbehebung 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
+- **Validieren Sie Variablenreferenzen**: Stellen Sie sicher, dass alle referenzierten Variablen existieren und die erwarteten Datentypen enthalten, bevor der Antwortblock ausgeführt wird

apps/docs/content/docs/de/blocks/router.mdx

@@ -3,13 +3,10 @@ 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.
+Der Router-Block verwendet KI, um Workflows basierend auf Inhaltsanalysen intelligent zu leiten. Im Gegensatz zu Bedingungsblöcken, die einfache Regeln verwenden, verstehen Router Kontext und Absicht.
 
 <div className="flex justify-center">
   <Image
@@ -21,203 +18,83 @@ Der Router-Block nutzt KI, um intelligent zu entscheiden, welchen Pfad Ihr Workf
   />
 </div>
 
-## Überblick
+## Router vs. Bedingung
 
-Der Router-Block ermöglicht Ihnen:
+**Verwende Router, wenn:**
+- KI-gestützte Inhaltsanalyse benötigt wird
+- Mit unstrukturierten oder variierenden Inhalten gearbeitet wird
+- Absichtsbasierte Weiterleitung erforderlich ist (z.B. "Support-Tickets an Abteilungen weiterleiten")
 
-<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>
+**Verwende Bedingung, wenn:**
+- Einfache regelbasierte Entscheidungen ausreichen
+- Mit strukturierten Daten oder numerischen Vergleichen gearbeitet wird
+- Schnelle, deterministische Weiterleitung benötigt wird
 
 ## Konfigurationsoptionen
 
 ### Inhalt/Prompt
 
-Der Inhalt oder Prompt, den der Router analysiert, um Routing-Entscheidungen zu treffen. Dies kann sein:
+Der Inhalt oder Prompt, den der Router analysieren wird, um Weiterleitungsentscheidungen zu treffen. Dies kann sein:
 
 - Eine direkte Benutzeranfrage oder -eingabe
-- Ausgabe aus einem vorherigen Block
-- Eine vom System generierte Nachricht
+- Ausgabe eines vorherigen Blocks
+- Eine systemgenerierte 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 möglichen Zielblöcke, aus denen der Router auswählen kann. Der Router erkennt automatisch verbundene Blöcke, aber du kannst 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
+- Die Beschreibungen von Zielblöcken anpassen, um die Weiterleitungsgenauigkeit zu verbessern
+- Weiterleitungskriterien für jeden Zielblock festlegen
+- Bestimmte Blöcke von der Berücksichtigung als Weiterleitungsziele ausschließen
 
 ### Modellauswahl
 
-Wählen Sie ein KI-Modell für die Routing-Entscheidung:
+Wähle ein KI-Modell für die Weiterleitungsentscheidung:
 
-**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 
+- **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**: Ollama oder VLLM-kompatible Modelle
 
-<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.
+Verwende Modelle mit starken Argumentationsfähigkeiten wie GPT-4o oder Claude 3.7 Sonnet für beste Ergebnisse.
 
 ### 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
+## Ausgaben
 
-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>
+- **`<router.prompt>`**: Zusammenfassung des Routing-Prompts
+- **`<router.selected_path>`**: Ausgewählter Zielblock
+- **`<router.tokens>`**: Token-Nutzungsstatistiken
+- **`<router.cost>`**: Geschätzte Routing-Kosten
+- **`<router.model>`**: Für die Entscheidungsfindung verwendetes Modell
 
 ## Beispielanwendungsfälle
 
-### Kundensupport-Triage
+**Kundensupport-Triage** - Tickets an spezialisierte Abteilungen weiterleiten
 
-<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>
+```
+Input (Ticket) → Router → Agent (Engineering) or Agent (Finance)
+```
 
-### Inhaltsklassifizierung
+**Inhaltsklassifizierung** - Nutzergenerierte Inhalte klassifizieren und weiterleiten
 
-<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>
+```
+Input (Feedback) → Router → Workflow (Product) or Workflow (Technical)
+```
 
-### Lead-Qualifizierung
+**Lead-Qualifizierung** - Leads basierend auf Qualifizierungskriterien weiterleiten
 
-<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>
+```
+Input (Lead) → Router → Agent (Enterprise Sales) or Workflow (Self-serve)
+```
 
 ## Best Practices
 
-- **Klare Zielbeschreibungen bereitstellen**: Helfen Sie dem Router zu verstehen, wann jedes Ziel mit spezifischen, detaillierten Beschreibungen ausgewählt werden soll
+- **Klare Zielbeschreibungen bereitstellen**: Helfen Sie dem Router zu verstehen, wann jedes Ziel ausgewählt werden soll, mit spezifischen, detaillierten Beschreibungen
 - **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

apps/docs/content/docs/de/blocks/variables.mdx

@@ -0,0 +1,86 @@
+---
+title: Variablen
+---
+
+import { Callout } from 'fumadocs-ui/components/callout'
+import { Step, Steps } from 'fumadocs-ui/components/steps'
+import { Image } from '@/components/ui/image'
+
+Der Variablen-Block aktualisiert Workflow-Variablen während der Ausführung. Variablen müssen zuerst im Variablen-Bereich deines Workflows initialisiert werden, dann kannst du diesen Block verwenden, um ihre Werte während der Ausführung deines Workflows zu aktualisieren.
+
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/variables.png"
+    alt="Variablen-Block"
+    width={500}
+    height={400}
+    className="my-6"
+  />
+</div>
+
+<Callout>
+  Greife überall in deinem Workflow auf Variablen zu, indem du die `<variable.variableName>` Syntax verwendest.
+</Callout>
+
+## Wie man Variablen verwendet
+
+### 1. Initialisierung in Workflow-Variablen
+
+Erstellen Sie zunächst Ihre Variablen im Variablenbereich des Workflows (zugänglich über die Workflow-Einstellungen):
+
+```
+customerEmail = ""
+retryCount = 0
+currentStatus = "pending"
+```
+
+### 2. Aktualisierung mit dem Variablen-Block
+
+Verwenden Sie den Variablen-Block, um diese Werte während der Ausführung zu aktualisieren:
+
+```
+customerEmail = <api.email>
+retryCount = <variable.retryCount> + 1
+currentStatus = "processing"
+```
+
+### 3. Überall zugreifen
+
+Referenzieren Sie Variablen in jedem Block:
+
+```
+Agent prompt: "Send email to <variable.customerEmail>"
+Condition: <variable.retryCount> < 5
+API body: {"status": "<variable.currentStatus>"}
+```
+
+## Beispielanwendungsfälle
+
+**Schleifenzähler und Status** - Fortschritt durch Iterationen verfolgen
+
+```
+Loop → Agent (Process) → Variables (itemsProcessed + 1) → Variables (Store lastResult)
+```
+
+**Wiederholungslogik** - API-Wiederholungsversuche verfolgen
+
+```
+API (Try) → Variables (retryCount + 1) → Condition (retryCount < 3)
+```
+
+**Dynamische Konfiguration** - Benutzerkontext für Workflow speichern
+
+```
+API (Fetch Profile) → Variables (userId, userTier) → Agent (Personalize)
+```
+
+## Ausgaben
+
+- **`<variables.assignments>`**: JSON-Objekt mit allen Variablenzuweisungen aus diesem Block
+
+## Bewährte Praktiken
+
+- **In Workflow-Einstellungen initialisieren**: Erstellen Sie Variablen immer im Variablenbereich des Workflows, bevor Sie sie verwenden
+- **Dynamisch aktualisieren**: Verwenden Sie Variablen-Blöcke, um Werte basierend auf Block-Ausgaben oder Berechnungen zu aktualisieren
+- **In Schleifen verwenden**: Perfekt für die Verfolgung des Status über Iterationen hinweg
+- **Beschreibend benennen**: Verwenden Sie klare Namen wie `currentIndex`, `totalProcessed` oder `lastError`

apps/docs/content/docs/de/blocks/wait.mdx

@@ -0,0 +1,67 @@
+---
+title: Warten
+---
+
+import { Callout } from 'fumadocs-ui/components/callout'
+import { Step, Steps } from 'fumadocs-ui/components/steps'
+import { Image } from '@/components/ui/image'
+
+Der Warten-Block pausiert deinen Workflow für eine bestimmte Zeit, bevor er mit dem nächsten Block fortfährt. Verwende ihn, um Verzögerungen zwischen Aktionen einzufügen, API-Ratenbegrenzungen einzuhalten oder Operationen zeitlich zu verteilen.
+
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/wait.png"
+    alt="Warte-Block"
+    width={500}
+    height={400}
+    className="my-6"
+  />
+</div>
+
+## Konfiguration
+
+### Wartezeit
+
+Geben Sie die Dauer für die Ausführungspause ein:
+- **Eingabe**: Positive Zahl
+- **Maximum**: 600 Sekunden (10 Minuten) oder 10 Minuten
+
+### Einheit
+
+Wählen Sie die Zeiteinheit:
+- **Sekunden**: Für kurze, präzise Verzögerungen
+- **Minuten**: Für längere Pausen
+
+<Callout type="info">
+  Warteblöcke können durch Stoppen des Workflows abgebrochen werden. Die maximale Wartezeit beträgt 10 Minuten.
+</Callout>
+
+## Ausgaben
+
+- **`<wait.waitDuration>`**: Die Wartezeit in Millisekunden
+- **`<wait.status>`**: Status der Wartezeit ('waiting', 'completed' oder 'cancelled')
+
+## Beispielanwendungsfälle
+
+**API-Ratenbegrenzung** - Bleiben Sie zwischen Anfragen innerhalb der API-Ratenlimits
+
+```
+API (Request 1) → Wait (2s) → API (Request 2)
+```
+
+**Zeitgesteuerte Benachrichtigungen** - Senden Sie Folgenachrichten nach einer Verzögerung
+
+```
+Function (Send Email) → Wait (5min) → Function (Follow-up)
+```
+
+**Verarbeitungsverzögerungen** - Warten Sie, bis das externe System die Verarbeitung abgeschlossen hat
+
+```
+API (Trigger Job) → Wait (30s) → API (Check Status)
+```
+
+## Bewährte Praktiken
+
+- **Halten Sie Wartezeiten angemessen**: Verwenden Sie Wait für Verzögerungen bis zu 10 Minuten. Für längere Verzögerungen sollten Sie geplante Workflows in Betracht ziehen
+- **Überwachen Sie die Ausführungszeit**: Denken Sie daran, dass Wartezeiten die Gesamtdauer des Workflows verlängern

apps/docs/content/docs/de/blocks/workflow.mdx

@@ -12,8 +12,8 @@ import { Image } from '@/components/ui/image'
   <Image
     src='/static/blocks/workflow.png'
     alt='Workflow-Block-Konfiguration'
-    width={400}
-    height={280}
+    width={500}
+    height={400}
     className='rounded-xl border border-border shadow-sm'
   />
 </div>
@@ -24,15 +24,38 @@ Füge einen Workflow-Block hinzu, wenn du einen untergeordneten Workflow als Tei
 
 1. **Wähle einen Workflow** aus dem Dropdown-Menü (Selbstreferenzen sind blockiert, um Schleifen zu verhindern).
 2. **Eingaben zuordnen**: Wenn der untergeordnete Workflow einen Eingabeformular-Trigger hat, siehst du jedes Feld und kannst übergeordnete Variablen verbinden. Die zugeordneten Werte sind das, was der untergeordnete Workflow erhält.
-3. **Ausgaben**: Nach Abschluss des untergeordneten Workflows stellt der Block folgendes bereit:
+
+<div className='flex justify-center my-6'>
+  <Image
+    src='/static/blocks/workflow-2.png'
+    alt='Workflow-Block mit Beispiel für Eingabezuordnung'
+    width={700}
+    height={400}
+    className='rounded-xl border border-border shadow-sm'
+  />
+</div>
+
+3. **Ausgaben**: Nachdem der untergeordnete Workflow abgeschlossen ist, stellt der Block folgendes bereit:
    - `result` – die endgültige Antwort des untergeordneten Workflows
    - `success` – ob er ohne Fehler ausgeführt wurde
    - `error` – Nachricht, wenn die Ausführung fehlschlägt
 
-## Ausführungshinweise
+## Bereitstellungsstatus-Badge
+
+Der Workflow-Block zeigt ein Bereitstellungsstatus-Badge an, das dir hilft zu verfolgen, ob der untergeordnete Workflow ausführungsbereit ist:
+
+- **Bereitgestellt** – Der untergeordnete Workflow wurde bereitgestellt und ist einsatzbereit. Der Block führt die aktuell bereitgestellte Version aus.
+- **Nicht bereitgestellt** – Der untergeordnete Workflow wurde noch nie bereitgestellt. Du musst ihn bereitstellen, bevor der Workflow-Block ihn ausführen kann.
+- **Erneut bereitstellen** – Seit der letzten Bereitstellung wurden Änderungen im untergeordneten Workflow erkannt. Klicke auf das Badge, um den untergeordneten Workflow mit den neuesten Änderungen erneut bereitzustellen.
+
+<Callout type="warn">
+Der Workflow-Block führt immer die zuletzt bereitgestellte Version des untergeordneten Workflows aus, nicht die Editor-Version. Stelle sicher, dass du nach Änderungen eine erneute Bereitstellung durchführst, damit der Block die neueste Logik verwendet.
+</Callout>
+
+## Hinweise zur Ausführung
 
 - Untergeordnete Workflows laufen im gleichen Workspace-Kontext, sodass Umgebungsvariablen und Tools übernommen werden.
-- Der Block verwendet Deployment-Versionierung: Jede API-, Zeitplan-, Webhook-, manuelle oder Chat-Ausführung ruft den bereitgestellten Snapshot auf. Stelle den untergeordneten Workflow neu bereit, wenn du ihn änderst.
+- Der Block verwendet Bereitstellungsversionierung: Jede API-, Zeitplan-, Webhook-, manuelle oder Chat-Ausführung ruft den bereitgestellten Snapshot auf. Stelle den untergeordneten Workflow nach Änderungen erneut bereit.
 - Wenn der untergeordnete Workflow fehlschlägt, löst der Block einen Fehler aus, es sei denn, du behandelst ihn nachgelagert.
 
 <Callout>

apps/docs/content/docs/de/connections/basics.mdx

@@ -1,9 +1,10 @@
 ---
-title: Verbindungsgrundlagen
+title: Grundlagen
 ---
 
 import { Callout } from 'fumadocs-ui/components/callout'
 import { Step, Steps } from 'fumadocs-ui/components/steps'
+import { Video } from '@/components/ui/video'
 
 ## Wie Verbindungen funktionieren
 
@@ -28,7 +29,11 @@ Verbindungen sind die Pfade, die den Datenfluss zwischen Blöcken in Ihrem Workf
   </Step>
 </Steps>
 
-### Verbindungsfluss
+<div className="mx-auto w-full overflow-hidden rounded-lg my-6">
+  <Video src="connections-build.mp4" width={700} height={450} />
+</div>
+
+### Verbindungsablauf
 
 Der Datenfluss durch Verbindungen folgt diesen Prinzipien:
 

apps/docs/content/docs/de/connections/data-structure.mdx

@@ -1,5 +1,5 @@
 ---
-title: Verbindungsdatenstruktur
+title: Datenstruktur
 ---
 
 import { Callout } from 'fumadocs-ui/components/callout'
@@ -111,26 +111,24 @@ Verschiedene Blocktypen erzeugen unterschiedliche Ausgabestrukturen. Hier ist, w
 
     ```json
     {
-      "content": "Original content passed through",
       "conditionResult": true,
       "selectedPath": {
         "blockId": "2acd9007-27e8-4510-a487-73d3b825e7c1",
         "blockType": "agent",
         "blockTitle": "Follow-up Agent"
       },
-      "selectedConditionId": "condition-1"
+      "selectedOption": "condition-1"
     }
     ```
 
     ### Ausgabefelder des Condition-Blocks
 
-    - **content**: Der ursprüngliche, durchgeleitete Inhalt
     - **conditionResult**: Boolesches Ergebnis der Bedingungsauswertung
     - **selectedPath**: Informationen über den ausgewählten Pfad
       - **blockId**: ID des nächsten Blocks im ausgewählten Pfad
       - **blockType**: Typ des nächsten Blocks
       - **blockTitle**: Titel des nächsten Blocks
-    - **selectedConditionId**: ID der ausgewählten Bedingung
+    - **selectedOption**: ID der ausgewählten Bedingung
 
   </Tab>
   <Tab>

apps/docs/content/docs/de/connections/index.mdx

@@ -1,5 +1,5 @@
 ---
-title: Verbindungen
+title: Übersicht
 description: Verbinde deine Blöcke miteinander.
 ---
 

apps/docs/content/docs/de/connections/tags.mdx

@@ -1,5 +1,5 @@
 ---
-title: Verbindungs-Tags
+title: Tags
 ---
 
 import { Callout } from 'fumadocs-ui/components/callout'

apps/docs/content/docs/de/copilot/index.mdx

@@ -71,6 +71,16 @@ Diese kontextbezogenen Informationen helfen Copilot, genauere und relevantere Un
   </Card>
 </Cards>
 
+<div className="flex justify-center">
+  <Image
+    src="/static/copilot/copilot-mode.png"
+    alt="Copilot-Modusauswahl-Oberfläche"
+    width={600}
+    height={400}
+    className="my-6"
+  />
+</div>
+
 ## Tiefenebenen
 
 <Cards>
@@ -82,7 +92,7 @@ Diese kontextbezogenen Informationen helfen Copilot, genauere und relevantere Un
       </span>
     }
   >
-    <div className="m-0 text-sm">Am schnellsten und günstigsten. Ideal für kleine Änderungen, einfache Workflows und geringfügige Anpassungen.</div>
+    <div className="m-0 text-sm">Am schnellsten und günstigsten. Ideal für kleine Änderungen, einfache Arbeitsabläufe und geringfügige Anpassungen.</div>
   </Card>
   <Card
     title={
@@ -102,7 +112,7 @@ Diese kontextbezogenen Informationen helfen Copilot, genauere und relevantere Un
       </span>
     }
   >
-    <div className="m-0 text-sm">Mehr Denkleistung für umfangreichere Workflows und komplexe Änderungen bei gleichzeitiger Leistungsfähigkeit.</div>
+    <div className="m-0 text-sm">Mehr Denkleistung für umfangreichere Arbeitsabläufe und komplexe Änderungen bei gleichzeitiger Leistungsfähigkeit.</div>
   </Card>
   <Card
     title={
@@ -118,7 +128,7 @@ Diese kontextbezogenen Informationen helfen Copilot, genauere und relevantere Un
 
 ### Modusauswahl-Oberfläche
 
-Du kannst einfach zwischen verschiedenen Denkmodi über den Modusauswähler in der Copilot-Oberfläche wechseln:
+Du kannst einfach zwischen verschiedenen Denkmodi über die Modusauswahl in der Copilot-Oberfläche wechseln:
 
 <Image
   src="/static/copilot/copilot-models.png"
@@ -140,8 +150,8 @@ Wähle deinen Modus basierend auf der Komplexität deiner Aufgabe - verwende Sch
 
 Die Copilot-Nutzung wird pro Token vom zugrundeliegenden LLM abgerechnet:
 
-- **Eingabe-Tokens**: werden zum Basistarif des Anbieters berechnet (**zum Selbstkostenpreis**)
-- **Ausgabe-Tokens**: werden mit dem **1,5-fachen** des Basisausgabepreises des Anbieters berechnet
+- **Eingabe-Tokens**: werden zum Basispreis des Anbieters berechnet (**zum Selbstkostenpreis**)
+- **Ausgabe-Tokens**: werden mit dem **1,5-fachen** des Basis-Ausgabepreises des Anbieters berechnet
 
 ```javascript
 copilotCost = (inputTokens × inputPrice + outputTokens × (outputPrice × 1.5)) / 1,000,000
@@ -149,13 +159,13 @@ copilotCost = (inputTokens × inputPrice + outputTokens × (outputPrice × 1.5))
 
 | Komponente | Angewendeter Tarif    |
 |------------|------------------------|
-| Input      | inputPrice             |
-| Output     | outputPrice × 1,5      |
+| Eingabe    | inputPrice             |
+| Ausgabe    | outputPrice × 1,5      |
 
 <Callout type="warning">
-  Die angezeigten Preise spiegeln die Tarife vom 4. September 2025 wider. Überprüfen Sie die Anbieterdokumentation für aktuelle Preise.
+  Die angezeigten Preise spiegeln die Tarife vom 4. September 2025 wider. Überprüfen Sie die Anbieter-Dokumentation für aktuelle Preise.
 </Callout>
 
 <Callout type="info">
-  Modellpreise werden pro Million Token berechnet. Die Berechnung teilt durch 1.000.000, um die tatsächlichen Kosten zu ermitteln. Siehe <a href="/execution/costs">die Seite zur Kostenberechnung</a> für Hintergründe und Beispiele.
+  Modellpreise werden pro Million Tokens angegeben. Die Berechnung teilt durch 1.000.000, um die tatsächlichen Kosten zu ermitteln. Siehe <a href="/execution/costs">die Seite zur Kostenberechnung</a> für Hintergründe und Beispiele.
 </Callout>

apps/docs/content/docs/de/execution/api.mdx

@@ -2,10 +2,8 @@
 title: Externe API
 ---
 
-import { Accordion, Accordions } from 'fumadocs-ui/components/accordion'
 import { Callout } from 'fumadocs-ui/components/callout'
 import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
-import { CodeBlock } from 'fumadocs-ui/components/codeblock'
 import { Video } from '@/components/ui/video'
 
 Sim bietet eine umfassende externe API zum Abfragen von Workflow-Ausführungsprotokollen und zum Einrichten von Webhooks für Echtzeit-Benachrichtigungen, wenn Workflows abgeschlossen werden.
@@ -29,14 +27,16 @@ Alle API-Antworten enthalten Informationen über Ihre Workflow-Ausführungslimit
 "limits": {
   "workflowExecutionRateLimit": {
     "sync": {
-      "limit": 60,        // Max sync workflow executions per minute
-      "remaining": 58,    // Remaining sync workflow executions
-      "resetAt": "..."    // When the window resets
+      "requestsPerMinute": 60,  // Sustained rate limit per minute
+      "maxBurst": 120,          // Maximum burst capacity
+      "remaining": 118,         // Current tokens available (up to maxBurst)
+      "resetAt": "..."          // When tokens next refill
     },
     "async": {
-      "limit": 60,        // Max async workflow executions per minute
-      "remaining": 59,    // Remaining async workflow executions
-      "resetAt": "..."    // When the window resets
+      "requestsPerMinute": 200, // Sustained rate limit per minute
+      "maxBurst": 400,          // Maximum burst capacity
+      "remaining": 398,         // Current tokens available
+      "resetAt": "..."          // When tokens next refill
     }
   },
   "usage": {
@@ -48,7 +48,7 @@ Alle API-Antworten enthalten Informationen über Ihre Workflow-Ausführungslimit
 }
 ```
 
-**Hinweis:** Die Ratenbegrenzungen in der Antwort beziehen sich auf Workflow-Ausführungen. Die Ratenbegrenzungen für den Aufruf dieses API-Endpunkts befinden sich in den Antwort-Headern (`X-RateLimit-*`).
+**Hinweis:** Ratenbegrenzungen verwenden einen Token-Bucket-Algorithmus. `remaining` kann `requestsPerMinute` bis zu `maxBurst` überschreiten, wenn du dein volles Kontingent in letzter Zeit nicht genutzt hast, was Burst-Traffic ermöglicht. Die Ratenbegrenzungen im Antworttext gelten für Workflow-Ausführungen. Die Ratenbegrenzungen für den Aufruf dieses API-Endpunkts befinden sich in den Antwort-Headern (`X-RateLimit-*`).
 
 ### Logs abfragen
 
@@ -112,13 +112,15 @@ Fragen Sie Workflow-Ausführungsprotokolle mit umfangreichen Filteroptionen ab.
       "limits": {
         "workflowExecutionRateLimit": {
           "sync": {
-            "limit": 60,
-            "remaining": 58,
+            "requestsPerMinute": 60,
+            "maxBurst": 120,
+            "remaining": 118,
             "resetAt": "2025-01-01T12:35:56.789Z"
           },
           "async": {
-            "limit": 60,
-            "remaining": 59,
+            "requestsPerMinute": 200,
+            "maxBurst": 400,
+            "remaining": 398,
             "resetAt": "2025-01-01T12:35:56.789Z"
           }
         },
@@ -192,13 +194,15 @@ Rufen Sie detaillierte Informationen zu einem bestimmten Logeintrag ab.
         "limits": {
           "workflowExecutionRateLimit": {
             "sync": {
-              "limit": 60,
-              "remaining": 58,
+              "requestsPerMinute": 60,
+              "maxBurst": 120,
+              "remaining": 118,
               "resetAt": "2025-01-01T12:35:56.789Z"
             },
             "async": {
-              "limit": 60,
-              "remaining": 59,
+              "requestsPerMinute": 200,
+              "maxBurst": 400,
+              "remaining": 398,
               "resetAt": "2025-01-01T12:35:56.789Z"
             }
           },
@@ -253,32 +257,78 @@ Rufen Sie Ausführungsdetails einschließlich des Workflow-Zustandsschnappschuss
   </Tab>
 </Tabs>
 
-## Webhook-Abonnements
+## Benachrichtigungen
 
-Erhalten Sie Echtzeitbenachrichtigungen, wenn Workflow-Ausführungen abgeschlossen werden. Webhooks werden über die Sim-Benutzeroberfläche im Workflow-Editor konfiguriert.
+Erhalten Sie Echtzeit-Benachrichtigungen, wenn Workflow-Ausführungen abgeschlossen sind, per Webhook, E-Mail oder Slack. Benachrichtigungen werden auf Workspace-Ebene von der Protokollseite aus konfiguriert.
 
 ### Konfiguration
 
-Webhooks können für jeden Workflow über die Benutzeroberfläche des Workflow-Editors konfiguriert werden. Klicken Sie auf das Webhook-Symbol in der Kontrollleiste, um Ihre Webhook-Abonnements einzurichten.
+Konfigurieren Sie Benachrichtigungen von der Protokollseite aus, indem Sie auf die Menütaste klicken und "Benachrichtigungen konfigurieren" auswählen.
 
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="configure-webhook.mp4" width={700} height={450} />
-</div>
+**Benachrichtigungskanäle:**
+- **Webhook**: Senden Sie HTTP POST-Anfragen an Ihren Endpunkt
+- **E-Mail**: Erhalten Sie E-Mail-Benachrichtigungen mit Ausführungsdetails
+- **Slack**: Posten Sie Nachrichten in einen Slack-Kanal
 
-**Verfügbare Konfigurationsoptionen:**
+**Workflow-Auswahl:**
+- Wählen Sie bestimmte Workflows zur Überwachung aus
+- Oder wählen Sie "Alle Workflows", um aktuelle und zukünftige Workflows einzubeziehen
+
+**Filteroptionen:**
+- `levelFilter`: Zu empfangende Protokollebenen (`info`, `error`)
+- `triggerFilter`: Zu empfangende Auslösertypen (`api`, `webhook`, `schedule`, `manual`, `chat`)
+
+**Optionale Daten:**
+- `includeFinalOutput`: Schließt die endgültige Ausgabe des Workflows ein
+- `includeTraceSpans`: Schließt detaillierte Ausführungs-Trace-Spans ein
+- `includeRateLimits`: Schließt Informationen zum Ratenlimit ein (Sync/Async-Limits und verbleibende)
+- `includeUsageData`: Schließt Abrechnungszeitraum-Nutzung und -Limits ein
+
+### Alarmregeln
+
+Anstatt Benachrichtigungen für jede Ausführung zu erhalten, konfigurieren Sie Alarmregeln, um nur bei erkannten Problemen benachrichtigt zu werden:
+
+**Aufeinanderfolgende Fehler**
+- Alarm nach X aufeinanderfolgenden fehlgeschlagenen Ausführungen (z.B. 3 Fehler in Folge)
+- Wird zurückgesetzt, wenn eine Ausführung erfolgreich ist
+
+**Fehlerrate**
+- Alarm, wenn die Fehlerrate X% in den letzten Y Stunden überschreitet
+- Erfordert mindestens 5 Ausführungen im Zeitfenster
+- Wird erst nach Ablauf des vollständigen Zeitfensters ausgelöst
+
+**Latenz-Schwellenwert**
+- Alarm, wenn eine Ausführung länger als X Sekunden dauert
+- Nützlich zum Erkennen langsamer oder hängender Workflows
+
+**Latenz-Spitze**
+- Alarm, wenn die Ausführung X% langsamer als der Durchschnitt ist
+- Vergleicht mit der durchschnittlichen Dauer über das konfigurierte Zeitfenster
+- Erfordert mindestens 5 Ausführungen, um eine Baseline zu etablieren
+
+**Kostenschwelle**
+- Alarmierung, wenn eine einzelne Ausführung mehr als $X kostet
+- Nützlich, um teure LLM-Aufrufe zu erkennen
+
+**Keine Aktivität**
+- Alarmierung, wenn innerhalb von X Stunden keine Ausführungen stattfinden
+- Nützlich zur Überwachung geplanter Workflows, die regelmäßig ausgeführt werden sollten
+
+**Fehlerzählung**
+- Alarmierung, wenn die Fehleranzahl X innerhalb eines Zeitfensters überschreitet
+- Erfasst die Gesamtfehler, nicht aufeinanderfolgende
+
+Alle Alarmtypen beinhalten eine Abklingzeit von 1 Stunde, um Benachrichtigungsspam zu vermeiden.
+
+### Webhook-Konfiguration
+
+Für Webhooks stehen zusätzliche Optionen zur Verfügung:
 - `url`: Ihre Webhook-Endpunkt-URL
-- `secret`: Optionales Geheimnis für die HMAC-Signaturverifizierung
-- `includeFinalOutput`: Die endgültige Ausgabe des Workflows in die Nutzlast einschließen
-- `includeTraceSpans`: Detaillierte Ausführungs-Trace-Spans einschließen
-- `includeRateLimits`: Informationen zum Ratelimit des Workflow-Besitzers einschließen
-- `includeUsageData`: Nutzungs- und Abrechnungsdaten des Workflow-Besitzers einschließen
-- `levelFilter`: Array von Log-Ebenen, die empfangen werden sollen (`info`, `error`)
-- `triggerFilter`: Array von Auslösertypen, die empfangen werden sollen (`api`, `webhook`, `schedule`, `manual`, `chat`)
-- `active`: Webhook-Abonnement aktivieren/deaktivieren
+- `secret`: Optionales Geheimnis für HMAC-Signaturverifizierung
 
-### Webhook-Nutzlast
+### Payload-Struktur
 
-Wenn eine Workflow-Ausführung abgeschlossen ist, sendet Sim eine POST-Anfrage an Ihre Webhook-URL:
+Wenn eine Workflow-Ausführung abgeschlossen ist, sendet Sim die folgende Payload (über Webhook POST, E-Mail oder Slack):
 
 ```json
 {
@@ -329,17 +379,17 @@ Wenn eine Workflow-Ausführung abgeschlossen ist, sendet Sim eine POST-Anfrage a
 
 ### Webhook-Header
 
-Jede Webhook-Anfrage enthält diese Header:
+Jede Webhook-Anfrage enthält diese Header (nur Webhook-Kanal):
 
 - `sim-event`: Ereignistyp (immer `workflow.execution.completed`)
 - `sim-timestamp`: Unix-Zeitstempel in Millisekunden
-- `sim-delivery-id`: Eindeutige Lieferungs-ID für Idempotenz
-- `sim-signature`: HMAC-SHA256-Signatur zur Verifizierung (falls Secret konfiguriert)
-- `Idempotency-Key`: Identisch mit der Lieferungs-ID zur Erkennung von Duplikaten
+- `sim-delivery-id`: Eindeutige Zustell-ID für Idempotenz
+- `sim-signature`: HMAC-SHA256-Signatur zur Verifizierung (falls Geheimnis konfiguriert)
+- `Idempotency-Key`: Gleich wie Zustell-ID zur Erkennung von Duplikaten
 
 ### Signaturverifizierung
 
-Wenn Sie ein Webhook-Secret konfigurieren, überprüfen Sie die Signatur, um sicherzustellen, dass der Webhook von Sim stammt:
+Wenn Sie ein Webhook-Geheimnis konfigurieren, überprüfen Sie die Signatur, um sicherzustellen, dass der Webhook von Sim stammt:
 
 <Tabs items={['Node.js', 'Python']}>
   <Tab value="Node.js">
@@ -416,7 +466,7 @@ Fehlgeschlagene Webhook-Zustellungen werden mit exponentiellem Backoff und Jitte
 
 - Maximale Versuche: 5
 - Wiederholungsverzögerungen: 5 Sekunden, 15 Sekunden, 1 Minute, 3 Minuten, 10 Minuten
-- Jitter: Bis zu 10% zusätzliche Verzögerung, um Überlastungen zu vermeiden
+- Jitter: Bis zu 10% zusätzliche Verzögerung, um Überlastung zu vermeiden
 - Nur HTTP 5xx und 429 Antworten lösen Wiederholungen aus
 - Zustellungen haben ein Timeout nach 30 Sekunden
 
@@ -426,31 +476,39 @@ Fehlgeschlagene Webhook-Zustellungen werden mit exponentiellem Backoff und Jitte
 
 ## Best Practices
 
-1. **Polling-Strategie**: Verwenden Sie beim Abfragen von Logs die cursorbasierte Paginierung mit `order=asc` und `startDate`, um neue Logs effizient abzurufen.
+1. **Polling-Strategie**: Verwende bei der Abfrage von Logs eine cursor-basierte Paginierung mit `order=asc` und `startDate`, um neue Logs effizient abzurufen.
 
-2. **Webhook-Sicherheit**: Konfigurieren Sie immer ein Webhook-Secret und überprüfen Sie Signaturen, um sicherzustellen, dass Anfragen von Sim stammen.
+2. **Webhook-Sicherheit**: Konfiguriere immer ein Webhook-Secret und überprüfe Signaturen, um sicherzustellen, dass Anfragen von Sim stammen.
 
-3. **Idempotenz**: Verwenden Sie den `Idempotency-Key`Header, um doppelte Webhook-Zustellungen zu erkennen und zu behandeln.
+3. **Idempotenz**: Verwende den `Idempotency-Key`Header, um doppelte Webhook-Zustellungen zu erkennen und zu behandeln.
 
-4. **Datenschutz**: Standardmäßig werden `finalOutput` und `traceSpans` von den Antworten ausgeschlossen. Aktivieren Sie diese nur, wenn Sie die Daten benötigen und die Datenschutzauswirkungen verstehen.
+4. **Datenschutz**: Standardmäßig werden `finalOutput` und `traceSpans` aus den Antworten ausgeschlossen. Aktiviere diese nur, wenn du die Daten benötigst und die Datenschutzauswirkungen verstehst.
 
-5. **Rate-Limiting**: Implementieren Sie exponentielles Backoff, wenn Sie 429-Antworten erhalten. Überprüfen Sie den `Retry-After`Header für die empfohlene Wartezeit.
+5. **Rate-Limiting**: Implementiere exponentielles Backoff, wenn du 429-Antworten erhältst. Überprüfe den `Retry-After`Header für die empfohlene Wartezeit.
 
 ## Rate-Limiting
 
-Die API implementiert Rate-Limiting, um eine faire Nutzung zu gewährleisten:
+Die API verwendet einen **Token-Bucket-Algorithmus** für die Ratenbegrenzung, der eine faire Nutzung ermöglicht und gleichzeitig Burst-Traffic zulässt:
 
-- **Kostenloser Plan**: 10 Anfragen pro Minute
-- **Pro-Plan**: 30 Anfragen pro Minute
-- **Team-Plan**: 60 Anfragen pro Minute
-- **Enterprise-Plan**: Individuelle Limits
+| Plan | Anfragen/Minute | Burst-Kapazität |
+|------|-----------------|----------------|
+| Free | 10 | 20 |
+| Pro | 30 | 60 |
+| Team | 60 | 120 |
+| Enterprise | 120 | 240 |
 
-Informationen zum Rate-Limit sind in den Antwort-Headern enthalten:
-- `X-RateLimit-Limit`: Maximale Anfragen pro Zeitfenster
-- `X-RateLimit-Remaining`: Verbleibende Anfragen im aktuellen Zeitfenster
-- `X-RateLimit-Reset`: ISO-Zeitstempel, wann das Zeitfenster zurückgesetzt wird
+**Wie es funktioniert:**
+- Tokens werden mit der Rate `requestsPerMinute` aufgefüllt
+- Du kannst im Leerlauf bis zu `maxBurst` Tokens ansammeln
+- Jede Anfrage verbraucht 1 Token
+- Die Burst-Kapazität ermöglicht die Bewältigung von Verkehrsspitzen
 
-## Beispiel: Abfragen neuer Logs
+Informationen zur Ratenbegrenzung sind in den Antwort-Headern enthalten:
+- `X-RateLimit-Limit`: Anfragen pro Minute (Auffüllrate)
+- `X-RateLimit-Remaining`: Aktuell verfügbare Tokens
+- `X-RateLimit-Reset`: ISO-Zeitstempel, wann Tokens als nächstes aufgefüllt werden
+
+## Beispiel: Abfragen nach neuen Logs
 
 ```javascript
 let cursor = null;
@@ -535,7 +593,7 @@ app.post('/sim-webhook', (req, res) => {
         // Handle error...
       } else {
         console.log(`Workflow ${workflowId} completed: ${executionId}`);
-        console.log(`Cost: ${cost.total}`);
+        console.log(`Cost: $${cost.total}`);
         // Process successful execution...
       }
       break;

apps/docs/content/docs/de/execution/basics.mdx

@@ -1,12 +1,10 @@
 ---
-title: Ausführungsgrundlagen
+title: Grundlagen
 ---
 
 import { Callout } from 'fumadocs-ui/components/callout'
 import { Card, Cards } from 'fumadocs-ui/components/card'
-import { Step, Steps } from 'fumadocs-ui/components/steps'
 import { Image } from '@/components/ui/image'
-import { Video } from '@/components/ui/video'
 
 Das Verständnis der Workflow-Ausführung in Sim ist entscheidend für die Erstellung effizienter und zuverlässiger Automatisierungen. Die Ausführungs-Engine verwaltet automatisch Abhängigkeiten, Parallelität und Datenfluss, um sicherzustellen, dass Ihre Workflows reibungslos und vorhersehbar ablaufen.
 
@@ -77,29 +75,6 @@ Sim bietet verschiedene Arten von Blöcken, die spezifische Zwecke in Ihren Work
 
 Alle Blöcke werden automatisch basierend auf ihren Abhängigkeiten ausgeführt - Sie müssen die Ausführungsreihenfolge oder das Timing nicht manuell verwalten.
 
-## Ausführungsauslöser
-
-Workflows können auf verschiedene Weise ausgelöst werden, abhängig von Ihrem Anwendungsfall:
-
-### Manuelles Testen
-Klicken Sie im Workflow-Editor auf "Ausführen", um Ihren Workflow während der Entwicklung zu testen. Perfekt für Debugging und Validierung.
-
-### Geplante Ausführung  
-Richten Sie wiederkehrende Ausführungen mit Cron-Ausdrücken ein. Ideal für regelmäßige Datenverarbeitung, Berichte oder Wartungsaufgaben.
-
-### API-Bereitstellung
-Stellen Sie Workflows als HTTP-Endpunkte bereit, die programmatisch von Ihren Anwendungen aufgerufen werden können.
-
-### Webhook-Integration
-Reagieren Sie in Echtzeit auf Ereignisse von externen Diensten wie GitHub, Stripe oder benutzerdefinierten Systemen.
-
-### Chat-Schnittstelle
-Erstellen Sie Konversationsschnittstellen, die auf benutzerdefinierten Subdomains für benutzerorientierte KI-Anwendungen gehostet werden.
-
-<Callout type="info">
-  Erfahren Sie mehr über jeden Auslösertyp im [Abschnitt Auslöser](/triggers) der Dokumentation.
-</Callout>
-
 ## Ausführungsüberwachung
 
 Wenn Workflows ausgeführt werden, bietet Sim Echtzeit-Einblick in den Ausführungsprozess:
@@ -118,7 +93,7 @@ Wenn Workflows ausgeführt werden, bietet Sim Echtzeit-Einblick in den Ausführu
 Das Verständnis dieser Grundprinzipien wird Ihnen helfen, bessere Workflows zu erstellen:
 
 1. **Abhängigkeitsbasierte Ausführung**: Blöcke werden nur ausgeführt, wenn alle ihre Abhängigkeiten abgeschlossen sind
-2. **Automatische Parallelisierung**: Unabhängige Blöcke laufen gleichzeitig ohne Konfiguration
+2. **Automatische Parallelisierung**: Unabhängige Blöcke laufen ohne Konfiguration gleichzeitig
 3. **Intelligenter Datenfluss**: Ausgaben fließen automatisch zu verbundenen Blöcken
 4. **Fehlerbehandlung**: Fehlgeschlagene Blöcke stoppen ihren Ausführungspfad, beeinflussen aber keine unabhängigen Pfade
 5. **Zustandspersistenz**: Alle Blockausgaben und Ausführungsdetails werden für die Fehlerbehebung gespeichert
@@ -129,4 +104,4 @@ Nachdem Sie die Grundlagen der Ausführung verstanden haben, erkunden Sie:
 - **[Blocktypen](/blocks)** - Erfahren Sie mehr über spezifische Block-Funktionen
 - **[Protokollierung](/execution/logging)** - Überwachen Sie Workflow-Ausführungen und beheben Sie Probleme
 - **[Kostenberechnung](/execution/costs)** - Verstehen und optimieren Sie Workflow-Kosten
-- **[Auslöser](/triggers)** - Richten Sie verschiedene Möglichkeiten ein, Ihre Workflows auszuführen
+- **[Trigger](/triggers)** - Richten Sie verschiedene Möglichkeiten ein, Ihre Workflows auszuführen

apps/docs/content/docs/de/execution/costs.mdx

@@ -2,7 +2,6 @@
 title: Kostenberechnung
 ---
 
-import { Accordion, Accordions } from 'fumadocs-ui/components/accordion'
 import { Callout } from 'fumadocs-ui/components/callout'
 import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
 import { Image } from '@/components/ui/image'
@@ -48,71 +47,77 @@ Die Modellaufschlüsselung zeigt:
 
 ## Preisoptionen
 
-<Tabs items={['Gehostete Modelle', 'Eigener API-Schlüssel']}>
+<Tabs items={['Hosted Models', 'Bring Your Own API Key']}>
   <Tab>
     **Gehostete Modelle** - Sim stellt API-Schlüssel mit einem 2,5-fachen Preismultiplikator bereit:
-    
+
+    **OpenAI**
     | Modell | Basispreis (Eingabe/Ausgabe) | Gehosteter Preis (Eingabe/Ausgabe) |
     |-------|---------------------------|----------------------------|
-    | GPT-4o | 2,50 $ / 10,00 $ | 6,25 $ / 25,00 $ |
-    | GPT-4.1 | 2,00 $ / 8,00 $ | 5,00 $ / 20,00 $ |
-    | o1 | 15,00 $ / 60,00 $ | 37,50 $ / 150,00 $ |
-    | o3 | 2,00 $ / 8,00 $ | 5,00 $ / 20,00 $ |
-    | Claude 3.5 Sonnet | 3,00 $ / 15,00 $ | 7,50 $ / 37,50 $ |
-    | Claude Opus 4.0 | 15,00 $ / 75,00 $ | 37,50 $ / 187,50 $ |
-    
+    | GPT-5.1 | $1,25 / $10,00 | $3,13 / $25,00 |
+    | GPT-5 | $1,25 / $10,00 | $3,13 / $25,00 |
+    | GPT-5 Mini | $0,25 / $2,00 | $0,63 / $5,00 |
+    | GPT-5 Nano | $0,05 / $0,40 | $0,13 / $1,00 |
+    | GPT-4o | $2,50 / $10,00 | $6,25 / $25,00 |
+    | GPT-4.1 | $2,00 / $8,00 | $5,00 / $20,00 |
+    | GPT-4.1 Mini | $0,40 / $1,60 | $1,00 / $4,00 |
+    | GPT-4.1 Nano | $0,10 / $0,40 | $0,25 / $1,00 |
+    | o1 | $15,00 / $60,00 | $37,50 / $150,00 |
+    | o3 | $2,00 / $8,00 | $5,00 / $20,00 |
+    | o4 Mini | $1,10 / $4,40 | $2,75 / $11,00 |
+
+    **Anthropic**
+    | Modell | Basispreis (Eingabe/Ausgabe) | Gehosteter Preis (Eingabe/Ausgabe) |
+    |-------|---------------------------|----------------------------|
+    | Claude Opus 4.5 | $5,00 / $25,00 | $12,50 / $62,50 |
+    | Claude Opus 4.1 | $15,00 / $75,00 | $37,50 / $187,50 |
+    | Claude Sonnet 4.5 | $3,00 / $15,00 | $7,50 / $37,50 |
+    | Claude Sonnet 4.0 | $3,00 / $15,00 | $7,50 / $37,50 |
+    | Claude Haiku 4.5 | $1,00 / $5,00 | $2,50 / $12,50 |
+
+    **Google**
+    | Modell | Basispreis (Eingabe/Ausgabe) | Gehosteter Preis (Eingabe/Ausgabe) |
+    |-------|---------------------------|----------------------------|
+    | Gemini 3 Pro Preview | $2,00 / $12,00 | $5,00 / $30,00 |
+    | Gemini 2.5 Pro | $0,15 / $0,60 | $0,38 / $1,50 |
+    | Gemini 2.5 Flash | $0,15 / $0,60 | $0,38 / $1,50 |
+
     *Der 2,5-fache Multiplikator deckt Infrastruktur- und API-Verwaltungskosten ab.*
   </Tab>
-  
+
   <Tab>
-    **Ihre eigenen API-Schlüssel** - Nutzen Sie jedes Modell zum Basispreis:
-    
-    | Anbieter | Modelle | Eingabe / Ausgabe |
-    |----------|---------|----------------|
-    | Google | Gemini 2.5 | 0,15 $ / 0,60 $ |
-    | Deepseek | V3, R1 | 0,75 $ / 1,00 $ |
-    | xAI | Grok 4, Grok 3 | 5,00 $ / 25,00 $ |
-    | Groq | Llama 4 Scout | 0,40 $ / 0,60 $ |
-    | Cerebras | Llama 3.3 70B | 0,94 $ / 0,94 $ |
+    **Eigene API-Schlüssel** - Nutzen Sie jedes Modell zum Basispreis:
+
+    | Anbieter | Beispielmodelle | Input / Output |
+    |----------|----------------|----------------|
+    | Deepseek | V3, R1 | $0,75 / $1,00 |
+    | xAI | Grok 4 Latest, Grok 3 | $3,00 / $15,00 |
+    | Groq | Llama 4 Scout, Llama 3.3 70B | $0,11 / $0,34 |
+    | Cerebras | Llama 4 Scout, Llama 3.3 70B | $0,11 / $0,34 |
     | Ollama | Lokale Modelle | Kostenlos |
-    
+    | VLLM | Lokale Modelle | Kostenlos |
+
     *Bezahlen Sie Anbieter direkt ohne Aufschlag*
   </Tab>
 </Tabs>
 
 <Callout type="warning">
-  Die angezeigten Preise spiegeln die Tarife vom 10. September 2025 wider. Überprüfen Sie die Anbieterdokumentation für aktuelle Preise.
+  Die angezeigten Preise entsprechen den Tarifen vom 10. September 2025. Überprüfen Sie die Dokumentation der Anbieter für aktuelle Preise.
 </Callout>
 
-## Kostenoptimierungsstrategien
+## Strategien zur Kostenoptimierung
 
-<Accordions>
-  <Accordion title="Modellauswahl">
-    Wählen Sie Modelle basierend auf der Komplexität der Aufgabe. Einfache Aufgaben können GPT-4.1-nano ($0,10/$0,40) verwenden, während komplexes Denken möglicherweise o1 oder Claude Opus erfordert.
-  </Accordion>
-  
-  <Accordion title="Prompt-Engineering">
-    Gut strukturierte, präzise Prompts reduzieren den Token-Verbrauch ohne Qualitätseinbußen.
-  </Accordion>
-  
-  <Accordion title="Lokale Modelle">
-    Verwenden Sie Ollama für unkritische Aufgaben, um API-Kosten vollständig zu eliminieren.
-  </Accordion>
-  
-  <Accordion title="Caching und Wiederverwendung">
-    Speichern Sie häufig verwendete Ergebnisse in Variablen oder Dateien, um wiederholte KI-Modellaufrufe zu vermeiden.
-  </Accordion>
-  
-  <Accordion title="Batch-Verarbeitung">
-    Verarbeiten Sie mehrere Elemente in einer einzigen KI-Anfrage anstatt einzelne Aufrufe zu tätigen.
-  </Accordion>
-</Accordions>
+- **Modellauswahl**: Wählen Sie Modelle basierend auf der Komplexität der Aufgabe. Einfache Aufgaben können GPT-4.1-nano verwenden, während komplexes Denken möglicherweise o1 oder Claude Opus erfordert.
+- **Prompt-Engineering**: Gut strukturierte, präzise Prompts reduzieren den Token-Verbrauch ohne Qualitätseinbußen.
+- **Lokale Modelle**: Verwenden Sie Ollama oder VLLM für unkritische Aufgaben, um API-Kosten vollständig zu eliminieren.
+- **Caching und Wiederverwendung**: Speichern Sie häufig verwendete Ergebnisse in Variablen oder Dateien, um wiederholte KI-Modellaufrufe zu vermeiden.
+- **Batch-Verarbeitung**: Verarbeiten Sie mehrere Elemente in einer einzigen KI-Anfrage anstatt einzelne Aufrufe zu tätigen.
 
 ## Nutzungsüberwachung
 
 Überwachen Sie Ihre Nutzung und Abrechnung unter Einstellungen → Abonnement:
 
-- **Aktuelle Nutzung**: Echtzeit-Nutzung und Kosten für den aktuellen Zeitraum
+- **Aktuelle Nutzung**: Echtzeit-Nutzung und -Kosten für den aktuellen Zeitraum
 - **Nutzungslimits**: Plangrenzen mit visuellen Fortschrittsanzeigen
 - **Abrechnungsdetails**: Prognostizierte Gebühren und Mindestverpflichtungen
 - **Planverwaltung**: Upgrade-Optionen und Abrechnungsverlauf
@@ -142,8 +147,20 @@ curl -X GET -H "X-API-Key: YOUR_API_KEY" -H "Content-Type: application/json" htt
 {
   "success": true,
   "rateLimit": {
-    "sync": { "isLimited": false, "limit": 10, "remaining": 10, "resetAt": "2025-09-08T22:51:55.999Z" },
-    "async": { "isLimited": false, "limit": 50, "remaining": 50, "resetAt": "2025-09-08T22:51:56.155Z" },
+    "sync": {
+      "isLimited": false,
+      "requestsPerMinute": 25,
+      "maxBurst": 50,
+      "remaining": 50,
+      "resetAt": "2025-09-08T22:51:55.999Z"
+    },
+    "async": {
+      "isLimited": false,
+      "requestsPerMinute": 200,
+      "maxBurst": 400,
+      "remaining": 400,
+      "resetAt": "2025-09-08T22:51:56.155Z"
+    },
     "authType": "api"
   },
   "usage": {
@@ -154,33 +171,70 @@ curl -X GET -H "X-API-Key: YOUR_API_KEY" -H "Content-Type: application/json" htt
 }
 ```
 
+**Rate-Limit-Felder:**
+- `requestsPerMinute`: Dauerhafte Rate-Begrenzung (Tokens werden mit dieser Rate aufgefüllt)
+- `maxBurst`: Maximale Tokens, die Sie ansammeln können (Burst-Kapazität)
+- `remaining`: Aktuell verfügbare Tokens (können bis zu `maxBurst` sein)
+
 **Antwortfelder:**
-- `currentPeriodCost` spiegelt die Nutzung im aktuellen Abrechnungszeitraum wider
-- `limit` wird aus individuellen Limits (Free/Pro) oder gepoolten Organisationslimits (Team/Enterprise) abgeleitet
+- `currentPeriodCost` spiegelt die Nutzung in der aktuellen Abrechnungsperiode wider
+- `limit` wird von individuellen Limits (Free/Pro) oder gepoolten Organisationslimits (Team/Enterprise) abgeleitet
 - `plan` ist der aktive Plan mit der höchsten Priorität, der mit Ihrem Benutzer verknüpft ist
 
-## Planlimits
+## Plan-Limits
 
 Verschiedene Abonnementpläne haben unterschiedliche Nutzungslimits:
 
-| Plan | Monatliches Nutzungslimit | Ratengrenze (pro Minute) |
+| Plan | Monatliches Nutzungslimit | Rate-Limits (pro Minute) |
 |------|-------------------|-------------------------|
 | **Free** | $10 | 5 sync, 10 async |
 | **Pro** | $100 | 10 sync, 50 async |
 | **Team** | $500 (gepoolt) | 50 sync, 100 async |
 | **Enterprise** | Individuell | Individuell |
 
+## Abrechnungsmodell
+
+Sim verwendet ein **Basisabonnement + Mehrverbrauch**-Abrechnungsmodell:
+
+### Wie es funktioniert
+
+**Pro-Plan ($20/Monat):**
+- Monatliches Abonnement beinhaltet $20 Nutzung
+- Nutzung unter $20 → Keine zusätzlichen Kosten
+- Nutzung über $20 → Zahlen Sie den Mehrverbrauch am Monatsende
+- Beispiel: $35 Nutzung = $20 (Abonnement) + $15 (Mehrverbrauch)
+
+**Team-Plan ($40/Benutzer/Monat):**
+- Gepoolte Nutzung für alle Teammitglieder
+- Mehrverbrauch wird aus der Gesamtnutzung des Teams berechnet
+- Organisationsinhaber erhält eine Rechnung
+
+**Enterprise-Pläne:**
+- Fester monatlicher Preis, kein Mehrverbrauch
+- Individuelle Nutzungslimits gemäß Vereinbarung
+
+### Schwellenwert-Abrechnung
+
+Wenn der nicht abgerechnete Mehrverbrauch $50 erreicht, berechnet Sim automatisch den gesamten nicht abgerechneten Betrag.
+
+**Beispiel:**
+- Tag 10: $70 Mehrverbrauch → Sofortige Abrechnung von $70
+- Tag 15: Zusätzliche $35 Nutzung ($105 insgesamt) → Bereits abgerechnet, keine Aktion
+- Tag 20: Weitere $50 Nutzung ($155 insgesamt, $85 nicht abgerechnet) → Sofortige Abrechnung von $85
+
+Dies verteilt große Überziehungsgebühren über den Monat, anstatt eine große Rechnung am Ende des Abrechnungszeitraums zu erhalten.
+
 ## Best Practices für Kostenmanagement
 
-1. **Regelmäßig überwachen**: Prüfen Sie Ihr Nutzungs-Dashboard häufig, um Überraschungen zu vermeiden
+1. **Regelmäßig überwachen**: Überprüfen Sie Ihr Nutzungs-Dashboard häufig, um Überraschungen zu vermeiden
 2. **Budgets festlegen**: Nutzen Sie Planlimits als Leitplanken für Ihre Ausgaben
 3. **Workflows optimieren**: Überprüfen Sie kostenintensive Ausführungen und optimieren Sie Prompts oder Modellauswahl
-4. **Passende Modelle verwenden**: Stimmen Sie die Modellkomplexität auf die Aufgabenanforderungen ab
+4. **Passende Modelle verwenden**: Passen Sie die Modellkomplexität an die Aufgabenanforderungen an
 5. **Ähnliche Aufgaben bündeln**: Kombinieren Sie wenn möglich mehrere Anfragen, um den Overhead zu reduzieren
 
 ## Nächste Schritte
 
 - Überprüfen Sie Ihre aktuelle Nutzung unter [Einstellungen → Abonnement](https://sim.ai/settings/subscription)
-- Erfahren Sie mehr über [Logging](/execution/logging), um Ausführungsdetails zu verfolgen
+- Erfahren Sie mehr über [Protokollierung](/execution/logging), um Ausführungsdetails zu verfolgen
 - Erkunden Sie die [Externe API](/execution/api) für programmatische Kostenüberwachung
 - Sehen Sie sich [Workflow-Optimierungstechniken](/blocks) an, um Kosten zu reduzieren

apps/docs/content/docs/de/execution/index.mdx

@@ -1,5 +1,5 @@
 ---
-title: Ausführung
+title: Übersicht
 ---
 
 import { Callout } from 'fumadocs-ui/components/callout'
@@ -52,51 +52,13 @@ Jeder Workflow behält während der Ausführung einen umfangreichen Kontext bei,
 - Umgebungsvariablen
 - Routing-Entscheidungen
 
-## Ausführungsauslöser
-
-Workflows können über mehrere Kanäle ausgeführt werden:
-
-- **Manuell**: Testen und debuggen direkt im Editor
-- **Als API bereitstellen**: Einen HTTP-Endpunkt erstellen, der mit API-Schlüsseln gesichert ist
-- **Als Chat bereitstellen**: Eine Konversationsschnittstelle auf einer benutzerdefinierten Subdomain erstellen
-- **Webhooks**: Auf externe Ereignisse von Drittanbieterdiensten reagieren
-- **Geplant**: Nach einem wiederkehrenden Zeitplan mit Cron-Ausdrücken ausführen
-
-### Als API bereitstellen
-
-Wenn Sie einen Workflow als API bereitstellen, macht Sim Folgendes:
-- Erstellt einen eindeutigen HTTP-Endpunkt: `https://sim.ai/api/workflows/{workflowId}/execute`
-- Generiert einen API-Schlüssel zur Authentifizierung
-- Akzeptiert POST-Anfragen mit JSON-Payloads
-- Gibt Workflow-Ausführungsergebnisse als JSON zurück
-
-Beispiel für einen API-Aufruf:
-
-```bash
-curl -X POST https://sim.ai/api/workflows/your-workflow-id/execute \
-  -H "X-API-Key: your-api-key" \
-  -H "Content-Type: application/json" \
-  -d '{"input": "your data here"}'
-```
-
-### Als Chat bereitstellen
-
-Die Chat-Bereitstellung erstellt eine Konversationsschnittstelle für Ihren Workflow:
-- Gehostet auf einer benutzerdefinierten Subdomain: `https://your-name.sim.ai`
-- Optionale Authentifizierung (öffentlich, passwortgeschützt oder E-Mail-basiert)
-- Anpassbare Benutzeroberfläche mit Ihrem Branding
-- Streaming-Antworten für Echtzeit-Interaktion
-- Perfekt für KI-Assistenten, Support-Bots oder interaktive Tools
-
-Jede Bereitstellungsmethode übergibt Daten an den Starter-Block Ihres Workflows und beginnt so den Ausführungsfluss.
-
 ## Deployment-Snapshots
 
-Alle öffentlichen Einstiegspunkte—API, Chat, Zeitplan, Webhook und manuelle Ausführungen—führen den aktiven Deployment-Snapshot des Workflows aus. Veröffentliche ein neues Deployment, wann immer du die Arbeitsfläche änderst, damit jeder Trigger die aktualisierte Version verwendet.
+Alle öffentlichen Einstiegspunkte – API, Chat, Zeitplan, Webhook und manuelle Ausführungen – führen den aktiven Deployment-Snapshot des Workflows aus. Veröffentliche ein neues Deployment, wann immer du die Arbeitsfläche änderst, damit jeder Auslöser die aktualisierte Version verwendet.
 
 <div className='flex justify-center my-6'>
   <Image
-    src='/static/execution/deployment-versions-light.png'
+    src='/static/execution/deployment-versions.png'
     alt='Tabelle mit Deployment-Versionen'
     width={500}
     height={280}
@@ -104,11 +66,11 @@ Alle öffentlichen Einstiegspunkte—API, Chat, Zeitplan, Webhook und manuelle A
   />
 </div>
 
-Das Deploy-Modal behält eine vollständige Versionshistorie bei—inspiziere jeden Snapshot, vergleiche ihn mit deinem Entwurf und führe Upgrades oder Rollbacks mit einem Klick durch, wenn du eine frühere Version wiederherstellen musst.
+Das Deploy-Modal behält eine vollständige Versionshistorie bei – untersuche jeden Snapshot, vergleiche ihn mit deinem Entwurf und führe Upgrades oder Rollbacks mit einem Klick durch, wenn du eine frühere Version wiederherstellen musst.
 
 ## Programmatische Ausführung
 
-Führe Workflows aus deinen Anwendungen mit unseren offiziellen SDKs aus:
+Führe Workflows aus deinen Anwendungen heraus mit unseren offiziellen SDKs aus:
 
 ```bash
 # TypeScript/JavaScript
@@ -138,12 +100,12 @@ const result = await client.executeWorkflow('workflow-id', {
 - Verwende Umgebungsvariablen für sensible Daten
 - Füge Logging zu Funktionsblöcken für Debugging hinzu
 
-### Leistung optimieren
+### Optimiere Performance
 - Minimiere externe API-Aufrufe wo möglich
 - Nutze parallele Ausführung für unabhängige Operationen
-- Cache Ergebnisse mit Memory-Blöcken, wenn angemessen
+- Cache Ergebnisse mit Memory-Blöcken wenn angemessen
 
-### Ausführungen überwachen
+### Überwache Ausführungen
 - Überprüfe Logs regelmäßig, um Leistungsmuster zu verstehen
 - Verfolge Kosten für KI-Modellnutzung
 - Verwende Workflow-Snapshots zur Fehlerbehebung

apps/docs/content/docs/de/execution/logging.mdx

@@ -147,4 +147,4 @@ Der Snapshot bietet:
 
 - Erfahren Sie mehr über die [Kostenberechnung](/execution/costs), um die Preisgestaltung von Workflows zu verstehen
 - Erkunden Sie die [externe API](/execution/api) für programmatischen Zugriff auf Protokolle
-- Richten Sie [Webhook-Benachrichtigungen](/execution/api#webhook-subscriptions) für Echtzeit-Warnungen ein
+- Richten Sie [Benachrichtigungen](/execution/api#notifications) für Echtzeit-Warnungen per Webhook, E-Mail oder Slack ein

apps/docs/content/docs/de/getting-started/index.mdx

@@ -24,20 +24,19 @@ import {
 import { Video } from '@/components/ui/video'
 import { Image } from '@/components/ui/image'
 
-Dieses Tutorial führt dich durch den Aufbau deines ersten KI-Workflows in Sim. Wir erstellen einen Personen-Recherche-Agenten, der Informationen über Personen mithilfe modernster LLM-Suchwerkzeuge finden kann.
+Erstelle deinen ersten KI-Workflow in 10 Minuten. In diesem Tutorial wirst du einen Personenrecherche-Agenten erstellen, der fortschrittliche LLM-gestützte Suchwerkzeuge nutzt, um Informationen über Personen zu extrahieren und zu strukturieren.
 
 <Callout type="info">
-  Dieses Tutorial dauert etwa 10 Minuten und behandelt die wesentlichen Konzepte zum Erstellen von Workflows in Sim.
+  Dieses Tutorial behandelt die wesentlichen Konzepte zum Erstellen von Workflows in Sim. Geschätzte Bearbeitungszeit: 10 Minuten.
 </Callout>
 
-## Was wir erstellen
+## Was du erstellen wirst
 
-Einen Personen-Recherche-Agenten, der:
-1. Den Namen einer Person über eine Chat-Schnittstelle empfängt
-2. Einen KI-Agenten mit erweiterten Suchfähigkeiten nutzt
-3. Das Web mithilfe modernster LLM-Suchwerkzeuge (Exa und Linkup) durchsucht
-4. Strukturierte Informationen mithilfe eines Antwortformats extrahiert
-5. Umfassende Daten über die Person zurückgibt
+Einen Personenrecherche-Agenten, der:
+1. Benutzereingaben über eine Chat-Schnittstelle akzeptiert
+2. Das Web mit KI-gestützten Tools durchsucht (Exa und Linkup)
+3. Informationen über Personen extrahiert und strukturiert
+4. Formatierte JSON-Daten mit Standort, Beruf und Ausbildung zurückgibt
 
 <Image
   src="/static/getting-started/started-1.png"
@@ -49,74 +48,71 @@ Einen Personen-Recherche-Agenten, der:
 ## Schritt-für-Schritt-Anleitung
 
 <Steps>
-  <Step title="Workflow erstellen und KI-Agenten hinzufügen">
-    Öffne Sim und klicke im Dashboard auf "Neuer Workflow". Benenne ihn "Erste Schritte".
+  <Step title="Workflow erstellen und einen KI-Agenten hinzufügen">
+    Klicke im Dashboard auf **Neuer Workflow** und benenne ihn "Getting Started".
     
-    Wenn du einen neuen Workflow erstellst, enthält er automatisch einen **Start-Block** - dies ist der Einstiegspunkt, der Eingaben von Benutzern empfängt. Für dieses Beispiel werden wir den Workflow über den Chat auslösen, daher müssen wir am Start-Block nichts konfigurieren.
+    Jeder neue Workflow enthält standardmäßig einen **Start-Block** – dies ist der Eingangspunkt, der Benutzereingaben empfängt. Da wir diesen Workflow über Chat auslösen werden, ist keine Konfiguration für den Start-Block erforderlich.
     
-    Ziehe nun einen **Agenten-Block** aus dem Blockbereich auf der linken Seite auf die Arbeitsfläche.
-    
-    Konfiguriere den Agenten-Block:
+    Ziehe einen **Agenten-Block** aus dem linken Bereich auf die Arbeitsfläche und konfiguriere ihn:
     - **Modell**: Wähle "OpenAI GPT-4o"
-    - **System-Prompt**: "Du bist ein Personen-Recherche-Agent. Wenn dir ein Personenname gegeben wird, nutze deine verfügbaren Suchwerkzeuge, um umfassende Informationen über diese Person zu finden, einschließlich ihres Standorts, Berufs, Bildungshintergrunds und anderer relevanter Details."
-    - **Benutzer-Prompt**: Ziehe die Verbindung vom Ausgabefeld des Start-Blocks in dieses Feld (dies verbindet `<start.input>` mit dem Benutzer-Prompt)
+    - **System-Prompt**: "Du bist ein Personenrecherche-Agent. Wenn dir ein Name einer Person gegeben wird, nutze deine verfügbaren Suchwerkzeuge, um umfassende Informationen über sie zu finden, einschließlich ihres Standorts, Berufs, Bildungshintergrunds und anderer relevanter Details."
+    - **Benutzer-Prompt**: Ziehe die Verbindung vom Ausgabefeld des Start-Blocks in dieses Feld, um `<start.input>` mit dem Benutzer-Prompt zu verbinden
     
     <div className="mx-auto w-full overflow-hidden rounded-lg">
       <Video src="getting-started/started-2.mp4" width={700} height={450} />
     </div>
   </Step>
   
-  <Step title="Werkzeuge zum Agenten hinzufügen">
-    Verbessern wir unseren Agenten mit Werkzeugen für bessere Fähigkeiten. Klicke auf den Agenten-Block, um ihn auszuwählen.
+  <Step title="Suchwerkzeuge zum Agenten hinzufügen">
+    Erweitere deinen Agenten mit Websuche-Funktionen. Klicke auf den Agenten-Block, um ihn auszuwählen.
     
-    Im Bereich **Werkzeuge**:
-    - Klicke auf **Werkzeug hinzufügen**
-    - Wähle **Exa** aus den verfügbaren Werkzeugen
-    - Wähle **Linkup** aus den verfügbaren Werkzeugen
-    - Füge deine API-Schlüssel für beide Werkzeuge hinzu (dies ermöglicht dem Agenten, das Web zu durchsuchen und auf zusätzliche Informationen zuzugreifen)
+    Im Bereich **Tools**:
+    - Klicke auf **Tool hinzufügen**
+    - Wähle **Exa** und **Linkup** aus den verfügbaren Tools
+    - Gib deine API-Schlüssel für beide Tools ein, um Websuche und Datenzugriff zu ermöglichen
     
     <div className="mx-auto w-3/5 overflow-hidden rounded-lg">
       <Video src="getting-started/started-3.mp4" width={700} height={450} />
     </div>
   </Step>
   
-  <Step title="Den grundlegenden Workflow testen">
-    Jetzt testen wir unseren Workflow. Gehe zum **Chat-Panel** auf der rechten Seite des Bildschirms.
+  <Step title="Workflow testen">
+    Teste deinen Workflow mit dem **Chat-Panel** auf der rechten Seite des Bildschirms.
     
     Im Chat-Panel:
-    - Klicke auf das Dropdown-Menü und wähle `agent1.content` (dies zeigt uns die Ausgabe unseres Agenten)
-    - Gib eine Testnachricht ein, wie: "John ist ein Softwareentwickler aus San Francisco, der Informatik an der Stanford University studiert hat."
-    - Klicke auf "Senden", um den Workflow auszuführen
+    - Klicke auf das Dropdown-Menü und wähle `agent1.content`, um die Ausgabe des Agenten anzuzeigen
+    - Gib eine Testnachricht ein: "John ist ein Softwareentwickler aus San Francisco, der Informatik an der Stanford University studiert hat."
+    - Klicke auf **Senden**, um den Workflow auszuführen
     
-    Du solltest die Antwort des Agenten sehen, der die in deinem Text beschriebene Person analysiert.
+    Der Agent wird die Person analysieren und strukturierte Informationen zurückgeben.
     
     <div className="mx-auto w-full overflow-hidden rounded-lg">
       <Video src="getting-started/started-4.mp4" width={700} height={450} />
     </div>
   </Step>
   
-  <Step title="Strukturierte Ausgabe hinzufügen">
-    Jetzt lassen wir unseren Agenten strukturierte Daten zurückgeben. Klicke auf den Agenten-Block, um ihn auszuwählen.
+  <Step title="Strukturierte Ausgabe konfigurieren">
+    Konfiguriere deinen Agenten, um strukturierte JSON-Daten zurückzugeben. Klicke auf den Agenten-Block, um ihn auszuwählen.
     
     Im Bereich **Antwortformat**:
     - Klicke auf das **Zauberstab-Symbol** (✨) neben dem Schema-Feld
-    - Gib in der erscheinenden Aufforderung ein: "Erstelle ein Schema namens Person, das Standort, Beruf und Bildung enthält"
-    - Die KI generiert automatisch ein JSON-Schema für dich
+    - Gib den Prompt ein: "Erstelle ein Schema namens person, das Standort, Beruf und Ausbildung enthält"
+    - Die KI wird automatisch das JSON-Schema generieren
     
     <div className="mx-auto w-full overflow-hidden rounded-lg">
       <Video src="getting-started/started-5.mp4" width={700} height={450} />
     </div>
   </Step>
   
-  <Step title="Die strukturierte Ausgabe testen">
-    Gehe zurück zum **Chat-Panel**.
+  <Step title="Mit strukturierter Ausgabe testen">
+    Kehre zum **Chat-Panel** zurück, um das strukturierte Antwortformat zu testen.
     
-    Da wir ein Antwortformat hinzugefügt haben, sind jetzt neue Ausgabeoptionen verfügbar:
-    - Klicke auf das Dropdown-Menü und wähle die neue Option für strukturierte Ausgabe (das Schema, das wir gerade erstellt haben)
-    - Gib eine neue Testnachricht ein, wie: "Sarah ist eine Marketing-Managerin aus New York, die einen MBA von der Harvard Business School hat."
-    - Klicke auf "Senden", um den Workflow erneut auszuführen
+    Mit dem konfigurierten Antwortformat sind jetzt neue Ausgabeoptionen verfügbar:
+    - Klicke auf das Dropdown-Menü und wähle die Option für strukturierte Ausgabe (das Schema, das du gerade erstellt hast)
+    - Gib eine Testnachricht ein: "Sarah ist eine Marketing-Managerin aus New York mit einem MBA von der Harvard Business School."
+    - Klicke auf **Senden**, um den Workflow auszuführen
     
-    Du solltest jetzt eine strukturierte JSON-Ausgabe sehen, bei der die Informationen der Person in die Felder Standort, Beruf und Bildung gegliedert sind.
+    Der Agent wird nun strukturierte JSON-Ausgabe zurückgeben, wobei die Informationen der Person in die Felder Standort, Beruf und Ausbildung organisiert sind.
     
     <div className="mx-auto w-full overflow-hidden rounded-lg">
       <Video src="getting-started/started-6.mp4" width={700} height={450} />
@@ -124,15 +120,15 @@ Einen Personen-Recherche-Agenten, der:
   </Step>
 </Steps>
 
-## Was du gerade erstellt hast
+## Was du erstellt hast
 
-Herzlichen Glückwunsch! Du hast deinen ersten KI-Workflow erstellt, der:
-- ✅ Texteingaben über eine Chat-Schnittstelle empfängt
-- ✅ KI nutzt, um Informationen aus unstrukturiertem Text zu extrahieren
-- ✅ Externe Tools (Exa und Linkup) für erweiterte Funktionen integriert
+Du hast erfolgreich einen KI-Workflow erstellt, der:
+- ✅ Benutzereingaben über eine Chat-Schnittstelle akzeptiert
+- ✅ Unstrukturierten Text mit KI verarbeitet
+- ✅ Externe Suchwerkzeuge integriert (Exa und Linkup)
 - ✅ Strukturierte JSON-Daten mit KI-generierten Schemas zurückgibt
-- ✅ Workflow-Tests und Iterationen demonstriert
-- ✅ Die Leistungsfähigkeit des visuellen Workflow-Aufbaus zeigt
+- ✅ Echtzeit-Tests und Iteration demonstriert
+- ✅ Die Leistungsfähigkeit der visuellen, codefreien Entwicklung zeigt
 
 ## Wichtige Konzepte, die du gelernt hast
 
@@ -153,41 +149,48 @@ Herzlichen Glückwunsch! Du hast deinen ersten KI-Workflow erstellt, der:
 
 ### Grundlegende Workflow-Konzepte
 
-**Datenfluss**: Variablen fließen zwischen Blöcken durch das Ziehen von Verbindungen
+**Datenfluss**  
+Verbinde Blöcke durch Ziehen von Verbindungen, um Daten zwischen Workflow-Schritten zu übertragen
 
-**Chat-Schnittstelle**: Teste Workflows in Echtzeit mit dem Chat-Panel mit verschiedenen Ausgabeoptionen
+**Chat-Schnittstelle**  
+Teste Workflows in Echtzeit mit dem Chat-Panel und wähle verschiedene Ausgabeoptionen
 
-**Tool-Integration**: Erweitere die Fähigkeiten des Agenten durch Hinzufügen externer Tools wie Exa und Linkup
+**Tool-Integration**  
+Erweitere die Fähigkeiten des Agenten durch Integration externer Dienste wie Exa und Linkup
 
-**Variablenreferenzen**: Greife auf Block-Ausgaben mit der `<blockName.output>` Syntax zu
+**Variablenreferenzen**  
+Greife auf Block-Ausgaben mit der `<blockName.output>` Syntax zu
 
-**Strukturierte Ausgabe**: Verwende JSON-Schemas, um konsistente, strukturierte Daten von der KI zu erhalten
+**Strukturierte Ausgabe**  
+Definiere JSON-Schemas, um konsistente, formatierte Antworten von der KI zu gewährleisten
 
-**KI-generierte Schemas**: Nutze den Zauberstab (✨), um Schemas mit natürlicher Sprache zu generieren
+**KI-generierte Schemas**  
+Verwende den Zauberstab (✨), um Schemas aus natürlichsprachigen Eingabeaufforderungen zu generieren
 
-**Iterative Entwicklung**: Teste, modifiziere und teste Workflows einfach erneut
+**Iterative Entwicklung**  
+Erstelle, teste und verfeinere Workflows schnell mit sofortigem Feedback
 
 ## Nächste Schritte
 
 <Cards>
-  <Card title="Weitere Blöcke hinzufügen" href="/blocks">
-    Erfahre mehr über API-, Funktions- und Bedingungsblöcke
+  <Card title="Workflow-Blöcke erkunden" href="/blocks">
+    Entdecke API-, Funktions-, Bedingungs- und andere Workflow-Blöcke
   </Card>
-  <Card title="Tools verwenden" href="/tools">
-    Integration mit externen Diensten wie Gmail, Slack und Notion
+  <Card title="Integrationen durchsuchen" href="/tools">
+    Verbinde über 80 Dienste einschließlich Gmail, Slack, Notion und mehr
   </Card>
   <Card title="Benutzerdefinierte Logik hinzufügen" href="/blocks/function">
-    Verwende Funktionsblöcke für benutzerdefinierte Datenverarbeitung
+    Schreibe benutzerdefinierte Funktionen für fortgeschrittene Datenverarbeitung
   </Card>
   <Card title="Deinen Workflow bereitstellen" href="/execution">
-    Mache deinen Workflow über REST API zugänglich
+    Mache deinen Workflow über REST API oder Webhooks zugänglich
   </Card>
 </Cards>
 
-## Brauchst du Hilfe?
+## Ressourcen
 
-**Bei einem Schritt hängengeblieben?** Schau in unserer [Blocks-Dokumentation](/blocks) nach detaillierten Erklärungen zu jeder Komponente.
+**Brauchst du detaillierte Erklärungen?** Besuche die [Blocks-Dokumentation](/blocks) für umfassende Anleitungen zu jeder Komponente.
 
-**Möchten Sie mehr Beispiele sehen?** Durchsuchen Sie unsere [Tools-Dokumentation](/tools), um zu sehen, welche Integrationen verfügbar sind.
+**Suchst du nach Integrationen?** Erkunde die [Tools-Dokumentation](/tools), um alle 80+ verfügbaren Integrationen zu sehen.
 
-**Bereit für die Bereitstellung?** Erfahren Sie mehr über [Ausführung und Bereitstellung](/execution), um Ihre Workflows zu aktivieren.
+**Bereit für den Livebetrieb?** Erfahre mehr über [Ausführung und Bereitstellung](/execution), um deine Workflows produktionsreif zu machen.

apps/docs/content/docs/de/index.mdx

@@ -46,15 +46,12 @@ Willkommen bei Sim, einem visuellen Workflow-Builder für KI-Anwendungen. Erstel
 
 <Cards>
   <Card title="Team-Management" href="/permissions/roles-and-permissions">
-    Richten Sie Workspace-Rollen und Berechtigungen ein
-  </Card>
-  <Card title="YAML-Konfiguration" href="/yaml">
-    Definieren Sie Workflows als Code
+    Workspace-Rollen und Berechtigungen einrichten
   </Card>
   <Card title="MCP-Integration" href="/mcp">
-    Verbinden Sie externe Dienste mit dem Model Context Protocol
+    Externe Dienste mit dem Model Context Protocol verbinden
   </Card>
   <Card title="SDKs" href="/sdks">
-    Integrieren Sie Sim in Ihre Anwendungen
+    Sim in Ihre Anwendungen integrieren
   </Card>
 </Cards>

apps/docs/content/docs/de/introduction/index.mdx

@@ -5,8 +5,9 @@ title: Einführung
 import { Card, Cards } from 'fumadocs-ui/components/card'
 import { Callout } from 'fumadocs-ui/components/callout'
 import { Image } from '@/components/ui/image'
+import { Video } from '@/components/ui/video'
 
-Sim ist ein visueller Workflow-Builder für KI-Anwendungen, mit dem Sie KI-Agenten-Workflows visuell erstellen können. Erstellen Sie leistungsstarke KI-Agenten, Automatisierungs-Workflows und Datenverarbeitungs-Pipelines, indem Sie Blöcke auf einer Leinwand verbinden – ganz ohne Programmierung.
+Sim ist ein Open-Source-Tool zur visuellen Workflow-Erstellung für die Entwicklung und Bereitstellung von KI-Agenten-Workflows. Entwerfen Sie intelligente Automatisierungssysteme mit einer No-Code-Oberfläche – verbinden Sie KI-Modelle, Datenbanken, APIs und Business-Tools über eine intuitive Drag-and-Drop-Oberfläche. Ob Sie Chatbots entwickeln, Geschäftsprozesse automatisieren oder komplexe Datenpipelines orchestrieren – Sim bietet die Werkzeuge, um Ihre KI-Workflows zum Leben zu erwecken.
 
 <div className="flex justify-center">
   <Image
@@ -20,50 +21,81 @@ Sim ist ein visueller Workflow-Builder für KI-Anwendungen, mit dem Sie KI-Agent
 
 ## Was Sie erstellen können
 
-**KI-Assistenten & Chatbots**
-Erstellen Sie intelligente Agenten, die im Web suchen, auf Ihren Kalender zugreifen, E-Mails senden und mit Ihren Geschäftstools interagieren können.
+**KI-Assistenten & Chatbots**  
+Entwickeln Sie intelligente Konversationsagenten, die sich in Ihre Tools und Daten integrieren lassen. Ermöglichen Sie Funktionen wie Websuche, Kalenderverwaltung, E-Mail-Automatisierung und nahtlose Interaktion mit Geschäftssystemen.
 
-**Geschäftsprozessautomatisierung**
-Automatisieren Sie wiederkehrende Aufgaben wie Dateneingabe, Berichtserstellung, Kundenservice-Antworten und Content-Erstellung.
+**Automatisierung von Geschäftsprozessen**  
+Beseitigen Sie manuelle Aufgaben in Ihrer gesamten Organisation. Automatisieren Sie Dateneingaben, erstellen Sie Berichte, beantworten Sie Kundenanfragen und optimieren Sie Workflows zur Inhaltserstellung.
 
-**Datenverarbeitung & -analyse**
-Gewinnen Sie Erkenntnisse aus Dokumenten, analysieren Sie Datensätze, erstellen Sie Berichte und synchronisieren Sie Daten zwischen Systemen.
+**Datenverarbeitung & -analyse**  
+Verwandeln Sie Rohdaten in umsetzbare Erkenntnisse. Extrahieren Sie Informationen aus Dokumenten, führen Sie Datensatzanalysen durch, erstellen Sie automatisierte Berichte und synchronisieren Sie Daten über verschiedene Plattformen hinweg.
 
-**API-Integrations-Workflows**
-Verbinden Sie mehrere Dienste zu einheitlichen Endpunkten, orchestrieren Sie komplexe Geschäftslogik und verwalten Sie ereignisgesteuerte Automatisierung.
+**API-Integrations-Workflows**  
+Orchestieren Sie komplexe Interaktionen zwischen mehreren Diensten. Erstellen Sie einheitliche API-Endpunkte, implementieren Sie anspruchsvolle Geschäftslogik und bauen Sie ereignisgesteuerte Automatisierungssysteme.
+
+<div className="mx-auto w-full overflow-hidden rounded-lg my-6">
+  <Video src="introduction/chat-workflow.mp4" width={700} height={450} />
+</div>
 
 ## Wie es funktioniert
 
-**Visuelle Leinwand**
-Ziehen Sie Blöcke per Drag-and-drop, um Workflows zu erstellen. Verbinden Sie KI-Modelle, Datenbanken, APIs und Geschäftstools mit einfachen Point-and-Click-Verbindungen.
+**Visueller Workflow-Editor**  
+Entwerfen Sie Workflows mit einer intuitiven Drag-and-Drop-Oberfläche. Verbinden Sie KI-Modelle, Datenbanken, APIs und Dienste von Drittanbietern über eine visuelle No-Code-Schnittstelle, die komplexe Automatisierungslogik leicht verständlich und wartbar macht.
 
-**Intelligente Blöcke**
-Wählen Sie aus Verarbeitungsblöcken (KI-Agenten, APIs, Funktionen), Logikblöcken (Bedingungen, Schleifen, Router) und Ausgabeblöcken (Antworten, Evaluatoren).
+**Modulares Blocksystem**  
+Bauen Sie mit spezialisierten Komponenten: Verarbeitungsblöcke (KI-Agenten, API-Aufrufe, benutzerdefinierte Funktionen), Logikblöcke (bedingte Verzweigungen, Schleifen, Router) und Ausgabeblöcke (Antworten, Evaluatoren). Jeder Block übernimmt eine bestimmte Aufgabe in Ihrem Workflow.
 
-**Mehrere Auslöser**
-Starten Sie Workflows über Chat-Schnittstelle, REST API, Webhooks, geplante Jobs oder externe Ereignisse von Diensten wie Slack und GitHub.
+**Flexible Ausführungsauslöser**  
+Starten Sie Workflows über mehrere Kanäle, einschließlich Chat-Schnittstellen, REST-APIs, Webhooks, geplante Cron-Jobs oder externe Ereignisse von Plattformen wie Slack und GitHub.
 
-**Team-Zusammenarbeit**
-Arbeiten Sie gleichzeitig mit Teammitgliedern am selben Workflow mit Echtzeit-Bearbeitung und Berechtigungsverwaltung.
+**Echtzeit-Zusammenarbeit**  
+Ermöglichen Sie Ihrem Team, gemeinsam zu arbeiten. Mehrere Benutzer können Workflows gleichzeitig bearbeiten, mit Live-Updates und detaillierten Berechtigungskontrollen.
 
-## Integrierte Anbindungen
+<div className="mx-auto w-full overflow-hidden rounded-lg my-6">
+  <Video src="introduction/build-workflow.mp4" width={700} height={450} />
+</div>
 
-Sim verbindet sich von Haus aus mit über 80 Diensten:
+## Integrationen
 
-- **KI-Modelle**: OpenAI, Anthropic, Google, Groq, Cerebras, lokale Ollama-Modelle
-- **Kommunikation**: Gmail, Slack, Teams, Telegram, WhatsApp  
-- **Produktivität**: Notion, Google Sheets, Airtable, Monday.com
-- **Entwicklung**: GitHub, Jira, Linear, Browser-Automatisierung
-- **Suche & Web**: Google Search, Perplexity, Firecrawl, Exa AI
+Sim bietet native Integrationen mit über 80 Diensten in verschiedenen Kategorien:
+
+- **KI-Modelle**: OpenAI, Anthropic, Google Gemini, Groq, Cerebras, lokale Modelle über Ollama oder VLLM
+- **Kommunikation**: Gmail, Slack, Microsoft Teams, Telegram, WhatsApp  
+- **Produktivität**: Notion, Google Workspace, Airtable, Monday.com
+- **Entwicklung**: GitHub, Jira, Linear, automatisierte Browser-Tests
+- **Suche & Daten**: Google Search, Perplexity, Firecrawl, Exa AI
 - **Datenbanken**: PostgreSQL, MySQL, Supabase, Pinecone, Qdrant
 
-Benötigen Sie etwas Maßgeschneidertes? Nutzen Sie unsere [MCP-Integration](/mcp), um jeden externen Dienst anzubinden.
+Für benutzerdefinierte Integrationen nutzen Sie unsere [MCP (Model Context Protocol)-Unterstützung](/mcp), um beliebige externe Dienste oder Tools anzubinden.
+
+<div className="mx-auto w-full overflow-hidden rounded-lg my-6">
+  <Video src="introduction/integrations-sidebar.mp4" width={700} height={450} />
+</div>
+
+## Copilot
+
+**Fragen stellen & Anleitung erhalten**  
+Der Copilot beantwortet Fragen zu Sim, erklärt Ihre Workflows und gibt Verbesserungsvorschläge. Verwenden Sie das `@` Symbol, um auf Workflows, Blöcke, Dokumentation, Wissen und Protokolle für kontextbezogene Unterstützung zu verweisen.
+
+**Workflows erstellen & bearbeiten**  
+Wechseln Sie in den Agent-Modus, damit der Copilot Änderungen direkt auf Ihrer Arbeitsfläche vorschlagen und anwenden kann. Fügen Sie Blöcke hinzu, konfigurieren Sie Einstellungen, verbinden Sie Variablen und strukturieren Sie Workflows mit natürlichsprachlichen Befehlen um.
+
+**Adaptive Reasoning-Stufen**  
+Wählen Sie zwischen den Modi Schnell, Auto, Erweitert oder Behemoth, je nach Komplexität der Aufgabe. Beginnen Sie mit Schnell für einfache Fragen und steigern Sie sich bis zu Behemoth für komplexe architektonische Änderungen und tiefgehendes Debugging.
+
+Erfahren Sie mehr über [Copilot-Funktionen](/copilot) und wie Sie die Produktivität mit KI-Unterstützung maximieren können.
+
+<div className="mx-auto w-full overflow-hidden rounded-lg my-6">
+  <Video src="introduction/copilot-workflow.mp4" width={700} height={450} />
+</div>
 
 ## Bereitstellungsoptionen
 
-**Cloud-gehostet**: Starten Sie sofort bei [sim.ai](https://sim.ai) mit verwalteter Infrastruktur, automatischer Skalierung und integriertem Monitoring.
+**Cloud-Hosting**  
+Starten Sie sofort bei [sim.ai](https://sim.ai) mit vollständig verwalteter Infrastruktur, automatischer Skalierung und integrierter Beobachtbarkeit. Konzentrieren Sie sich auf den Aufbau von Workflows, während wir den Betrieb übernehmen.
 
-**Selbst-gehostet**: Stellen Sie die Anwendung auf Ihrer eigenen Infrastruktur mit Docker bereit, mit Unterstützung für lokale KI-Modelle über Ollama für vollständige Datenprivatsphäre.
+**Self-Hosting**  
+Stellen Sie die Lösung auf Ihrer eigenen Infrastruktur mit Docker Compose oder Kubernetes bereit. Behalten Sie die vollständige Kontrolle über Ihre Daten mit Unterstützung für lokale KI-Modelle durch Ollama-Integration.
 
 ## Nächste Schritte
 
@@ -73,11 +105,11 @@ Bereit, Ihren ersten KI-Workflow zu erstellen?
   <Card title="Erste Schritte" href="/getting-started">
     Erstellen Sie Ihren ersten Workflow in 10 Minuten
   </Card>
-  <Card title="Workflow-Bausteine" href="/blocks">
+  <Card title="Workflow-Blöcke" href="/blocks">
     Erfahren Sie mehr über die Bausteine
   </Card>
   <Card title="Tools & Integrationen" href="/tools">
-    Entdecken Sie über 60 integrierte Schnittstellen
+    Entdecken Sie über 80 integrierte Integrationen
   </Card>
   <Card title="Team-Berechtigungen" href="/permissions/roles-and-permissions">
     Richten Sie Workspace-Rollen und Berechtigungen ein

apps/docs/content/docs/de/knowledgebase/index.mdx

@@ -1,5 +1,7 @@
 ---
-title: Wissensdatenbank
+title: Übersicht
+description: Laden Sie Ihre Dokumente hoch, verarbeiten und durchsuchen Sie sie
+  mit intelligenter Vektorsuche und Chunking
 ---
 
 import { Video } from '@/components/ui/video'

apps/docs/content/docs/de/mcp/index.mdx

@@ -2,7 +2,7 @@
 title: MCP (Model Context Protocol)
 ---
 
-import { Video } from '@/components/ui/video'
+import { Image } from '@/components/ui/image'
 import { Callout } from 'fumadocs-ui/components/callout'
 
 Das Model Context Protocol ([MCP](https://modelcontextprotocol.com/)) ermöglicht es Ihnen, externe Tools und Dienste über ein standardisiertes Protokoll zu verbinden, wodurch Sie APIs und Dienste direkt in Ihre Workflows integrieren können. Mit MCP können Sie die Fähigkeiten von Sim erweitern, indem Sie benutzerdefinierte Integrationen hinzufügen, die nahtlos mit Ihren Agenten und Workflows zusammenarbeiten.
@@ -16,16 +16,18 @@ MCP ist ein offener Standard, der es KI-Assistenten ermöglicht, sich sicher mit
 - Benutzerdefinierte Tools und Skripte auszuführen
 - Sicheren, kontrollierten Zugriff auf externe Ressourcen zu gewährleisten
 
-## Hinzufügen von MCP-Servern
+## Konfiguration von MCP-Servern
 
-MCP-Server stellen Sammlungen von Tools bereit, die Ihre Agenten nutzen können. Sie können MCP-Server auf zwei Arten hinzufügen:
+MCP-Server stellen Sammlungen von Tools bereit, die Ihre Agenten nutzen können. Konfigurieren Sie diese in den Workspace-Einstellungen:
 
-### Über die Workspace-Einstellungen
-
-Konfigurieren Sie MCP-Server auf Workspace-Ebene, damit alle Teammitglieder sie nutzen können:
-
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="mcp-1.mp4" width={700} height={450} />
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/mcp-1.png"
+    alt="Konfiguration eines MCP-Servers in den Einstellungen"
+    width={700}
+    height={450}
+    className="my-6"
+  />
 </div>
 
 1. Navigieren Sie zu Ihren Workspace-Einstellungen
@@ -35,29 +37,25 @@ Konfigurieren Sie MCP-Server auf Workspace-Ebene, damit alle Teammitglieder sie
 5. Speichern Sie die Konfiguration
 
 <Callout type="info">
-MCP-Server, die in den Workspace-Einstellungen konfiguriert sind, stehen allen Workspace-Mitgliedern entsprechend ihrer Berechtigungsstufen zur Verfügung.
+Sie können MCP-Server auch direkt über die Symbolleiste in einem Agent-Block für eine schnelle Einrichtung konfigurieren.
 </Callout>
 
-### Über die Agenten-Konfiguration
-
-Sie können MCP-Server auch direkt innerhalb eines Agenten-Blocks hinzufügen und konfigurieren:
-
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="mcp-2.mp4" width={700} height={450} />
-</div>
-
-Dies ist nützlich, wenn Sie schnell eine bestimmte Integration für einen speziellen Workflow einrichten müssen.
-
 ## Verwendung von MCP-Tools in Agenten
 
-Sobald MCP-Server konfiguriert sind, werden ihre Tools innerhalb Ihrer Agentenblöcke verfügbar:
+Sobald MCP-Server konfiguriert sind, werden ihre Tools innerhalb Ihrer Agent-Blöcke verfügbar:
 
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="mcp-3.mp4" width={700} height={450} />
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/mcp-2.png"
+    alt="Verwendung eines MCP-Tools im Agent-Block"
+    width={700}
+    height={450}
+    className="my-6"
+  />
 </div>
 
-1. Öffnen Sie einen **Agenten**-Block
-2. Im Abschnitt **Tools** sehen Sie verfügbare MCP-Tools
+1. Öffnen Sie einen **Agent**-Block
+2. Im Abschnitt **Tools** sehen Sie die verfügbaren MCP-Tools
 3. Wählen Sie die Tools aus, die der Agent verwenden soll
 4. Der Agent kann nun während der Ausführung auf diese Tools zugreifen
 
@@ -65,8 +63,14 @@ Sobald MCP-Server konfiguriert sind, werden ihre Tools innerhalb Ihrer Agentenbl
 
 Für eine genauere Kontrolle können Sie den dedizierten MCP-Tool-Block verwenden, um bestimmte MCP-Tools auszuführen:
 
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="mcp-4.mp4" width={700} height={450} />
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/mcp-3.png"
+    alt="Eigenständiger MCP-Tool-Block"
+    width={700}
+    height={450}
+    className="my-6"
+  />
 </div>
 
 Der MCP-Tool-Block ermöglicht es Ihnen:
@@ -94,9 +98,9 @@ MCP-Funktionalität erfordert spezifische Workspace-Berechtigungen:
 | Aktion | Erforderliche Berechtigung |
 |--------|-------------------|
 | MCP-Server in den Einstellungen konfigurieren | **Admin** |
-| MCP-Tools in Agenten verwenden | **Schreiben** oder **Admin** |
-| Verfügbare MCP-Tools anzeigen | **Lesen**, **Schreiben** oder **Admin** |
-| MCP-Tool-Blöcke ausführen | **Schreiben** oder **Admin** |
+| MCP-Tools in Agenten verwenden | **Write** oder **Admin** |
+| Verfügbare MCP-Tools anzeigen | **Read**, **Write** oder **Admin** |
+| MCP-Tool-Blöcke ausführen | **Write** oder **Admin** |
 
 ## Häufige Anwendungsfälle
 
@@ -113,14 +117,14 @@ Lesen, schreiben und bearbeiten Sie Dateien auf lokalen oder entfernten Dateisys
 Führen Sie benutzerdefinierte Skripte oder Tools aus, die auf die Bedürfnisse Ihrer Organisation zugeschnitten sind.
 
 ### Echtzeit-Datenzugriff
-Rufen Sie während der Workflow-Ausführung Live-Daten von externen Systemen ab.
+Rufen Sie Live-Daten von externen Systemen während der Workflow-Ausführung ab.
 
 ## Sicherheitsüberlegungen
 
 - MCP-Server laufen mit den Berechtigungen des Benutzers, der sie konfiguriert hat
-- Überprüfen Sie immer die Quellen von MCP-Servern vor der Installation
+- Überprüfen Sie immer die MCP-Server-Quellen vor der Installation
 - Verwenden Sie Umgebungsvariablen für sensible Konfigurationsdaten
-- Überprüfen Sie die Fähigkeiten des MCP-Servers, bevor Sie Agenten Zugriff gewähren
+- Überprüfen Sie die MCP-Server-Funktionen, bevor Sie Agenten Zugriff gewähren
 
 ## Fehlerbehebung
 
@@ -137,4 +141,4 @@ Rufen Sie während der Workflow-Ausführung Live-Daten von externen Systemen ab.
 ### Berechtigungsfehler
 - Bestätigen Sie Ihre Workspace-Berechtigungsstufe
 - Prüfen Sie, ob der MCP-Server zusätzliche Authentifizierung erfordert
-- Überprüfen Sie, ob der Server für Ihren Workspace richtig konfiguriert ist
+- Stellen Sie sicher, dass der Server für Ihren Workspace richtig konfiguriert ist

apps/docs/content/docs/de/sdks/python.mdx

@@ -1,5 +1,5 @@
 ---
-title: Python SDK
+title: Python
 ---
 
 import { Callout } from 'fumadocs-ui/components/callout'
@@ -10,7 +10,7 @@ import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
 Das offizielle Python SDK für Sim ermöglicht es Ihnen, Workflows programmatisch aus Ihren Python-Anwendungen mithilfe des offiziellen Python SDKs auszuführen.
 
 <Callout type="info">
-  Das Python SDK unterstützt Python 3.8+ und bietet synchrone Workflow-Ausführung. Alle Workflow-Ausführungen sind derzeit synchron.
+  Das Python SDK unterstützt Python 3.8+ mit asynchroner Ausführungsunterstützung, automatischer Ratenbegrenzung mit exponentiellem Backoff und Nutzungsverfolgung.
 </Callout>
 
 ## Installation
@@ -74,12 +74,17 @@ result = client.execute_workflow(
 - `workflow_id` (str): Die ID des auszuführenden Workflows
 - `input_data` (dict, optional): Eingabedaten, die an den Workflow übergeben werden
 - `timeout` (float, optional): Timeout in Sekunden (Standard: 30.0)
+- `stream` (bool, optional): Streaming-Antworten aktivieren (Standard: False)
+- `selected_outputs` (list[str], optional): Block-Ausgaben, die im `blockName.attribute`Format gestreamt werden sollen (z.B. `["agent1.content"]`)
+- `async_execution` (bool, optional): Asynchron ausführen (Standard: False)
 
-**Rückgabewert:** `WorkflowExecutionResult`
+**Rückgabe:** `WorkflowExecutionResult | AsyncExecutionResult`
+
+Wenn `async_execution=True`, wird sofort mit einer Task-ID zum Abfragen zurückgegeben. Andernfalls wird auf den Abschluss gewartet.
 
 ##### get_workflow_status()
 
-Ruft den Status eines Workflows ab (Deployment-Status usw.).
+Den Status eines Workflows abrufen (Bereitstellungsstatus usw.).
 
 ```python
 status = client.get_workflow_status("workflow-id")
@@ -93,7 +98,7 @@ print("Is deployed:", status.is_deployed)
 
 ##### validate_workflow()
 
-Überprüft, ob ein Workflow für die Ausführung bereit ist.
+Überprüfen, ob ein Workflow für die Ausführung bereit ist.
 
 ```python
 is_ready = client.validate_workflow("workflow-id")
@@ -107,28 +112,118 @@ if is_ready:
 
 **Rückgabe:** `bool`
 
-##### execute_workflow_sync()
+##### get_job_status()
 
-<Callout type="info">
-  Derzeit ist diese Methode identisch mit `execute_workflow()`, da alle Ausführungen synchron sind. Diese Methode wird für zukünftige Kompatibilität bereitgestellt, wenn asynchrone Ausführung hinzugefügt wird.
-</Callout>
-
-Führt einen Workflow aus (derzeit synchron, identisch mit `execute_workflow()`).
+Den Status einer asynchronen Job-Ausführung abrufen.
 
 ```python
-result = client.execute_workflow_sync(
+status = client.get_job_status("task-id-from-async-execution")
+print("Status:", status["status"])  # 'queued', 'processing', 'completed', 'failed'
+if status["status"] == "completed":
+    print("Output:", status["output"])
+```
+
+**Parameter:**
+- `task_id` (str): Die Task-ID, die von der asynchronen Ausführung zurückgegeben wurde
+
+**Rückgabe:** `Dict[str, Any]`
+
+**Antwortfelder:**
+- `success` (bool): Ob die Anfrage erfolgreich war
+- `taskId` (str): Die Task-ID
+- `status` (str): Einer der Werte `'queued'`, `'processing'`, `'completed'`, `'failed'`, `'cancelled'`
+- `metadata` (dict): Enthält `startedAt`, `completedAt` und `duration`
+- `output` (any, optional): Die Workflow-Ausgabe (wenn abgeschlossen)
+- `error` (any, optional): Fehlerdetails (wenn fehlgeschlagen)
+- `estimatedDuration` (int, optional): Geschätzte Dauer in Millisekunden (wenn in Bearbeitung/in Warteschlange)
+
+##### execute_with_retry()
+
+Einen Workflow mit automatischer Wiederholung bei Ratenbegrenzungsfehlern unter Verwendung von exponentiellem Backoff ausführen.
+
+```python
+result = client.execute_with_retry(
     "workflow-id",
-    input_data={"data": "some input"},
-    timeout=60.0
+    input_data={"message": "Hello"},
+    timeout=30.0,
+    max_retries=3,           # Maximum number of retries
+    initial_delay=1.0,       # Initial delay in seconds
+    max_delay=30.0,          # Maximum delay in seconds
+    backoff_multiplier=2.0   # Exponential backoff multiplier
 )
 ```
 
 **Parameter:**
 - `workflow_id` (str): Die ID des auszuführenden Workflows
 - `input_data` (dict, optional): Eingabedaten, die an den Workflow übergeben werden
-- `timeout` (float): Timeout für die initiale Anfrage in Sekunden
+- `timeout` (float, optional): Timeout in Sekunden
+- `stream` (bool, optional): Streaming-Antworten aktivieren
+- `selected_outputs` (list, optional): Block-Ausgaben zum Streamen
+- `async_execution` (bool, optional): Asynchron ausführen
+- `max_retries` (int, optional): Maximale Anzahl von Wiederholungen (Standard: 3)
+- `initial_delay` (float, optional): Anfängliche Verzögerung in Sekunden (Standard: 1.0)
+- `max_delay` (float, optional): Maximale Verzögerung in Sekunden (Standard: 30.0)
+- `backoff_multiplier` (float, optional): Backoff-Multiplikator (Standard: 2.0)
 
-**Rückgabe:** `WorkflowExecutionResult`
+**Rückgabewert:** `WorkflowExecutionResult | AsyncExecutionResult`
+
+Die Wiederholungslogik verwendet exponentielles Backoff (1s → 2s → 4s → 8s...) mit ±25% Jitter, um den Thundering-Herd-Effekt zu vermeiden. Wenn die API einen `retry-after` Header bereitstellt, wird dieser stattdessen verwendet.
+
+##### get_rate_limit_info()
+
+Ruft die aktuellen Rate-Limit-Informationen aus der letzten API-Antwort ab.
+
+```python
+rate_limit_info = client.get_rate_limit_info()
+if rate_limit_info:
+    print("Limit:", rate_limit_info.limit)
+    print("Remaining:", rate_limit_info.remaining)
+    print("Reset:", datetime.fromtimestamp(rate_limit_info.reset))
+```
+
+**Rückgabewert:** `RateLimitInfo | None`
+
+##### get_usage_limits()
+
+Ruft aktuelle Nutzungslimits und Kontingentinformationen für dein Konto ab.
+
+```python
+limits = client.get_usage_limits()
+print("Sync requests remaining:", limits.rate_limit["sync"]["remaining"])
+print("Async requests remaining:", limits.rate_limit["async"]["remaining"])
+print("Current period cost:", limits.usage["currentPeriodCost"])
+print("Plan:", limits.usage["plan"])
+```
+
+**Rückgabewert:** `UsageLimits`
+
+**Antwortstruktur:**
+
+```python
+{
+    "success": bool,
+    "rateLimit": {
+        "sync": {
+            "isLimited": bool,
+            "limit": int,
+            "remaining": int,
+            "resetAt": str
+        },
+        "async": {
+            "isLimited": bool,
+            "limit": int,
+            "remaining": int,
+            "resetAt": str
+        },
+        "authType": str  # 'api' or 'manual'
+    },
+    "usage": {
+        "currentPeriodCost": float,
+        "limit": float,
+        "plan": str  # e.g., 'free', 'pro'
+    }
+}
+```
 
 ##### set_api_key()
 
@@ -170,6 +265,18 @@ class WorkflowExecutionResult:
     total_duration: Optional[float] = None
 ```
 
+### AsyncExecutionResult
+
+```python
+@dataclass
+class AsyncExecutionResult:
+    success: bool
+    task_id: str
+    status: str  # 'queued'
+    created_at: str
+    links: Dict[str, str]  # e.g., {"status": "/api/jobs/{taskId}"}
+```
+
 ### WorkflowStatus
 
 ```python
@@ -177,10 +284,30 @@ class WorkflowExecutionResult:
 class WorkflowStatus:
     is_deployed: bool
     deployed_at: Optional[str] = None
-    is_published: bool = False
     needs_redeployment: bool = False
 ```
 
+### RateLimitInfo
+
+```python
+@dataclass
+class RateLimitInfo:
+    limit: int
+    remaining: int
+    reset: int
+    retry_after: Optional[int] = None
+```
+
+### UsageLimits
+
+```python
+@dataclass
+class UsageLimits:
+    success: bool
+    rate_limit: Dict[str, Any]
+    usage: Dict[str, Any]
+```
+
 ### SimStudioError
 
 ```python
@@ -191,6 +318,13 @@ class SimStudioError(Exception):
         self.status = status
 ```
 
+**Häufige Fehlercodes:**
+- `UNAUTHORIZED`: Ungültiger API-Schlüssel
+- `TIMEOUT`: Zeitüberschreitung bei der Anfrage
+- `RATE_LIMIT_EXCEEDED`: Ratengrenze überschritten
+- `USAGE_LIMIT_EXCEEDED`: Nutzungsgrenze überschritten
+- `EXECUTION_ERROR`: Workflow-Ausführung fehlgeschlagen
+
 ## Beispiele
 
 ### Grundlegende Workflow-Ausführung
@@ -214,7 +348,7 @@ class SimStudioError(Exception):
 import os
 from simstudio import SimStudioClient
 
-client = SimStudioClient(api_key=os.getenv("SIMSTUDIO_API_KEY"))
+client = SimStudioClient(api_key=os.getenv("SIM_API_KEY"))
 
 def run_workflow():
     try:
@@ -252,7 +386,7 @@ Behandeln Sie verschiedene Fehlertypen, die während der Workflow-Ausführung au
 from simstudio import SimStudioClient, SimStudioError
 import os
 
-client = SimStudioClient(api_key=os.getenv("SIMSTUDIO_API_KEY"))
+client = SimStudioClient(api_key=os.getenv("SIM_API_KEY"))   
 
 def execute_with_error_handling():
     try:
@@ -279,16 +413,7 @@ def execute_with_error_handling():
 
 Verwenden Sie den Client als Kontextmanager, um die Ressourcenbereinigung automatisch zu handhaben:
 
-```python
-from simstudio import SimStudioClient
-import os
-
-# Using context manager to automatically close the session
-with SimStudioClient(api_key=os.getenv("SIMSTUDIO_API_KEY")) as client:
-    result = client.execute_workflow("workflow-id")
-    print("Result:", result)
-# Session is automatically closed here
-```
+---CODE-PLACEHOLDER-ef99d3dd509e04865d5b6b0e0e03d3f8---
 
 ### Batch-Workflow-Ausführung
 
@@ -298,7 +423,7 @@ Führen Sie mehrere Workflows effizient aus:
 from simstudio import SimStudioClient
 import os
 
-client = SimStudioClient(api_key=os.getenv("SIMSTUDIO_API_KEY"))
+client = SimStudioClient(api_key=os.getenv("SIM_API_KEY"))   
 
 def execute_workflows_batch(workflow_data_pairs):
     """Execute multiple workflows with different input data."""
@@ -339,9 +464,233 @@ for result in results:
     print(f"Workflow {result['workflow_id']}: {'Success' if result['success'] else 'Failed'}")
 ```
 
+### Asynchrone Workflow-Ausführung
+
+Führen Sie Workflows asynchron für lang laufende Aufgaben aus:
+
+```python
+import os
+import time
+from simstudio import SimStudioClient
+
+client = SimStudioClient(api_key=os.getenv("SIM_API_KEY"))
+
+def execute_async():
+    try:
+        # Start async execution
+        result = client.execute_workflow(
+            "workflow-id",
+            input_data={"data": "large dataset"},
+            async_execution=True  # Execute asynchronously
+        )
+
+        # Check if result is an async execution
+        if hasattr(result, 'task_id'):
+            print(f"Task ID: {result.task_id}")
+            print(f"Status endpoint: {result.links['status']}")
+
+            # Poll for completion
+            status = client.get_job_status(result.task_id)
+
+            while status["status"] in ["queued", "processing"]:
+                print(f"Current status: {status['status']}")
+                time.sleep(2)  # Wait 2 seconds
+                status = client.get_job_status(result.task_id)
+
+            if status["status"] == "completed":
+                print("Workflow completed!")
+                print(f"Output: {status['output']}")
+                print(f"Duration: {status['metadata']['duration']}")
+            else:
+                print(f"Workflow failed: {status['error']}")
+
+    except Exception as error:
+        print(f"Error: {error}")
+
+execute_async()
+```
+
+### Rate-Limiting und Wiederholungsversuche
+
+Behandle Rate-Limits automatisch mit exponentiellem Backoff:
+
+```python
+import os
+from simstudio import SimStudioClient, SimStudioError
+
+client = SimStudioClient(api_key=os.getenv("SIM_API_KEY"))
+
+def execute_with_retry_handling():
+    try:
+        # Automatically retries on rate limit
+        result = client.execute_with_retry(
+            "workflow-id",
+            input_data={"message": "Process this"},
+            max_retries=5,
+            initial_delay=1.0,
+            max_delay=60.0,
+            backoff_multiplier=2.0
+        )
+
+        print(f"Success: {result}")
+    except SimStudioError as error:
+        if error.code == "RATE_LIMIT_EXCEEDED":
+            print("Rate limit exceeded after all retries")
+
+            # Check rate limit info
+            rate_limit_info = client.get_rate_limit_info()
+            if rate_limit_info:
+                from datetime import datetime
+                reset_time = datetime.fromtimestamp(rate_limit_info.reset)
+                print(f"Rate limit resets at: {reset_time}")
+
+execute_with_retry_handling()
+```
+
+### Nutzungsüberwachung
+
+Überwache deine Kontonutzung und -limits:
+
+```python
+import os
+from simstudio import SimStudioClient
+
+client = SimStudioClient(api_key=os.getenv("SIM_API_KEY"))
+
+def check_usage():
+    try:
+        limits = client.get_usage_limits()
+
+        print("=== Rate Limits ===")
+        print("Sync requests:")
+        print(f"  Limit: {limits.rate_limit['sync']['limit']}")
+        print(f"  Remaining: {limits.rate_limit['sync']['remaining']}")
+        print(f"  Resets at: {limits.rate_limit['sync']['resetAt']}")
+        print(f"  Is limited: {limits.rate_limit['sync']['isLimited']}")
+
+        print("\nAsync requests:")
+        print(f"  Limit: {limits.rate_limit['async']['limit']}")
+        print(f"  Remaining: {limits.rate_limit['async']['remaining']}")
+        print(f"  Resets at: {limits.rate_limit['async']['resetAt']}")
+        print(f"  Is limited: {limits.rate_limit['async']['isLimited']}")
+
+        print("\n=== Usage ===")
+        print(f"Current period cost: ${limits.usage['currentPeriodCost']:.2f}")
+        print(f"Limit: ${limits.usage['limit']:.2f}")
+        print(f"Plan: {limits.usage['plan']}")
+
+        percent_used = (limits.usage['currentPeriodCost'] / limits.usage['limit']) * 100
+        print(f"Usage: {percent_used:.1f}%")
+
+        if percent_used > 80:
+            print("⚠️  Warning: You are approaching your usage limit!")
+
+    except Exception as error:
+        print(f"Error checking usage: {error}")
+
+check_usage()
+```
+
+### Streaming-Workflow-Ausführung
+
+Führe Workflows mit Echtzeit-Streaming-Antworten aus:
+
+```python
+from simstudio import SimStudioClient
+import os
+
+client = SimStudioClient(api_key=os.getenv("SIM_API_KEY"))   
+
+def execute_with_streaming():
+    """Execute workflow with streaming enabled."""
+    try:
+        # Enable streaming for specific block outputs
+        result = client.execute_workflow(
+            "workflow-id",
+            input_data={"message": "Count to five"},
+            stream=True,
+            selected_outputs=["agent1.content"]  # Use blockName.attribute format
+        )
+
+        print("Workflow result:", result)
+    except Exception as error:
+        print("Error:", error)
+
+execute_with_streaming()
+```
+
+Die Streaming-Antwort folgt dem Server-Sent Events (SSE) Format:
+
+```
+data: {"blockId":"7b7735b9-19e5-4bd6-818b-46aae2596e9f","chunk":"One"}
+
+data: {"blockId":"7b7735b9-19e5-4bd6-818b-46aae2596e9f","chunk":", two"}
+
+data: {"event":"done","success":true,"output":{},"metadata":{"duration":610}}
+
+data: [DONE]
+```
+
+**Flask-Streaming-Beispiel:**
+
+```python
+from flask import Flask, Response, stream_with_context
+import requests
+import json
+import os
+
+app = Flask(__name__)
+
+@app.route('/stream-workflow')
+def stream_workflow():
+    """Stream workflow execution to the client."""
+
+    def generate():
+        response = requests.post(
+            'https://sim.ai/api/workflows/WORKFLOW_ID/execute',
+            headers={
+                'Content-Type': 'application/json',
+                'X-API-Key': os.getenv('SIM_API_KEY')
+            },
+            json={
+                'message': 'Generate a story',
+                'stream': True,
+                'selectedOutputs': ['agent1.content']
+            },
+            stream=True
+        )
+
+        for line in response.iter_lines():
+            if line:
+                decoded_line = line.decode('utf-8')
+                if decoded_line.startswith('data: '):
+                    data = decoded_line[6:]  # Remove 'data: ' prefix
+
+                    if data == '[DONE]':
+                        break
+
+                    try:
+                        parsed = json.loads(data)
+                        if 'chunk' in parsed:
+                            yield f"data: {json.dumps(parsed)}\n\n"
+                        elif parsed.get('event') == 'done':
+                            yield f"data: {json.dumps(parsed)}\n\n"
+                            print("Execution complete:", parsed.get('metadata'))
+                    except json.JSONDecodeError:
+                        pass
+
+    return Response(
+        stream_with_context(generate()),
+        mimetype='text/event-stream'
+    )
+
+if __name__ == '__main__':
+    app.run(debug=True)
+```
+
 ### Umgebungskonfiguration
 
-Konfigurieren Sie den Client mit Umgebungsvariablen:
+Konfiguriere den Client mit Umgebungsvariablen:
 
 <Tabs items={['Development', 'Production']}>
   <Tab value="Development">
@@ -352,8 +701,8 @@ Konfigurieren Sie den Client mit Umgebungsvariablen:
 
     # Development configuration
     client = SimStudioClient(
-        api_key=os.getenv("SIMSTUDIO_API_KEY"),
-        base_url=os.getenv("SIMSTUDIO_BASE_URL", "https://sim.ai")
+        api_key=os.getenv("SIM_API_KEY")
+        base_url=os.getenv("SIM_BASE_URL", "https://sim.ai")
     )
     ```
 
@@ -365,13 +714,13 @@ Konfigurieren Sie den Client mit Umgebungsvariablen:
     from simstudio import SimStudioClient
 
     # Production configuration with error handling
-    api_key = os.getenv("SIMSTUDIO_API_KEY")
+    api_key = os.getenv("SIM_API_KEY")
     if not api_key:
-        raise ValueError("SIMSTUDIO_API_KEY environment variable is required")
+        raise ValueError("SIM_API_KEY environment variable is required")
 
     client = SimStudioClient(
         api_key=api_key,
-        base_url=os.getenv("SIMSTUDIO_BASE_URL", "https://sim.ai")
+        base_url=os.getenv("SIM_BASE_URL", "https://sim.ai")
     )
     ```
 
@@ -382,26 +731,22 @@ Konfigurieren Sie den Client mit Umgebungsvariablen:
 
 <Steps>
   <Step title="Bei Sim anmelden">
-    Navigieren Sie zu [Sim](https://sim.ai) und melden Sie sich bei Ihrem Konto an.
+    Navigiere zu [Sim](https://sim.ai) und melde dich bei deinem Konto an.
   </Step>
-  <Step title="Ihren Workflow öffnen">
-    Navigieren Sie zu dem Workflow, den Sie programmatisch ausführen möchten.
+  <Step title="Öffne deinen Workflow">
+    Navigiere zu dem Workflow, den du programmatisch ausführen möchtest.
   </Step>
-  <Step title="Ihren Workflow bereitstellen">
-    Klicken Sie auf "Deploy", um Ihren Workflow bereitzustellen, falls dies noch nicht geschehen ist.
+  <Step title="Deploye deinen Workflow">
+    Klicke auf "Deploy", um deinen Workflow zu deployen, falls dies noch nicht geschehen ist.
   </Step>
-  <Step title="API-Schlüssel erstellen oder auswählen">
-    Wählen Sie während des Bereitstellungsprozesses einen API-Schlüssel aus oder erstellen Sie einen neuen.
+  <Step title="Erstelle oder wähle einen API-Schlüssel">
+    Wähle während des Deployment-Prozesses einen API-Schlüssel aus oder erstelle einen neuen.
   </Step>
-  <Step title="API-Schlüssel kopieren">
-    Kopieren Sie den API-Schlüssel zur Verwendung in Ihrer Python-Anwendung.
+  <Step title="Kopiere den API-Schlüssel">
+    Kopiere den API-Schlüssel zur Verwendung in deiner Python-Anwendung.
   </Step>
 </Steps>
 
-<Callout type="warning">
-  Halte deinen API-Schlüssel sicher und committe ihn niemals in die Versionskontrolle. Verwende Umgebungsvariablen oder sicheres Konfigurationsmanagement.
-</Callout>
-
 ## Anforderungen
 
 - Python 3.8+

apps/docs/content/docs/de/sdks/typescript.mdx

@@ -1,5 +1,5 @@
 ---
-title: TypeScript/JavaScript SDK
+title: TypeScript
 ---
 
 import { Callout } from 'fumadocs-ui/components/callout'
@@ -7,10 +7,10 @@ import { Card, Cards } from 'fumadocs-ui/components/card'
 import { Step, Steps } from 'fumadocs-ui/components/steps'
 import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
 
-Das offizielle TypeScript/JavaScript SDK für Sim bietet vollständige Typsicherheit und unterstützt sowohl Node.js- als auch Browser-Umgebungen, sodass Sie Workflows programmatisch aus Ihren Node.js-Anwendungen, Webanwendungen und anderen JavaScript-Umgebungen ausführen können. Alle Workflow-Ausführungen sind derzeit synchron.
+Das offizielle TypeScript/JavaScript SDK für Sim bietet vollständige Typsicherheit und unterstützt sowohl Node.js- als auch Browser-Umgebungen, sodass Sie Workflows programmatisch aus Ihren Node.js-Anwendungen, Webanwendungen und anderen JavaScript-Umgebungen ausführen können.
 
 <Callout type="info">
-  Das TypeScript SDK bietet vollständige Typsicherheit und unterstützt sowohl Node.js- als auch Browser-Umgebungen. Alle Workflow-Ausführungen sind derzeit synchron.
+  Das TypeScript SDK bietet vollständige Typsicherheit, Unterstützung für asynchrone Ausführung, automatische Ratenbegrenzung mit exponentiellem Backoff und Nutzungsverfolgung.
 </Callout>
 
 ## Installation
@@ -81,7 +81,7 @@ new SimStudioClient(config: SimStudioConfig)
 
 ##### executeWorkflow()
 
-Führen Sie einen Workflow mit optionalen Eingabedaten aus.
+Führt einen Workflow mit optionalen Eingabedaten aus.
 
 ```typescript
 const result = await client.executeWorkflow('workflow-id', {
@@ -95,8 +95,13 @@ const result = await client.executeWorkflow('workflow-id', {
 - `options` (ExecutionOptions, optional):
   - `input` (any): Eingabedaten, die an den Workflow übergeben werden
   - `timeout` (number): Timeout in Millisekunden (Standard: 30000)
+  - `stream` (boolean): Streaming-Antworten aktivieren (Standard: false)
+  - `selectedOutputs` (string[]): Block-Ausgaben, die im `blockName.attribute`Format gestreamt werden sollen (z.B. `["agent1.content"]`)
+  - `async` (boolean): Asynchron ausführen (Standard: false)
 
-**Rückgabewert:** `Promise<WorkflowExecutionResult>`
+**Rückgabewert:** `Promise<WorkflowExecutionResult | AsyncExecutionResult>`
+
+Wenn `async: true`, wird sofort mit einer Task-ID zum Abfragen zurückgegeben. Andernfalls wird auf den Abschluss gewartet.
 
 ##### getWorkflowStatus()
 
@@ -128,32 +133,121 @@ if (isReady) {
 
 **Rückgabewert:** `Promise<boolean>`
 
-##### executeWorkflowSync()
+##### getJobStatus()
 
-<Callout type="info">
-  Derzeit ist diese Methode identisch mit `executeWorkflow()`, da alle Ausführungen synchron sind. Diese Methode wird für zukünftige Kompatibilität bereitgestellt, wenn asynchrone Ausführung hinzugefügt wird.
-</Callout>
-
-Einen Workflow ausführen (derzeit synchron, identisch mit `executeWorkflow()`).
+Den Status einer asynchronen Job-Ausführung abrufen.
 
 ```typescript
-const result = await client.executeWorkflowSync('workflow-id', {
-  input: { data: 'some input' },
-  timeout: 60000
+const status = await client.getJobStatus('task-id-from-async-execution');
+console.log('Status:', status.status); // 'queued', 'processing', 'completed', 'failed'
+if (status.status === 'completed') {
+  console.log('Output:', status.output);
+}
+```
+
+**Parameter:**
+- `taskId` (string): Die Task-ID, die von der asynchronen Ausführung zurückgegeben wurde
+
+**Rückgabewert:** `Promise<JobStatus>`
+
+**Antwortfelder:**
+- `success` (boolean): Ob die Anfrage erfolgreich war
+- `taskId` (string): Die Task-ID
+- `status` (string): Einer der Werte `'queued'`, `'processing'`, `'completed'`, `'failed'`, `'cancelled'`
+- `metadata` (object): Enthält `startedAt`, `completedAt` und `duration`
+- `output` (any, optional): Die Workflow-Ausgabe (wenn abgeschlossen)
+- `error` (any, optional): Fehlerdetails (wenn fehlgeschlagen)
+- `estimatedDuration` (number, optional): Geschätzte Dauer in Millisekunden (wenn in Bearbeitung/in der Warteschlange)
+
+##### executeWithRetry()
+
+Einen Workflow mit automatischer Wiederholung bei Rate-Limit-Fehlern unter Verwendung von exponentiellem Backoff ausführen.
+
+```typescript
+const result = await client.executeWithRetry('workflow-id', {
+  input: { message: 'Hello' },
+  timeout: 30000
+}, {
+  maxRetries: 3,           // Maximum number of retries
+  initialDelay: 1000,      // Initial delay in ms (1 second)
+  maxDelay: 30000,         // Maximum delay in ms (30 seconds)
+  backoffMultiplier: 2     // Exponential backoff multiplier
 });
 ```
 
 **Parameter:**
 - `workflowId` (string): Die ID des auszuführenden Workflows
-- `options` (ExecutionOptions, optional):
-  - `input` (any): Eingabedaten, die an den Workflow übergeben werden
-  - `timeout` (number): Timeout für die initiale Anfrage in Millisekunden
+- `options` (ExecutionOptions, optional): Gleich wie `executeWorkflow()`
+- `retryOptions` (RetryOptions, optional):
+  - `maxRetries` (number): Maximale Anzahl von Wiederholungen (Standard: 3)
+  - `initialDelay` (number): Anfängliche Verzögerung in ms (Standard: 1000)
+  - `maxDelay` (number): Maximale Verzögerung in ms (Standard: 30000)
+  - `backoffMultiplier` (number): Backoff-Multiplikator (Standard: 2)
 
-**Rückgabewert:** `Promise<WorkflowExecutionResult>`
+**Rückgabe:** `Promise<WorkflowExecutionResult | AsyncExecutionResult>`
+
+Die Wiederholungslogik verwendet exponentielles Backoff (1s → 2s → 4s → 8s...) mit ±25% Jitter, um den Thundering-Herd-Effekt zu vermeiden. Wenn die API einen `retry-after` Header bereitstellt, wird dieser stattdessen verwendet.
+
+##### getRateLimitInfo()
+
+Ruft die aktuellen Rate-Limit-Informationen aus der letzten API-Antwort ab.
+
+```typescript
+const rateLimitInfo = client.getRateLimitInfo();
+if (rateLimitInfo) {
+  console.log('Limit:', rateLimitInfo.limit);
+  console.log('Remaining:', rateLimitInfo.remaining);
+  console.log('Reset:', new Date(rateLimitInfo.reset * 1000));
+}
+```
+
+**Rückgabe:** `RateLimitInfo | null`
+
+##### getUsageLimits()
+
+Ruft aktuelle Nutzungslimits und Kontingentinformationen für Ihr Konto ab.
+
+```typescript
+const limits = await client.getUsageLimits();
+console.log('Sync requests remaining:', limits.rateLimit.sync.remaining);
+console.log('Async requests remaining:', limits.rateLimit.async.remaining);
+console.log('Current period cost:', limits.usage.currentPeriodCost);
+console.log('Plan:', limits.usage.plan);
+```
+
+**Rückgabe:** `Promise<UsageLimits>`
+
+**Antwortstruktur:**
+
+```typescript
+{
+  success: boolean
+  rateLimit: {
+    sync: {
+      isLimited: boolean
+      limit: number
+      remaining: number
+      resetAt: string
+    }
+    async: {
+      isLimited: boolean
+      limit: number
+      remaining: number
+      resetAt: string
+    }
+    authType: string  // 'api' or 'manual'
+  }
+  usage: {
+    currentPeriodCost: number
+    limit: number
+    plan: string  // e.g., 'free', 'pro'
+  }
+}
+```
 
 ##### setApiKey()
 
-Den API-Schlüssel aktualisieren.
+Aktualisiert den API-Schlüssel.
 
 ```typescript
 client.setApiKey('new-api-key');
@@ -161,7 +255,7 @@ client.setApiKey('new-api-key');
 
 ##### setBaseUrl()
 
-Die Basis-URL aktualisieren.
+Aktualisiert die Basis-URL.
 
 ```typescript
 client.setBaseUrl('https://my-custom-domain.com');
@@ -187,17 +281,69 @@ interface WorkflowExecutionResult {
 }
 ```
 
+### AsyncExecutionResult
+
+```typescript
+interface AsyncExecutionResult {
+  success: boolean;
+  taskId: string;
+  status: 'queued';
+  createdAt: string;
+  links: {
+    status: string;  // e.g., "/api/jobs/{taskId}"
+  };
+}
+```
+
 ### WorkflowStatus
 
 ```typescript
 interface WorkflowStatus {
   isDeployed: boolean;
   deployedAt?: string;
-  isPublished: boolean;
   needsRedeployment: boolean;
 }
 ```
 
+### RateLimitInfo
+
+```typescript
+interface RateLimitInfo {
+  limit: number;
+  remaining: number;
+  reset: number;
+  retryAfter?: number;
+}
+```
+
+### UsageLimits
+
+```typescript
+interface UsageLimits {
+  success: boolean;
+  rateLimit: {
+    sync: {
+      isLimited: boolean;
+      limit: number;
+      remaining: number;
+      resetAt: string;
+    };
+    async: {
+      isLimited: boolean;
+      limit: number;
+      remaining: number;
+      resetAt: string;
+    };
+    authType: string;
+  };
+  usage: {
+    currentPeriodCost: number;
+    limit: number;
+    plan: string;
+  };
+}
+```
+
 ### SimStudioError
 
 ```typescript
@@ -207,6 +353,13 @@ class SimStudioError extends Error {
 }
 ```
 
+**Häufige Fehlercodes:**
+- `UNAUTHORIZED`: Ungültiger API-Schlüssel
+- `TIMEOUT`: Zeitüberschreitung der Anfrage
+- `RATE_LIMIT_EXCEEDED`: Rate-Limit überschritten
+- `USAGE_LIMIT_EXCEEDED`: Nutzungslimit überschritten
+- `EXECUTION_ERROR`: Workflow-Ausführung fehlgeschlagen
+
 ## Beispiele
 
 ### Grundlegende Workflow-Ausführung
@@ -230,7 +383,7 @@ class SimStudioError extends Error {
 import { SimStudioClient } from 'simstudio-ts-sdk';
 
 const client = new SimStudioClient({
-  apiKey: process.env.SIMSTUDIO_API_KEY!
+  apiKey: process.env.SIM_API_KEY!
 });
 
 async function runWorkflow() {
@@ -271,7 +424,7 @@ Behandeln Sie verschiedene Fehlertypen, die während der Workflow-Ausführung au
 import { SimStudioClient, SimStudioError } from 'simstudio-ts-sdk';
 
 const client = new SimStudioClient({
-  apiKey: process.env.SIMSTUDIO_API_KEY!
+  apiKey: process.env.SIM_API_KEY!
 });
 
 async function executeWithErrorHandling() {
@@ -315,14 +468,14 @@ Konfigurieren Sie den Client mit Umgebungsvariablen:
     import { SimStudioClient } from 'simstudio-ts-sdk';
 
     // Development configuration
-    const apiKey = process.env.SIMSTUDIO_API_KEY;
+    const apiKey = process.env.SIM_API_KEY;
     if (!apiKey) {
-      throw new Error('SIMSTUDIO_API_KEY environment variable is required');
+      throw new Error('SIM_API_KEY environment variable is required');
     }
 
     const client = new SimStudioClient({
       apiKey,
-      baseUrl: process.env.SIMSTUDIO_BASE_URL // optional
+      baseUrl: process.env.SIM_BASE_URL // optional
     });
     ```
 
@@ -333,14 +486,14 @@ Konfigurieren Sie den Client mit Umgebungsvariablen:
     import { SimStudioClient } from 'simstudio-ts-sdk';
 
     // Production configuration with validation
-    const apiKey = process.env.SIMSTUDIO_API_KEY;
+    const apiKey = process.env.SIM_API_KEY;
     if (!apiKey) {
-      throw new Error('SIMSTUDIO_API_KEY environment variable is required');
+      throw new Error('SIM_API_KEY environment variable is required');
     }
 
     const client = new SimStudioClient({
       apiKey,
-      baseUrl: process.env.SIMSTUDIO_BASE_URL || 'https://sim.ai'
+      baseUrl: process.env.SIM_BASE_URL || 'https://sim.ai'
     });
     ```
 
@@ -357,7 +510,7 @@ import { SimStudioClient } from 'simstudio-ts-sdk';
 
 const app = express();
 const client = new SimStudioClient({
-  apiKey: process.env.SIMSTUDIO_API_KEY!
+  apiKey: process.env.SIM_API_KEY!
 });
 
 app.use(express.json());
@@ -399,7 +552,7 @@ import { NextApiRequest, NextApiResponse } from 'next';
 import { SimStudioClient } from 'simstudio-ts-sdk';
 
 const client = new SimStudioClient({
-  apiKey: process.env.SIMSTUDIO_API_KEY!
+  apiKey: process.env.SIM_API_KEY!
 });
 
 export default async function handler(
@@ -450,33 +603,112 @@ async function executeClientSideWorkflow() {
     });
 
     console.log('Workflow result:', result);
-    
+
     // Update UI with result
-    document.getElementById('result')!.textContent = 
+    document.getElementById('result')!.textContent =
       JSON.stringify(result.output, null, 2);
   } catch (error) {
     console.error('Error:', error);
   }
 }
-
-// Attach to button click
-document.getElementById('executeBtn')?.addEventListener('click', executeClientSideWorkflow);
 ```
 
+### Datei-Upload
+
+Datei-Objekte werden automatisch erkannt und in das Base64-Format konvertiert. Fügen Sie sie in Ihrem Input unter dem Feldnamen ein, der dem API-Trigger-Inputformat Ihres Workflows entspricht.
+
+Das SDK konvertiert Datei-Objekte in dieses Format:
+
+```typescript
+{
+  type: 'file',
+  data: 'data:mime/type;base64,base64data',
+  name: 'filename',
+  mime: 'mime/type'
+}
+```
+
+Alternativ können Sie Dateien manuell im URL-Format bereitstellen:
+
+```typescript
+{
+  type: 'url',
+  data: 'https://example.com/file.pdf',
+  name: 'file.pdf',
+  mime: 'application/pdf'
+}
+```
+
+<Tabs items={['Browser', 'Node.js']}>
+  <Tab value="Browser">
+
+    ```typescript
+    import { SimStudioClient } from 'simstudio-ts-sdk';
+
+    const client = new SimStudioClient({
+      apiKey: process.env.NEXT_PUBLIC_SIM_API_KEY!
+    });
+
+    // From file input
+    async function handleFileUpload(event: Event) {
+      const input = event.target as HTMLInputElement;
+      const files = Array.from(input.files || []);
+
+      // Include files under the field name from your API trigger's input format
+      const result = await client.executeWorkflow('workflow-id', {
+        input: {
+          documents: files,  // Must match your workflow's "files" field name
+          instructions: 'Analyze these documents'
+        }
+      });
+
+      console.log('Result:', result);
+    }
+    ```
+
+  </Tab>
+  <Tab value="Node.js">
+
+    ```typescript
+    import { SimStudioClient } from 'simstudio-ts-sdk';
+    import fs from 'fs';
+
+    const client = new SimStudioClient({
+      apiKey: process.env.SIM_API_KEY!
+    });
+
+    // Read file and create File object
+    const fileBuffer = fs.readFileSync('./document.pdf');
+    const file = new File([fileBuffer], 'document.pdf', {
+      type: 'application/pdf'
+    });
+
+    // Include files under the field name from your API trigger's input format
+    const result = await client.executeWorkflow('workflow-id', {
+      input: {
+        documents: [file],  // Must match your workflow's "files" field name
+        query: 'Summarize this document'
+      }
+    });
+    ```
+
+  </Tab>
+</Tabs>
+
 <Callout type="warning">
   Bei der Verwendung des SDK im Browser sollten Sie darauf achten, keine sensiblen API-Schlüssel offenzulegen. Erwägen Sie die Verwendung eines Backend-Proxys oder öffentlicher API-Schlüssel mit eingeschränkten Berechtigungen.
 </Callout>
 
 ### React Hook Beispiel
 
-Erstellen Sie einen benutzerdefinierten React Hook für die Workflow-Ausführung:
+Erstellen Sie einen benutzerdefinierten React-Hook für die Workflow-Ausführung:
 
 ```typescript
 import { useState, useCallback } from 'react';
 import { SimStudioClient, WorkflowExecutionResult } from 'simstudio-ts-sdk';
 
 const client = new SimStudioClient({
-  apiKey: process.env.NEXT_PUBLIC_SIMSTUDIO_API_KEY!
+  apiKey: process.env.SIM_API_KEY!
 });
 
 interface UseWorkflowResult {
@@ -532,7 +764,7 @@ function WorkflowComponent() {
       <button onClick={handleExecute} disabled={loading}>
         {loading ? 'Executing...' : 'Execute Workflow'}
       </button>
-      
+
       {error && <div>Error: {error.message}</div>}
       {result && (
         <div>
@@ -545,7 +777,252 @@ function WorkflowComponent() {
 }
 ```
 
-## Ihren API-Schlüssel erhalten
+### Asynchrone Workflow-Ausführung
+
+Führen Sie Workflows asynchron für lang laufende Aufgaben aus:
+
+```typescript
+import { SimStudioClient, AsyncExecutionResult } from 'simstudio-ts-sdk';
+
+const client = new SimStudioClient({
+  apiKey: process.env.SIM_API_KEY!
+});
+
+async function executeAsync() {
+  try {
+    // Start async execution
+    const result = await client.executeWorkflow('workflow-id', {
+      input: { data: 'large dataset' },
+      async: true  // Execute asynchronously
+    });
+
+    // Check if result is an async execution
+    if ('taskId' in result) {
+      console.log('Task ID:', result.taskId);
+      console.log('Status endpoint:', result.links.status);
+
+      // Poll for completion
+      let status = await client.getJobStatus(result.taskId);
+
+      while (status.status === 'queued' || status.status === 'processing') {
+        console.log('Current status:', status.status);
+        await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds
+        status = await client.getJobStatus(result.taskId);
+      }
+
+      if (status.status === 'completed') {
+        console.log('Workflow completed!');
+        console.log('Output:', status.output);
+        console.log('Duration:', status.metadata.duration);
+      } else {
+        console.error('Workflow failed:', status.error);
+      }
+    }
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+executeAsync();
+```
+
+### Rate-Limiting und Wiederholungsversuche
+
+Automatische Behandlung von Rate-Limits mit exponentiellem Backoff:
+
+```typescript
+import { SimStudioClient, SimStudioError } from 'simstudio-ts-sdk';
+
+const client = new SimStudioClient({
+  apiKey: process.env.SIM_API_KEY!
+});
+
+async function executeWithRetryHandling() {
+  try {
+    // Automatically retries on rate limit
+    const result = await client.executeWithRetry('workflow-id', {
+      input: { message: 'Process this' }
+    }, {
+      maxRetries: 5,
+      initialDelay: 1000,
+      maxDelay: 60000,
+      backoffMultiplier: 2
+    });
+
+    console.log('Success:', result);
+  } catch (error) {
+    if (error instanceof SimStudioError && error.code === 'RATE_LIMIT_EXCEEDED') {
+      console.error('Rate limit exceeded after all retries');
+
+      // Check rate limit info
+      const rateLimitInfo = client.getRateLimitInfo();
+      if (rateLimitInfo) {
+        console.log('Rate limit resets at:', new Date(rateLimitInfo.reset * 1000));
+      }
+    }
+  }
+}
+```
+
+### Nutzungsüberwachung
+
+Überwachen Sie Ihre Kontonutzung und -limits:
+
+```typescript
+import { SimStudioClient } from 'simstudio-ts-sdk';
+
+const client = new SimStudioClient({
+  apiKey: process.env.SIM_API_KEY!
+});
+
+async function checkUsage() {
+  try {
+    const limits = await client.getUsageLimits();
+
+    console.log('=== Rate Limits ===');
+    console.log('Sync requests:');
+    console.log('  Limit:', limits.rateLimit.sync.limit);
+    console.log('  Remaining:', limits.rateLimit.sync.remaining);
+    console.log('  Resets at:', limits.rateLimit.sync.resetAt);
+    console.log('  Is limited:', limits.rateLimit.sync.isLimited);
+
+    console.log('\nAsync requests:');
+    console.log('  Limit:', limits.rateLimit.async.limit);
+    console.log('  Remaining:', limits.rateLimit.async.remaining);
+    console.log('  Resets at:', limits.rateLimit.async.resetAt);
+    console.log('  Is limited:', limits.rateLimit.async.isLimited);
+
+    console.log('\n=== Usage ===');
+    console.log('Current period cost: $' + limits.usage.currentPeriodCost.toFixed(2));
+    console.log('Limit: $' + limits.usage.limit.toFixed(2));
+    console.log('Plan:', limits.usage.plan);
+
+    const percentUsed = (limits.usage.currentPeriodCost / limits.usage.limit) * 100;
+    console.log('Usage: ' + percentUsed.toFixed(1) + '%');
+
+    if (percentUsed > 80) {
+      console.warn('⚠️  Warning: You are approaching your usage limit!');
+    }
+  } catch (error) {
+    console.error('Error checking usage:', error);
+  }
+}
+
+checkUsage();
+```
+
+### Streaming-Workflow-Ausführung
+
+Führen Sie Workflows mit Echtzeit-Streaming-Antworten aus:
+
+```typescript
+import { SimStudioClient } from 'simstudio-ts-sdk';
+
+const client = new SimStudioClient({
+  apiKey: process.env.SIM_API_KEY!
+});
+
+async function executeWithStreaming() {
+  try {
+    // Enable streaming for specific block outputs
+    const result = await client.executeWorkflow('workflow-id', {
+      input: { message: 'Count to five' },
+      stream: true,
+      selectedOutputs: ['agent1.content'] // Use blockName.attribute format
+    });
+
+    console.log('Workflow result:', result);
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+```
+
+Die Streaming-Antwort folgt dem Server-Sent Events (SSE) Format:
+
+```
+data: {"blockId":"7b7735b9-19e5-4bd6-818b-46aae2596e9f","chunk":"One"}
+
+data: {"blockId":"7b7735b9-19e5-4bd6-818b-46aae2596e9f","chunk":", two"}
+
+data: {"event":"done","success":true,"output":{},"metadata":{"duration":610}}
+
+data: [DONE]
+```
+
+**React Streaming Beispiel:**
+
+```typescript
+import { useState, useEffect } from 'react';
+
+function StreamingWorkflow() {
+  const [output, setOutput] = useState('');
+  const [loading, setLoading] = useState(false);
+
+  const executeStreaming = async () => {
+    setLoading(true);
+    setOutput('');
+
+    // IMPORTANT: Make this API call from your backend server, not the browser
+    // Never expose your API key in client-side code
+    const response = await fetch('https://sim.ai/api/workflows/WORKFLOW_ID/execute', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': process.env.SIM_API_KEY! // Server-side environment variable only
+      },
+      body: JSON.stringify({
+        message: 'Generate a story',
+        stream: true,
+        selectedOutputs: ['agent1.content']
+      })
+    });
+
+    const reader = response.body?.getReader();
+    const decoder = new TextDecoder();
+
+    while (reader) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value);
+      const lines = chunk.split('\n\n');
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = line.slice(6);
+          if (data === '[DONE]') {
+            setLoading(false);
+            break;
+          }
+
+          try {
+            const parsed = JSON.parse(data);
+            if (parsed.chunk) {
+              setOutput(prev => prev + parsed.chunk);
+            } else if (parsed.event === 'done') {
+              console.log('Execution complete:', parsed.metadata);
+            }
+          } catch (e) {
+            // Skip invalid JSON
+          }
+        }
+      }
+    }
+  };
+
+  return (
+    <div>
+      <button onClick={executeStreaming} disabled={loading}>
+        {loading ? 'Generating...' : 'Start Streaming'}
+      </button>
+      <div style={{ whiteSpace: 'pre-wrap' }}>{output}</div>
+    </div>
+  );
+}
+```
+
+## API-Schlüssel erhalten
 
 <Steps>
   <Step title="Bei Sim anmelden">
@@ -557,51 +1034,19 @@ function WorkflowComponent() {
   <Step title="Deployen Sie Ihren Workflow">
     Klicken Sie auf "Deploy", um Ihren Workflow zu deployen, falls dies noch nicht geschehen ist.
   </Step>
-  <Step title="Erstellen oder wählen Sie einen API-Schlüssel">
+  <Step title="API-Schlüssel erstellen oder auswählen">
     Wählen Sie während des Deployment-Prozesses einen API-Schlüssel aus oder erstellen Sie einen neuen.
   </Step>
-  <Step title="Kopieren Sie den API-Schlüssel">
+  <Step title="API-Schlüssel kopieren">
     Kopieren Sie den API-Schlüssel zur Verwendung in Ihrer TypeScript/JavaScript-Anwendung.
   </Step>
 </Steps>
 
-<Callout type="warning">
-  Halten Sie Ihren API-Schlüssel sicher und committen Sie ihn niemals in die Versionskontrolle. Verwenden Sie Umgebungsvariablen oder sicheres Konfigurationsmanagement.
-</Callout>
-
 ## Anforderungen
 
 - Node.js 16+
 - TypeScript 5.0+ (für TypeScript-Projekte)
 
-## TypeScript-Unterstützung
-
-Das SDK ist in TypeScript geschrieben und bietet vollständige Typsicherheit:
-
-```typescript
-import { 
-  SimStudioClient, 
-  WorkflowExecutionResult, 
-  WorkflowStatus,
-  SimStudioError 
-} from 'simstudio-ts-sdk';
-
-// Type-safe client initialization
-const client: SimStudioClient = new SimStudioClient({
-  apiKey: process.env.SIMSTUDIO_API_KEY!
-});
-
-// Type-safe workflow execution
-const result: WorkflowExecutionResult = await client.executeWorkflow('workflow-id', {
-  input: {
-    message: 'Hello, TypeScript!'
-  }
-});
-
-// Type-safe status checking
-const status: WorkflowStatus = await client.getWorkflowStatus('workflow-id');
-```
-
 ## Lizenz
 
 Apache-2.0

apps/docs/content/docs/de/self-hosting/docker.mdx

@@ -0,0 +1,155 @@
+---
+title: Docker
+description: Sim Studio mit Docker Compose bereitstellen
+---
+
+import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
+import { Callout } from 'fumadocs-ui/components/callout'
+
+## Schnellstart
+
+```bash
+# Clone and start
+git clone https://github.com/simstudioai/sim.git && cd sim
+docker compose -f docker-compose.prod.yml up -d
+```
+
+Öffnen Sie [http://localhost:3000](http://localhost:3000)
+
+## Produktionseinrichtung
+
+### 1. Umgebung konfigurieren
+
+```bash
+# Generate secrets
+cat > .env << EOF
+DATABASE_URL=postgresql://postgres:postgres@db:5432/simstudio
+BETTER_AUTH_SECRET=$(openssl rand -hex 32)
+ENCRYPTION_KEY=$(openssl rand -hex 32)
+INTERNAL_API_SECRET=$(openssl rand -hex 32)
+NEXT_PUBLIC_APP_URL=https://sim.yourdomain.com
+BETTER_AUTH_URL=https://sim.yourdomain.com
+NEXT_PUBLIC_SOCKET_URL=https://sim.yourdomain.com
+EOF
+```
+
+### 2. Dienste starten
+
+```bash
+docker compose -f docker-compose.prod.yml up -d
+```
+
+### 3. SSL einrichten
+
+<Tabs items={['Caddy (Empfohlen)', 'Nginx + Certbot']}>
+  <Tab value="Caddy (Empfohlen)">
+Caddy verwaltet SSL-Zertifikate automatisch.
+
+```bash
+# Install Caddy
+sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
+curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
+curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
+sudo apt update && sudo apt install caddy
+```
+
+Erstellen Sie `/etc/caddy/Caddyfile`:
+
+```
+sim.yourdomain.com {
+    reverse_proxy localhost:3000
+
+    handle /socket.io/* {
+        reverse_proxy localhost:3002
+    }
+}
+```
+
+```bash
+sudo systemctl restart caddy
+```
+
+  </Tab>
+  <Tab value="Nginx + Certbot">
+
+```bash
+# Install
+sudo apt install nginx certbot python3-certbot-nginx -y
+
+# Create /etc/nginx/sites-available/sim
+server {
+    listen 80;
+    server_name sim.yourdomain.com;
+
+    location / {
+        proxy_pass http://127.0.0.1:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location /socket.io/ {
+        proxy_pass http://127.0.0.1:3002;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+    }
+}
+
+# Enable and get certificate
+sudo ln -s /etc/nginx/sites-available/sim /etc/nginx/sites-enabled/
+sudo certbot --nginx -d sim.yourdomain.com
+```
+
+  </Tab>
+</Tabs>
+
+## Ollama
+
+```bash
+# With GPU
+docker compose -f docker-compose.ollama.yml --profile gpu --profile setup up -d
+
+# CPU only
+docker compose -f docker-compose.ollama.yml --profile cpu --profile setup up -d
+```
+
+Zusätzliche Modelle herunterladen:
+
+```bash
+docker compose -f docker-compose.ollama.yml exec ollama ollama pull llama3.2
+```
+
+### Externes Ollama
+
+Wenn Ollama auf Ihrem Host-Rechner läuft (nicht in Docker):
+
+```bash
+# macOS/Windows
+OLLAMA_URL=http://host.docker.internal:11434 docker compose -f docker-compose.prod.yml up -d
+
+# Linux - use your host IP
+OLLAMA_URL=http://192.168.1.100:11434 docker compose -f docker-compose.prod.yml up -d
+```
+
+<Callout type="warning">
+  Innerhalb von Docker bezieht sich `localhost` auf den Container, nicht auf Ihren Host. Verwenden Sie `host.docker.internal` oder die IP-Adresse Ihres Hosts.
+</Callout>
+
+## Befehle
+
+```bash
+# View logs
+docker compose -f docker-compose.prod.yml logs -f simstudio
+
+# Stop
+docker compose -f docker-compose.prod.yml down
+
+# Update
+docker compose -f docker-compose.prod.yml pull && docker compose -f docker-compose.prod.yml up -d
+
+# Backup database
+docker compose -f docker-compose.prod.yml exec db pg_dump -U postgres simstudio > backup.sql
+```

apps/docs/content/docs/de/self-hosting/environment-variables.mdx

@@ -0,0 +1,87 @@
+---
+title: Umgebungsvariablen
+description: Konfigurationsreferenz für Sim Studio
+---
+
+import { Callout } from 'fumadocs-ui/components/callout'
+
+## Erforderlich
+
+| Variable | Beschreibung |
+|----------|-------------|
+| `DATABASE_URL` | PostgreSQL-Verbindungszeichenfolge |
+| `BETTER_AUTH_SECRET` | Auth-Secret (32 Hex-Zeichen): `openssl rand -hex 32` |
+| `BETTER_AUTH_URL` | Ihre App-URL |
+| `ENCRYPTION_KEY` | Verschlüsselungsschlüssel (32 Hex-Zeichen): `openssl rand -hex 32` |
+| `INTERNAL_API_SECRET` | Internes API-Secret (32 Hex-Zeichen): `openssl rand -hex 32` |
+| `NEXT_PUBLIC_APP_URL` | Öffentliche App-URL |
+| `NEXT_PUBLIC_SOCKET_URL` | WebSocket-URL (Standard: `http://localhost:3002`) |
+
+## KI-Anbieter
+
+| Variable | Anbieter |
+|----------|----------|
+| `OPENAI_API_KEY` | OpenAI |
+| `ANTHROPIC_API_KEY_1` | Anthropic Claude |
+| `GEMINI_API_KEY_1` | Google Gemini |
+| `MISTRAL_API_KEY` | Mistral |
+| `OLLAMA_URL` | Ollama (Standard: `http://localhost:11434`) |
+
+<Callout type="info">
+  Für Lastausgleich fügen Sie mehrere Schlüssel mit den Suffixen `_1`, `_2`, `_3` hinzu (z.B. `OPENAI_API_KEY_1`, `OPENAI_API_KEY_2`). Funktioniert mit OpenAI, Anthropic und Gemini.
+</Callout>
+
+<Callout type="info">
+  In Docker verwenden Sie `OLLAMA_URL=http://host.docker.internal:11434` für Ollama auf dem Host-System.
+</Callout>
+
+### Azure OpenAI
+
+| Variable | Beschreibung |
+|----------|-------------|
+| `AZURE_OPENAI_API_KEY` | Azure OpenAI API-Schlüssel |
+| `AZURE_OPENAI_ENDPOINT` | Azure OpenAI Endpoint-URL |
+| `AZURE_OPENAI_API_VERSION` | API-Version (z.B. `2024-02-15-preview`) |
+
+### vLLM (Selbst-gehostet)
+
+| Variable | Beschreibung |
+|----------|-------------|
+| `VLLM_BASE_URL` | vLLM-Server-URL (z.B. `http://localhost:8000/v1`) |
+| `VLLM_API_KEY` | Optionaler Bearer-Token für vLLM |
+
+## OAuth-Anbieter
+
+| Variable | Beschreibung |
+|----------|-------------|
+| `GOOGLE_CLIENT_ID` | Google OAuth Client-ID |
+| `GOOGLE_CLIENT_SECRET` | Google OAuth Client-Secret |
+| `GITHUB_CLIENT_ID` | GitHub OAuth Client-ID |
+| `GITHUB_CLIENT_SECRET` | GitHub OAuth Client-Secret |
+
+## Optional
+
+| Variable | Beschreibung |
+|----------|-------------|
+| `API_ENCRYPTION_KEY` | Verschlüsselt gespeicherte API-Schlüssel (32 Hex-Zeichen): `openssl rand -hex 32` |
+| `COPILOT_API_KEY` | API-Schlüssel für Copilot-Funktionen |
+| `ADMIN_API_KEY` | Admin-API-Schlüssel für GitOps-Operationen |
+| `RESEND_API_KEY` | E-Mail-Dienst für Benachrichtigungen |
+| `ALLOWED_LOGIN_DOMAINS` | Registrierungen auf Domains beschränken (durch Kommas getrennt) |
+| `ALLOWED_LOGIN_EMAILS` | Registrierungen auf bestimmte E-Mails beschränken (durch Kommas getrennt) |
+| `DISABLE_REGISTRATION` | Auf `true` setzen, um neue Benutzerregistrierungen zu deaktivieren |
+
+## Beispiel .env
+
+```bash
+DATABASE_URL=postgresql://postgres:postgres@db:5432/simstudio
+BETTER_AUTH_SECRET=<openssl rand -hex 32>
+BETTER_AUTH_URL=https://sim.yourdomain.com
+ENCRYPTION_KEY=<openssl rand -hex 32>
+INTERNAL_API_SECRET=<openssl rand -hex 32>
+NEXT_PUBLIC_APP_URL=https://sim.yourdomain.com
+NEXT_PUBLIC_SOCKET_URL=https://sim.yourdomain.com
+OPENAI_API_KEY=sk-...
+```
+
+Siehe `apps/sim/.env.example` für alle Optionen.

apps/docs/content/docs/de/self-hosting/index.mdx

@@ -0,0 +1,50 @@
+---
+title: Self-Hosting
+description: Stellen Sie Sim Studio auf Ihrer eigenen Infrastruktur bereit
+---
+
+import { Card, Cards } from 'fumadocs-ui/components/card'
+import { Callout } from 'fumadocs-ui/components/callout'
+
+Stellen Sie Sim Studio auf Ihrer eigenen Infrastruktur mit Docker oder Kubernetes bereit.
+
+## Anforderungen
+
+| Ressource | Minimum | Empfohlen |
+|----------|---------|-------------|
+| CPU | 2 Kerne | 4+ Kerne |
+| RAM | 12 GB | 16+ GB |
+| Speicher | 20 GB SSD | 50+ GB SSD |
+| Docker | 20.10+ | Neueste Version |
+
+## Schnellstart
+
+```bash
+git clone https://github.com/simstudioai/sim.git && cd sim
+docker compose -f docker-compose.prod.yml up -d
+```
+
+Öffnen Sie [http://localhost:3000](http://localhost:3000)
+
+## Bereitstellungsoptionen
+
+<Cards>
+  <Card title="Docker" href="/self-hosting/docker">
+    Bereitstellung mit Docker Compose auf jedem Server
+  </Card>
+  <Card title="Kubernetes" href="/self-hosting/kubernetes">
+    Bereitstellung mit Helm auf Kubernetes-Clustern
+  </Card>
+  <Card title="Cloud-Plattformen" href="/self-hosting/platforms">
+    Anleitungen für Railway, DigitalOcean, AWS, Azure, GCP
+  </Card>
+</Cards>
+
+## Architektur
+
+| Komponente | Port | Beschreibung |
+|-----------|------|-------------|
+| simstudio | 3000 | Hauptanwendung |
+| realtime | 3002 | WebSocket-Server |
+| db | 5432 | PostgreSQL mit pgvector |
+| migrations | - | Datenbank-Migrationen (werden einmal ausgeführt) |

apps/docs/content/docs/de/self-hosting/kubernetes.mdx

@@ -0,0 +1,133 @@
+---
+title: Kubernetes
+description: Sim Studio mit Helm bereitstellen
+---
+
+import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
+import { Callout } from 'fumadocs-ui/components/callout'
+
+## Voraussetzungen
+
+- Kubernetes 1.19+
+- Helm 3.0+
+- PV-Provisioner-Unterstützung
+
+## Installation
+
+```bash
+# Clone repo
+git clone https://github.com/simstudioai/sim.git && cd sim
+
+# Generate secrets
+BETTER_AUTH_SECRET=$(openssl rand -hex 32)
+ENCRYPTION_KEY=$(openssl rand -hex 32)
+INTERNAL_API_SECRET=$(openssl rand -hex 32)
+
+# Install
+helm install sim ./helm/sim \
+  --set app.env.BETTER_AUTH_SECRET="$BETTER_AUTH_SECRET" \
+  --set app.env.ENCRYPTION_KEY="$ENCRYPTION_KEY" \
+  --set app.env.INTERNAL_API_SECRET="$INTERNAL_API_SECRET" \
+  --namespace simstudio --create-namespace
+```
+
+## Cloud-spezifische Werte
+
+<Tabs items={['AWS EKS', 'Azure AKS', 'GCP GKE']}>
+  <Tab value="AWS EKS">
+
+```bash
+helm install sim ./helm/sim \
+  --values ./helm/sim/examples/values-aws.yaml \
+  --set app.env.BETTER_AUTH_SECRET="$BETTER_AUTH_SECRET" \
+  --set app.env.ENCRYPTION_KEY="$ENCRYPTION_KEY" \
+  --set app.env.INTERNAL_API_SECRET="$INTERNAL_API_SECRET" \
+  --set app.env.NEXT_PUBLIC_APP_URL="https://sim.yourdomain.com" \
+  --namespace simstudio --create-namespace
+```
+
+  </Tab>
+  <Tab value="Azure AKS">
+
+```bash
+helm install sim ./helm/sim \
+  --values ./helm/sim/examples/values-azure.yaml \
+  --set app.env.BETTER_AUTH_SECRET="$BETTER_AUTH_SECRET" \
+  --set app.env.ENCRYPTION_KEY="$ENCRYPTION_KEY" \
+  --set app.env.INTERNAL_API_SECRET="$INTERNAL_API_SECRET" \
+  --set app.env.NEXT_PUBLIC_APP_URL="https://sim.yourdomain.com" \
+  --namespace simstudio --create-namespace
+```
+
+  </Tab>
+  <Tab value="GCP GKE">
+
+```bash
+helm install sim ./helm/sim \
+  --values ./helm/sim/examples/values-gcp.yaml \
+  --set app.env.BETTER_AUTH_SECRET="$BETTER_AUTH_SECRET" \
+  --set app.env.ENCRYPTION_KEY="$ENCRYPTION_KEY" \
+  --set app.env.INTERNAL_API_SECRET="$INTERNAL_API_SECRET" \
+  --set app.env.NEXT_PUBLIC_APP_URL="https://sim.yourdomain.com" \
+  --namespace simstudio --create-namespace
+```
+
+  </Tab>
+</Tabs>
+
+## Schlüsselkonfiguration
+
+```yaml
+# Custom values.yaml
+app:
+  replicaCount: 2
+  env:
+    NEXT_PUBLIC_APP_URL: "https://sim.yourdomain.com"
+    OPENAI_API_KEY: "sk-..."
+
+postgresql:
+  persistence:
+    size: 50Gi
+
+ingress:
+  enabled: true
+  className: nginx
+  tls:
+    enabled: true
+  app:
+    host: sim.yourdomain.com
+```
+
+Siehe `helm/sim/values.yaml` für alle Optionen.
+
+## Externe Datenbank
+
+```yaml
+postgresql:
+  enabled: false
+
+externalDatabase:
+  enabled: true
+  host: "your-db-host"
+  port: 5432
+  username: "postgres"
+  password: "your-password"
+  database: "simstudio"
+  sslMode: "require"
+```
+
+## Befehle
+
+```bash
+# Port forward for local access
+kubectl port-forward deployment/sim-sim-app 3000:3000 -n simstudio
+
+# View logs
+kubectl logs -l app.kubernetes.io/component=app -n simstudio --tail=100
+
+# Upgrade
+helm upgrade sim ./helm/sim --namespace simstudio
+
+# Uninstall
+helm uninstall sim --namespace simstudio
+```

apps/docs/content/docs/de/self-hosting/platforms.mdx

@@ -0,0 +1,124 @@
+---
+title: Cloud-Plattformen
+description: Sim Studio auf Cloud-Plattformen bereitstellen
+---
+
+import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
+import { Callout } from 'fumadocs-ui/components/callout'
+
+## Railway
+
+Bereitstellung mit einem Klick und automatischer PostgreSQL-Bereitstellung.
+
+[
+
+![Auf Railway bereitstellen](https://railway.app/button.svg)
+
+](https://railway.com/new/template/sim-studio)
+
+Nach der Bereitstellung fügen Sie Umgebungsvariablen im Railway-Dashboard hinzu:
+- `BETTER_AUTH_SECRET`, `ENCRYPTION_KEY`, `INTERNAL_API_SECRET` (automatisch generiert)
+- `OPENAI_API_KEY` oder andere KI-Anbieter-Schlüssel
+- Benutzerdefinierte Domain in Einstellungen → Netzwerk
+
+## VPS-Bereitstellung
+
+Für DigitalOcean, AWS EC2, Azure VMs oder jeden Linux-Server:
+
+<Tabs items={['DigitalOcean', 'AWS EC2', 'Azure VM']}>
+  <Tab value="DigitalOcean">
+**Empfohlen:** 16 GB RAM Droplet, Ubuntu 24.04
+
+```bash
+# Create Droplet via console, then SSH in
+ssh root@your-droplet-ip
+```
+
+  </Tab>
+  <Tab value="AWS EC2">
+**Empfohlen:** t3.xlarge (16 GB RAM), Ubuntu 24.04
+
+```bash
+ssh -i your-key.pem ubuntu@your-ec2-ip
+```
+
+  </Tab>
+  <Tab value="Azure VM">
+**Empfohlen:** Standard_D4s_v3 (16 GB RAM), Ubuntu 24.04
+
+```bash
+ssh azureuser@your-vm-ip
+```
+
+  </Tab>
+</Tabs>
+
+### Docker installieren
+
+```bash
+# Install Docker (official method)
+curl -fsSL https://get.docker.com | sudo sh
+sudo usermod -aG docker $USER
+
+# Logout and reconnect, then verify
+docker --version
+```
+
+### Sim Studio bereitstellen
+
+```bash
+git clone https://github.com/simstudioai/sim.git && cd sim
+
+# Create .env with secrets
+cat > .env << EOF
+DATABASE_URL=postgresql://postgres:postgres@db:5432/simstudio
+BETTER_AUTH_SECRET=$(openssl rand -hex 32)
+ENCRYPTION_KEY=$(openssl rand -hex 32)
+INTERNAL_API_SECRET=$(openssl rand -hex 32)
+NEXT_PUBLIC_APP_URL=https://sim.yourdomain.com
+BETTER_AUTH_URL=https://sim.yourdomain.com
+NEXT_PUBLIC_SOCKET_URL=https://sim.yourdomain.com
+EOF
+
+# Start
+docker compose -f docker-compose.prod.yml up -d
+```
+
+### SSL mit Caddy
+
+```bash
+# Install Caddy
+sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
+curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
+curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
+sudo apt update && sudo apt install caddy
+
+# Configure (replace domain)
+echo 'sim.yourdomain.com {
+    reverse_proxy localhost:3000
+    handle /socket.io/* {
+        reverse_proxy localhost:3002
+    }
+}' | sudo tee /etc/caddy/Caddyfile
+
+sudo systemctl restart caddy
+```
+
+Richten Sie den DNS A-Eintrag Ihrer Domain auf die IP-Adresse Ihres Servers.
+
+## Kubernetes (EKS, AKS, GKE)
+
+Siehe den [Kubernetes-Leitfaden](/self-hosting/kubernetes) für Helm-Deployment auf verwaltetem Kubernetes.
+
+## Verwaltete Datenbank (Optional)
+
+Für den Produktivbetrieb sollten Sie einen verwalteten PostgreSQL-Dienst verwenden:
+
+- **AWS RDS** / **Azure Database** / **Cloud SQL** - Aktivieren Sie die pgvector-Erweiterung
+- **Supabase** / **Neon** - pgvector enthalten
+
+Setzen Sie `DATABASE_URL` in Ihrer Umgebung:
+
+```bash
+DATABASE_URL="postgresql://user:pass@host:5432/db?sslmode=require"
+```