</details>

<details>
<summary><b>Agenteninteraktion</b> (zum Erweitern klicken)</summary>```mermaid
sequenceDiagram
    participant O as Orchestrator
    participant R as Researcher
    participant D as Developer
    participant E as Executor
    participant VS as Vector Store
    participant KB as Knowledge Base

    Note over O,KB: Flow Initialization
    O->>VS: Query similar tasks
    VS-->>O: Return experiences
    O->>KB: Load relevant knowledge
    KB-->>O: Return context

    Note over O,R: Research Phase
    O->>R: Analyze target
    R->>VS: Search similar cases
    VS-->>R: Return patterns
    R->>KB: Query vulnerabilities
    KB-->>R: Return known issues
    R->>VS: Store findings
    R-->>O: Research results

    Note over O,D: Planning Phase
    O->>D: Plan attack
    D->>VS: Query exploits
    VS-->>D: Return techniques
    D->>KB: Load tools info
    KB-->>D: Return capabilities
    D-->>O: Attack plan

    Note over O,E: Execution Phase
    O->>E: Execute plan
    E->>KB: Load tool guides
    KB-->>E: Return procedures
    E->>VS: Store results
    E-->>O: Execution status

</details>

<a id="advanced-agent-supervision"></a>
<details>
<summary><b>Erweiterte Agentenüberwachung</b> (anklicken, um zu erweitern)</summary>

PentAGI enthält ausgeklügelte mehrschichtige Agentenüberwachungsmechanismen, um eine effiziente Aufgabenausführung sicherzustellen, Endlosschleifen zu verhindern und eine intelligente Wiederherstellung aus festgefahrenen Zuständen zu ermöglichen:

### Ausführungsüberwachung (Beta)
- **Automatisches Mentor-Eingreifen**: Beratungs-Agent (Mentor) wird automatisch aufgerufen, wenn Ausführungsmuster auf potenzielle Probleme hindeuten
- **Mustererkennung**: Überwacht identische Tool-Aufrufe (Grenzwert: 5, konfigurierbar) und gesamte Tool-Aufrufe (Grenzwert: 10, konfigurierbar)
- **Fortschrittsanalyse**: Bewertet, ob der Agent in Richtung Teilaufgabenziel voranschreitet, erkennt Schleifen und Ineffizienzen
- **Alternative Strategien**: Empfiehlt andere Ansätze, wenn die aktuelle Strategie fehlschlägt
- **Informationsbeschaffungshilfe**: Schlägt vor, nach bewährten Lösungen zu suchen, anstatt sie neu zu erfinden
- **Verbessertes Antwortformat**: Tool-Antworten enthalten sowohl `<original_result>` als auch `<mentor_analysis>`-Abschnitte
- **Konfigurierbar**: Aktivieren über `EXECUTION_MONITOR_ENABLED` (Standard: false), Grenzwerte anpassen mit `EXECUTION_MONITOR_SAME_TOOL_LIMIT` und `EXECUTION_MONITOR_TOTAL_TOOL_LIMIT`

**Am besten geeignet für**: Kleinere Modelle (< 32B Parameter), komplexe Angriffsszenarien, die kontinuierliche Anleitung erfordern, verhindert, dass Agenten auf einem einzigen Ansatz hängen bleiben

**Leistungsauswirkung**: 2-3x längere Ausführungszeit und Tokenverbrauch, aber liefert **2x Verbesserung der Ergebnisqualität** basierend auf Tests mit Qwen3.5-27B-FP8

### Intelligente Aufgabenplanung (Beta)
- **Automatische Zerlegung**: Planer (Berater im Planungsmodus) generiert 3-7 spezifische, handlungsorientierte Schritte, bevor Spezialisten-Agenten mit der Arbeit beginnen
- **Kontextbewusste Pläne**: Analysiert den vollständigen Ausführungskontext über den Anreicherungs-Agenten, um fundierte Pläne zu erstellen
- **Strukturierte Zuweisung**: Ursprüngliche Anfrage wird in `<task_assignment>`-Struktur mit Ausführungsplan und Anweisungen eingeschlossen
- **Umfangsmanagement**: Verhindert Umfangsausweitung, indem die Agenten auf die aktuelle Teilaufgabe fokussiert bleiben
- **Angereicherte Anweisungen**: Pläne heben kritische Aktionen, potenzielle Fallstricke und Überprüfungspunkte hervor
- **Konfigurierbar**: Aktivieren über `AGENT_PLANNING_STEP_ENABLED` (Standard: false)

**Am besten geeignet für**: Modelle < 32B Parameter, komplexe Penetrationstest-Workflows, Verbesserung der Erfolgsraten bei anspruchsvollen Aufgaben

**Erweiterte Beraterkonfiguration**: Funktioniert besonders gut, wenn der Berater-Agent ein stärkeres Modell oder erweiterte Einstellungen verwendet. Beispiel: Verwendung desselben Basismodells mit maximalem Reasoning-Modus für den Berater (siehe [`vllm-qwen3.5-27b-fp8.provider.yml`](https://github.com/vxcontrol/pentagi/blob/HEAD/examples/configs/vllm-qwen3.5-27b-fp8.provider.yml)) ermöglicht umfassende Aufgabenanalyse und strategische Planung von identischer Modellarchitektur.

**Leistungsauswirkung**: Fügt Planungs-Overhead hinzu, verbessert aber deutlich die Abschlussraten und reduziert redundante Arbeit

### Tool-Aufruf-Grenzen (immer aktiv)
- **Harte Grenzen**: Verhindern unkontrollierte Ausführungen unabhängig vom Überwachungsmodus
- **Nach Agententyp unterschieden**:
  - Allgemeine Agenten (Assistent, Primäragent, Pentester, Coder, Installer): `MAX_GENERAL_AGENT_TOOL_CALLS` (Standard: 100)
  - Eingeschränkte Agenten (Sucher, Anreicherer, Memorisierer, Generator, Reporter, Berater, Reflektor, Planer): `MAX_LIMITED_AGENT_TOOL_CALLS` (Standard: 20)
- **Sanfte Beendigung**: Reflektor führt Agenten bei Annäherung an die Grenzen zur ordnungsgemäßen Fertigstellung
- **Ressourcenschutz**: Stellt Systemstabilität sicher und verhindert Ressourcenerschöpfung

### Reflektor-Integration (immer aktiv)
- **Automatische Korrektur**: Wird aufgerufen, wenn das LLM nach 3 Versuchen keine Tool-Aufrufe generiert
- **Strategische Anleitung**: Analysiert Fehler und führt Agenten zur korrekten Tool-Nutzung oder zu Barriere-Tools (`done`, `ask`)
- **Wiederherstellungsmechanismus**: Bietet kontextbezogene Anleitung basierend auf spezifischen Fehlermustern
- **Grenzendurchsetzung**: Koordiniert die sanfte Beendigung, wenn Tool-Aufruf-Grenzen erreicht sind

### Empfehlungen für Open-Source-Modelle

**Muss-Have für Modelle < 32B Parameter**:
Tests mit Qwen3.5-27B-FP8 zeigen, dass die Aktivierung von Ausführungsüberwachung und Aufgabenplanung **unerlässlich** für kleinere Open-Source-Modelle ist:
- **Qualitätsverbesserung**: 2x bessere Ergebnisse im Vergleich zur Basisausführung ohne Überwachung
- **Schleifenvermeidung**: Reduziert Endlosschleifen und redundante Arbeit signifikant
- **Angriffsvielfalt**: Fördert die Erkundung mehrerer Angriffsvektoren anstatt Fixierung auf einen einzelnen Ansatz
- **Luftgesperrte Bereitstellungen**: Ermöglicht produktionsreife autonome Penetrationstests in geschlossenen Netzwerkumgebungen mit lokaler LLM-Inferenz

**Kompromisse**:
- Tokenverbrauch: 2-3x höher durch Mentor/Planer-Aufrufe
- Ausführungszeit: 2-3x länger durch Analyse- und Planungsschritte
- Ergebnisqualität: 2x Verbesserung in Vollständigkeit, Genauigkeit und Angriffsabdeckung
- Modellanforderungen: Funktioniert am besten, wenn der Berater eine erweiterte Konfiguration verwendet (höhere Reasoning-Parameter, stärkere Modellvariante oder anderes Modell)

**Konfigurationsstrategie**:
Für optimale Leistung mit kleineren Modellen den Berater-Agenten mit erweiterten Einstellungen konfigurieren:
- Gleiches Modell mit maximalem Reasoning-Modus verwenden (Beispiel: [`vllm-qwen3.5-27b-fp8.provider.yml`](https://github.com/vxcontrol/pentagi/blob/HEAD/examples/configs/vllm-qwen3.5-27b-fp8.provider.yml))
- Oder ein stärkeres Modell für den Berater verwenden, während das Basismodell für andere Agenten beibehalten wird
- Überwachungsschwellenwerte basierend auf Aufgabenkomplexität und Modellfähigkeiten anpassen



</details>

Die Architektur von PentAGI ist modular, skalierbar und sicher. Hier sind die Schlüsselkomponenten:

1. **Kerndienste**
   - Frontend-UI: React-basierte Weboberfläche mit TypeScript für Typsicherheit
   - Backend-API: Go-basierte REST- und GraphQL-APIs mit Bearer-Token-Authentifizierung für programmatischen Zugriff
   - Vektor-Speicher: PostgreSQL mit pgvector für semantische Suche und Speicher
   - Aufgabenwarteschlange: Async-Aufgabenverarbeitungssystem für zuverlässigen Betrieb
   - KI-Agent: Multi-Agenten-System mit spezialisierten Rollen für effizientes Testen

2. **Wissensgraph**
   - Graphiti: Wissensgraph-API für semantische Beziehungsverfolgung und kontextuelles Verständnis
   - Neo4j: Graphdatenbank zum Speichern und Abfragen von Beziehungen zwischen Entitäten, Aktionen und Ergebnissen
   - Automatische Erfassung von Agentenantworten und Tool-Ausführungen zum Aufbau einer umfassenden Wissensbasis

3. **Monitoring-Stack**
   - OpenTelemetry: Einheitliche Observability-Datenerfassung und -korrelation
   - Grafana: Echtzeit-Visualisierung und Alarmierungs-Dashboards
   - VictoriaMetrics: Hochleistungs-Zeitreihen-Metrikspeicher
   - Jaeger: End-to-End verteiltes Tracing zum Debuggen
   - Loki: Skalierbare Log-Aggregation und -Analyse

4. **Analyseplattform**
   - Langfuse: Erweiterte LLM-Observability und Leistungsanalyse
   - ClickHouse: Spaltenorientiertes Analyse-Datenlager
   - Redis: Hochgeschwindigkeits-Caching und Ratenbegrenzung
   - MinIO: S3-kompatibler Objektspeicher für Artefakte

5. **Sicherheitswerkzeuge**
   - Web Scraper: Isolierte Browser-Umgebung für sichere Web-Interaktion
   - Pentesting-Tools: Umfassende Suite von über 20 professionellen Sicherheitswerkzeugen
   - Sandbox-Ausführung: Alle Operationen laufen in isolierten Containern

6. **Gedächtnissysteme**
   - Langzeitgedächtnis: Dauerhafte Speicherung von Wissen und Erfahrungen
   - Arbeitsgedächtnis: Aktiver Kontext und Ziele für aktuelle Operationen
   - Episodisches Gedächtnis: Historische Aktionen und Erfolgsmuster
   - Wissensbasis: Strukturiertes Domain-Wissen und Tool-Fähigkeiten
   - Kontextmanagement: Intelligentes Management wachsender LLM-Kontextfenster mittels Kettenzusammenfassung

Das System verwendet Docker-Container für Isolation und einfache Bereitstellung, mit getrennten Netzwerken für Kerndienste, Monitoring und Analyse, um angemessene Sicherheitsgrenzen zu gewährleisten. Jede Komponente ist für horizontale Skalierung ausgelegt und kann für hohe Verfügbarkeit in Produktionsumgebungen konfiguriert werden.

## Schnellstart

### Systemanforderungen

- Docker und Docker Compose (oder Podman – siehe [Podman-Konfiguration](#running-pentagi-with-podman))
- Mindestens 2 vCPU
- Mindestens 4 GB RAM
- 20 GB freier Speicherplatz
- Internetzugang zum Herunterladen von Images und Updates

### Mit dem Installer (empfohlen)

PentAGI bietet einen interaktiven Installer mit einer terminalbasierten Benutzeroberfläche für optimierte Konfiguration und Bereitstellung. Der Installer führt Sie durch Systemprüfungen, LLM-Provider-Einrichtung, Suchmaschinenkonfiguration und Sicherheitshärtung.

**Unterstützte Plattformen:**
- **Linux**: amd64 [Download](https://pentagi.com/downloads/linux/amd64/installer-latest.zip) | arm64 [Download](https://pentagi.com/downloads/linux/arm64/installer-latest.zip)
- **Windows**: amd64 [Download](https://pentagi.com/downloads/windows/amd64/installer-latest.zip)
- **macOS**: amd64 (Intel) [Download](https://pentagi.com/downloads/darwin/amd64/installer-latest.zip) | arm64 (M-Serie) [Download](https://pentagi.com/downloads/darwin/arm64/installer-latest.zip)

**Schnellinstallation (Linux amd64):**```bash
# Create installation directory
mkdir -p pentagi && cd pentagi

# Download installer
wget -O installer.zip https://pentagi.com/downloads/linux/amd64/installer-latest.zip

# Extract
unzip installer.zip

# Run interactive installer
./installer

2. Kopieren Sie `.env.example` nach `.env` oder laden Sie es herunter:```bash
curl -o .env https://raw.githubusercontent.com/vxcontrol/pentagi/master/.env.example

4. Füge die erforderlichen API-Schlüssel in die `.env`-Datei ein.```bash
# Required: At least one of these LLM providers
OPEN_AI_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
GEMINI_API_KEY=your_gemini_key

# Optional: AWS Bedrock provider (enterprise-grade models)
BEDROCK_REGION=us-east-1
# Choose one authentication method:
BEDROCK_DEFAULT_AUTH=true                        # Option 1: Use AWS SDK default credential chain (recommended for EC2/ECS)
# BEDROCK_BEARER_TOKEN=your_bearer_token         # Option 2: Bearer token authentication
# BEDROCK_ACCESS_KEY_ID=your_aws_access_key      # Option 3: Static credentials
# BEDROCK_SECRET_ACCESS_KEY=your_aws_secret_key

# Optional: Ollama provider (local or cloud)
# OLLAMA_SERVER_URL=http://ollama-server:11434   # Local server
# OLLAMA_SERVER_URL=https://ollama.com           # Cloud service
# OLLAMA_SERVER_API_KEY=your_ollama_cloud_key    # Required for cloud, empty for local

# Optional: Chinese AI providers
# DEEPSEEK_API_KEY=your_deepseek_key             # DeepSeek (strong reasoning)
# GLM_API_KEY=your_glm_key                       # GLM (Zhipu AI)
# KIMI_API_KEY=your_kimi_key                     # Kimi (Moonshot AI, ultra-long context)
# QWEN_API_KEY=your_qwen_key                     # Qwen (Alibaba Cloud, multimodal)

# Optional: Local LLM provider (zero-cost inference)
OLLAMA_SERVER_URL=http://localhost:11434
OLLAMA_SERVER_MODEL=your_model_name

# Optional: Additional search capabilities
DUCKDUCKGO_ENABLED=true
DUCKDUCKGO_REGION=us-en
DUCKDUCKGO_SAFESEARCH=
DUCKDUCKGO_TIME_RANGE=
SPLOITUS_ENABLED=true
GOOGLE_API_KEY=your_google_key
GOOGLE_CX_KEY=your_google_cx
TAVILY_API_KEY=your_tavily_key
TRAVERSAAL_API_KEY=your_traversaal_key
PERPLEXITY_API_KEY=your_perplexity_key
PERPLEXITY_MODEL=sonar-pro
PERPLEXITY_CONTEXT_SIZE=medium

# Searxng meta search engine (aggregates results from multiple sources)
SEARXNG_URL=http://your-searxng-instance:8080
SEARXNG_CATEGORIES=general
SEARXNG_LANGUAGE=
SEARXNG_SAFESEARCH=0
SEARXNG_TIME_RANGE=
SEARXNG_TIMEOUT=

## Graphiti knowledge graph settings
GRAPHITI_ENABLED=true
GRAPHITI_TIMEOUT=30
GRAPHITI_URL=http://graphiti:8000
GRAPHITI_MODEL_NAME=gpt-5-mini

# Neo4j settings (used by Graphiti stack)
NEO4J_USER=neo4j
NEO4J_DATABASE=neo4j
NEO4J_PASSWORD=devpassword
NEO4J_URI=bolt://neo4j:7687

# Assistant configuration
ASSISTANT_USE_AGENTS=false         # Default value for agent usage when creating new assistants

7. Führen Sie den PentAGI-Stack aus:```bash
curl -O https://raw.githubusercontent.com/vxcontrol/pentagi/master/docker-compose.yml
docker compose up -d

> [!WICHTIG]
> - Ersetzen Sie `192.168.1.100` durch die tatsächliche IP-Adresse Ihres Servers
> - Verwenden Sie NICHT `0.0.0.0` in `PUBLIC_URL` oder `CORS_ORIGINS` – verwenden Sie die tatsächliche IP-Adresse
> - Schließen Sie sowohl localhost als auch Ihre Server-IP in `CORS_ORIGINS` ein, um Flexibilität zu gewährleisten

2. **Container neu erstellen**, um die Änderungen zu übernehmen:```bash
docker compose down
docker compose up -d --force-recreate

Sie sollten `0.0.0.0:8443->8443/tcp` oder `:::8443->8443/tcp` sehen.

Wenn Sie `127.0.0.1:8443->8443/tcp` sehen, wurde die Umgebungsvariable nicht übernommen. Bearbeiten Sie in diesem Fall direkt `docker-compose.yml` Zeile 31:```yaml
ports:
  - "0.0.0.0:8443:8443"

5. **Zugriff auf PentAGI:**

- **Lokaler Zugriff:** `https://localhost:8443`
- **Netzwerkzugriff:** `https://your-server-ip:8443`

> [!NOTE]
> Sie müssen die Warnung zum selbstsignierten SSL-Zertifikat in Ihrem Browser akzeptieren, wenn Sie über die IP-Adresse zugreifen.

---

### PentAGI mit Podman ausführen

PentAGI unterstützt Podman vollständig als Docker-Alternative. Allerdings erfordert der Scraper-Dienst bei Verwendung des **rootless-Modus von Podman** eine spezielle Konfiguration, da rootless-Container keine privilegierten Ports (Ports unter 1024) binden können.

#### Rootless-Konfiguration für Podman

Die Standardkonfiguration des Scrapers verwendet Port 443 (HTTPS), einen privilegierten Port. Konfigurieren Sie den Scraper für Podman rootless so um, dass er einen nicht-privilegierten Port verwendet:

**1. Bearbeiten Sie `docker-compose.yml`** - modifizieren Sie den `scraper`-Dienst (etwa in Zeile 199):```yaml
scraper:
  image: vxcontrol/scraper:latest
  restart: unless-stopped
  container_name: scraper
  hostname: scraper
  expose:
    - 3000/tcp  # Changed from 443 to 3000
  ports:
    - "${SCRAPER_LISTEN_IP:-127.0.0.1}:${SCRAPER_LISTEN_PORT:-9443}:3000"  # Map to port 3000
  environment:
    - MAX_CONCURRENT_SESSIONS=${LOCAL_SCRAPER_MAX_CONCURRENT_SESSIONS:-10}
    - USERNAME=${LOCAL_SCRAPER_USERNAME:-someuser}
    - PASSWORD=${LOCAL_SCRAPER_PASSWORD:-somepass}
  logging:
    options:
      max-size: 50m
      max-file: "7"
  volumes:
    - scraper-ssl:/usr/src/app/ssl
  networks:
    - pentagi-network
  shm_size: 2g

> [!IMPORTANT]
> Wichtige Änderungen für Podman:
> - Verwende **HTTP** anstelle von HTTPS für `SCRAPER_PRIVATE_URL`
> - Verwende Port **3000** anstelle von 443
> - Ändere internes `expose` auf `3000/tcp`
> - Aktualisiere Port-Zuordnung, um auf `3000` statt `443` zu verweisen

**3. Container neu erstellen:**```bash
podman-compose down
podman-compose up -d --force-recreate

Wenn Sie HTML-Ausgabe sehen, funktioniert der Scraper korrekt.

#### Podman Rootful Mode

Wenn Sie Podman im Rootful-Modus (mit sudo) ausführen, können Sie die Standardkonfiguration ohne Änderungen verwenden. Der Scraper funktioniert wie vorgesehen auf Port 443.

#### Docker Compatibility

Alle Podman-Konfigurationen bleiben vollständig kompatibel mit Docker. Der nicht-privilegierte Port-Ansatz funktioniert auf beiden Container-Laufzeiten identisch.

### Assistentenkonfiguration

Mit PentAGI können Sie das Standardverhalten für Assistenten konfigurieren:

| Variable | Standard | Beschreibung |
| ---------------------- | ------- | ----------------------------------------------------------------------- |
| `ASSISTANT_USE_AGENTS` | `false` | Steuert den Standardwert für die Agentennutzung beim Erstellen neuer Assistenten |

Die Einstellung `ASSISTANT_USE_AGENTS` beeinflusst den Anfangszustand des Umschalters "Use Agents" beim Erstellen eines neuen Assistenten in der Benutzeroberfläche:
- `false` (Standard): Neue Assistenten werden standardmäßig ohne Agenten-Delegation erstellt
- `true`: Neue Assistenten werden standardmäßig mit aktivierter Agenten-Delegation erstellt

Beachten Sie, dass Benutzer diese Einstellung jederzeit überschreiben können, indem sie den Schalter "Use Agents" in der Benutzeroberfläche beim Erstellen oder Bearbeiten eines Assistenten umlegen. Diese Umgebungsvariable steuert nur den anfänglichen Standardzustand.

## So verwenden Sie PentAGI nach der Anmeldung

Sobald der Stack läuft und Sie sich in der Web-UI anmelden können, ist der schnellste Weg über den Flows-Workflow.

### 1. Erstellen Sie Ihren ersten Flow

1. Öffnen Sie **Flows** in der Seitenleiste.
2. Klicken Sie auf **Neuer Flow**.
3. Wählen Sie den Modus, der zu Ihrem Ziel passt:
   - **Automation**: vollständig autonome Ausführung für ein Testziel, das PentAGI von Anfang bis Ende durchführen soll
   - **Assistant**: interaktive Unterstützung, wenn Sie die Untersuchung Schritt für Schritt steuern möchten. In diesem Modus können Sie auch den Schalter **Use Agents** aktivieren, damit PentAGI Unteraufgaben an spezialisierte Unter-Agenten für komplexere Untersuchungen delegieren kann.
4. Wählen Sie den LLM-Anbieter aus, den Sie für diesen Flow verwenden möchten.
5. Beschreiben Sie das Ziel und die Aufgabenstellung in natürlicher Sprache im Nachrichtenfeld.

Gute erste Anweisungen umfassen in der Regel:

- das Zielsystem oder die URL
- die Art der gewünschten Bewertung
- etwaige Bereichsbeschränkungen oder Verhaltensregeln
- das erwartete Ergebnis, z. B. einen Schwachstellenbericht oder die Bestätigung einer Hypothese

Beispiel:```text
Assess https://target.example for common web application vulnerabilities. Focus on authentication, file handling, and injection issues. Stay within the provided target only and summarize confirmed findings with reproduction steps.

### API-Erkundung und -Testen

PentAGI bietet interaktive Dokumentation zur Erkundung und zum Testen von API-Endpunkten:

#### GraphQL Playground

Greifen Sie auf das GraphQL Playground unter `https://your-pentagi-instance:8443/api/v1/graphql/playground` zu

1. Klicken Sie auf die Registerkarte **HTTP Headers** unten
2. Fügen Sie Ihren Autorisierungs-Header hinzu:   ```json
   {
     "Authorization": "Bearer YOUR_API_TOKEN"
   }

**Paid Tier Setup (Multi-Model mit vorgefertigter Konfiguration)**

Verwenden Sie für kostenpflichtige Tarife, die mehrere gleichzeitige Modelle unterstützen, die vorgefertigte Ollama Cloud-Konfiguration:```bash
# Using pre-built Ollama Cloud configuration (included in Docker image)
OLLAMA_SERVER_URL=https://ollama.com
OLLAMA_SERVER_API_KEY=your_ollama_cloud_api_key
OLLAMA_SERVER_CONFIG_PATH=/opt/pentagi/conf/ollama-cloud.provider.yml

Die Umgebungsvariable `PENTAGI_OLLAMA_SERVER_CONFIG_PATH` ordnet Ihre Host-Konfigurationsdatei dem Pfad `/opt/pentagi/conf/ollama.provider.yml` im Container zu.

**Beispiel für benutzerdefinierte Konfiguration** (`my-ollama-config.yml`):```yaml
primary_agent:
  model: "qwen3-coder-next:cloud"
  temperature: 1.0
  top_p: 0.9
  max_tokens: 32768
  reasoning:
    effort: high

coder:
  model: "qwen3-coder:32b"
  temperature: 1.0
  max_tokens: 20480

**Überlegungen zur Leistung:**

- **Modell-Erkennung** (`OLLAMA_SERVER_LOAD_MODELS_ENABLED=true`): Fügt 1-2s Startlatenz durch Abfrage der Ollama-API hinzu
- **Automatischer Pull** (`OLLAMA_SERVER_PULL_MODELS_ENABLED=true`): Erster Start kann mehrere Minuten dauern, um Modelle herunterzuladen
- **Pull-Timeout** (`OLLAMA_SERVER_PULL_MODELS_TIMEOUT=900`): 15 Minuten in Sekunden
- **Statische Konfiguration**: Deaktivieren Sie beide Flags und geben Sie Modelle in der Konfigurationsdatei an, um den schnellsten Start zu erreichen

#### Erstellen benutzerdefinierter Ollama-Modelle mit erweitertem Kontext

PentAGI benötigt Modelle mit größeren Kontextfenstern als die Standard-Ollama-Konfigurationen. Sie müssen benutzerdefinierte Modelle mit erhöhtem `num_ctx`-Parameter über Modelfiles erstellen. Während typische Agenten-Workflows etwa 64K Tokens verbrauchen, verwendet PentAGI eine Kontextgröße von 110K für eine Sicherheitsmarge und zur Bewältigung komplexer Penetrationstest-Szenarien.

**Wichtig**: Der `num_ctx`-Parameter kann nur während der Modellerstellung über die Modelfile gesetzt werden – er kann nach der Erstellung nicht mehr geändert oder zur Laufzeit überschrieben werden.

##### Beispiel: Qwen3 32B FP16 mit erweitertem Kontext

Erstellen Sie eine Modelfile mit dem Namen `Modelfile_qwen3_32b_fp16_tc`:```dockerfile
FROM qwen3:32b-fp16
PARAMETER num_ctx 110000
PARAMETER temperature 0.3
PARAMETER top_p 0.8
PARAMETER min_p 0.0
PARAMETER top_k 20
PARAMETER repeat_penalty 1.1

##### Beispiel: QwQ 32B FP16 mit erweitertem Kontext

Erstellen Sie eine Modelfile mit dem Namen `Modelfile_qwq_32b_fp16_tc`:```dockerfile
FROM qwq:32b-fp16
PARAMETER num_ctx 110000
PARAMETER temperature 0.2
PARAMETER top_p 0.7
PARAMETER min_p 0.0
PARAMETER top_k 40
PARAMETER repeat_penalty 1.2

> **Hinweis**: Das QwQ 32B FP16-Modell benötigt für die Inferenz etwa **71,3 GB VRAM**. Stellen Sie sicher, dass Ihr System über ausreichend GPU-Speicher verfügt, bevor Sie versuchen, dieses Modell zu verwenden.

Diese benutzerdefinierten Modelle werden in den vorgefertigten Anbieterkonfigurationsdateien (`ollama-qwen332b-fp16-tc.provider.yml` und `ollama-qwq32b-fp16-tc.provider.yml`) referenziert, die im Docker-Image unter `/opt/pentagi/conf/` enthalten sind.

### OpenAI-Anbieterkonfiguration

PentAGI integriert sich in die umfassende Modellpalette von OpenAI, die erweiterte Reasoning-Fähigkeiten mit erweiterter Gedankenkette, agentische Modelle mit verbesserter Tool-Integration und spezialisierte Codemodelle für Sicherheitstechnik bietet.

#### Konfigurationsvariablen

| Variable             | Standard                    | Beschreibung                     |
| -------------------- | --------------------------- | -------------------------------- |
| `OPEN_AI_KEY`        |                             | API-Schlüssel für OpenAI-Dienste |
| `OPEN_AI_SERVER_URL` | `https://api.openai.com/v1` | OpenAI-API-Endpunkt              |

#### Konfigurationsbeispiele```bash
# Basic OpenAI setup
OPEN_AI_KEY=your_openai_api_key
OPEN_AI_SERVER_URL=https://api.openai.com/v1

# Using with proxy for enhanced security
OPEN_AI_KEY=your_openai_api_key
PROXY_URL=http://your-proxy:8080

> [!NOTE]
> **Google Vertex KI für Claude-Modelle**
>
> PentAGI stellt derzeit keinen dedizierten Google Vertex AI-Konfigurationspfad für Anthropic Claude in `.env` bereit. Es gibt derzeit kein separates Vertex AI-API-Schlüsselfeld, und die vorhandenen Anthropic-Variablen (`ANTHROPIC_API_KEY`, `ANTHROPIC_SERVER_URL`) zielen auf die direkte Anthropic-API. Unterstützte Routen für Claude sind:
>
> - **Direkte Anthropic-API**: `ANTHROPIC_API_KEY` und `ANTHROPIC_SERVER_URL` (siehe oben).
> - **AWS Bedrock**: `BEDROCK_*`-Variablen (siehe [AWS Bedrock Provider-Konfiguration](#aws-bedrock-provider-configuration)).
>
> Wenn Sie Vertex AI heute verwenden müssen, ist die sicherste unterstützte Problemumgehung, Vertex AI über einen OpenAI-kompatiblen Proxy oder Gateway bereitzustellen, der Vertex AI-Aufrufe in das Chat Completions-Format übersetzt, während das Chat- und Tool-Call-Verhalten, auf das PentAGI angewiesen ist, erhalten bleibt. Richten Sie dann den Custom LLM-Anbieter auf dieses Gateway über `LLM_SERVER_URL`, `LLM_SERVER_KEY` und `LLM_SERVER_MODEL` aus. Dieser Weg ist nur so zuverlässig wie das von Ihnen gewählte Gateway.

#### Unterstützte Modelle

PentAGI unterstützt 10 Claude-Modelle mit Tool Calling, Streaming, Extended Thinking, Adaptive Thinking und Prompt Caching. Modelle, die mit `*` markiert sind, werden in der Standardkonfiguration verwendet.

**Claude 4 Serie - Neueste Modelle (2025-2026)**

| Modell-ID                 | Denken | Veröffentlichungsdatum | Preis (Eingabe/Ausgabe/Cache R/W) | Anwendungsfall                                        |
| ------------------------- | ------ | ---------------------- | --------------------------------- | ---------------------------------------------------- |
| `claude-opus-4-6`*        | ✅      | Mai 2025               | $5.00/$25.00/$0.50/$6.25          | Das intelligenteste Modell für autonome Agenten und Codierung. Extended + Adaptive Thinking für komplexe Exploit-Entwicklung, mehrstufige Angriffssimulation |
| `claude-sonnet-4-6`*      | ✅      | Aug 2025               | $3.00/$15.00/$0.30/$3.75          | Beste Balance zwischen Geschwindigkeit und Intelligenz mit Adaptive Thinking. Mehrphasige Sicherheitsbewertungen, intelligente Schwachstellenanalyse, Echtzeit-Bedrohungsjagd |
| `claude-haiku-4-5`*       | ✅      | Okt 2025               | $1.00/$5.00/$0.10/$1.25           | Schnellstes Modell mit nahezu Grenzintelligenz. Hochfrequenz-Scanning, Echtzeit-Überwachung, automatisierte Massentests |

**Legacy-Modelle - Weiterhin unterstützt**

| Modell-ID                 | Denken | Veröffentlichungsdatum | Preis (Eingabe/Ausgabe/Cache R/W) | Anwendungsfall                                        |
| ------------------------- | ------ | ---------------------- | --------------------------------- | ---------------------------------------------------- |
| `claude-sonnet-4-5`       | ✅      | Sep 2025               | $3.00/$15.00/$0.30/$3.75          | Hochmodernes Reasoning (durch 4-6 abgelöst). Anspruchsvolle Penetrationstests, erweiterte Bedrohungsanalyse |
| `claude-opus-4-5`         | ✅      | Nov 2025               | $5.00/$25.00/$0.50/$6.25          | Ultimatives Reasoning (durch opus-4-6 abgelöst). Kritische Sicherheitsforschung, Zero-Day-Entdeckung, Red-Team-Operationen |
| `claude-opus-4-1`         | ✅      | Aug 2025               | $15.00/$75.00/$1.50/$18.75        | Erweitertes Reasoning (abgelöst). Komplexe Penetrationstests, anspruchsvolle Bedrohungsmodellierung |
| `claude-sonnet-4-0`       | ✅      | Mai 2025               | $3.00/$15.00/$0.30/$3.75          | Hochleistungs-Reasoning (abgelöst). Komplexe Bedrohungsmodellierung, Multi-Tool-Koordination |
| `claude-opus-4-0`         | ✅      | Mai 2025               | $15.00/$75.00/$1.50/$18.75        | Erste Generation Opus (abgelöst). Mehrstufige Exploit-Entwicklung, autonome Pentesting-Workflows |

**Veraltete Modelle - Migration zu aktuellen Modellen**

| Modell-ID                      | Denken | Veröffentlichungsdatum | Preis (Eingabe/Ausgabe/Cache R/W) | Hinweise                                     |
| ------------------------------ | ------ | ---------------------- | --------------------------------- | -------------------------------------------- |
| `claude-3-haiku-20240307`      | ❌      | Mär 2024               | $0.25/$1.25/$0.03/$0.30          | Wird am 19. April 2026 eingestellt. Migrieren Sie zu claude-haiku-4-5 |

**Preise**: Pro 1M Tokens. Cache-Preise beinhalten sowohl Lese- als auch Schreibkosten.

**Konfiguration für Extended Thinking**:
- **Max Tokens 4096**: Generator (claude-opus-4-6) für maximale Reasoning-Tiefe bei komplexer Exploit-Entwicklung
- **Max Tokens 2048**: Coder (claude-sonnet-4-6) für ausgewogene Code-Analyse und Schwachstellenforschung
- **Max Tokens 1024**: Primäragent, Assistent, Verfeinerer, Berater, Reflektor, Sucher, Installer, Pentester für fokussiertes Reasoning bei spezifischen Aufgaben
- **Extended Thinking**: Alle Claude 4.5+- und 4.6-Modelle unterstützen konfigurierbares Extended Thinking für tiefgehende Reasoning-Aufgaben

**Hauptfunktionen**:
- **Extended Thinking**: Alle Claude 4.5+- und 4.6-Modelle mit konfigurierbaren Chain-of-Thought-Reasoning-Tiefen für komplexe Sicherheitsanalysen
- **Adaptive Thinking**: Die Claude 4.6-Serie (Opus/Sonnet) passt die Reasoning-Tiefe dynamisch an die Aufgabenkomplexität an, um optimale Leistung zu erzielen
- **Prompt Caching**: Deutliche Kostenreduzierung mit separater Lese-/Schreib-Preisgestaltung (10 % Lesen, 125 % Schreiben des Inputs)
- **Erweitertes Kontextfenster**: 200K Tokens Standard, bis zu 1M Tokens (Beta) für Claude Opus/Sonnet 4.6 für umfassende Codebasis-Analyse
- **Tool Calling**: Robustes Function Calling mit außergewöhnlicher Genauigkeit für die Orchestrierung von Sicherheitstools
- **Streaming**: Echtzeit-Response-Streaming für interaktive Penetrationstest-Workflows
- **Safety-First-Design**: Integrierte Sicherheitsmechanismen, die verantwortungsvolle Sicherheitstestpraktiken gewährleisten
- **Multimodale Unterstützung**: Vision-Funktionen in den neuesten Modellen für Screenshot-Analyse und UI-Sicherheitsbewertung
- **Constitutional AI**: Fortschrittliches Safety-Training, das zuverlässige und ethische Sicherheitsberatung bietet

### Google AI (Gemini) Provider-Konfiguration

PentAGI integriert sich über die Google AI API in Googles Gemini-Modelle und bietet hochmoderne multimodale Reasoning-Fähigkeiten mit Extended Thinking und Context Caching.

#### Konfigurationsvariablen

| Variable            | Standardwert                                | Beschreibung                   |
| ------------------- | ------------------------------------------- | ------------------------------ |
| `GEMINI_API_KEY`    |                                             | API-Schlüssel für Google AI-Dienste |
| `GEMINI_SERVER_URL` | `https://generativelanguage.googleapis.com` | Google AI API-Endpunkt         |

#### Konfigurationsbeispiele```bash
# Basic Gemini setup
GEMINI_API_KEY=your_gemini_api_key
GEMINI_SERVER_URL=https://generativelanguage.googleapis.com

# Using with proxy
GEMINI_API_KEY=your_gemini_api_key
PROXY_URL=http://your-proxy:8080

#### Unterstützte Modelle

PentAGI unterstützt 21 AWS-Bedrock-Modelle mit Tool-Calling, Streaming und multimodalen Fähigkeiten. Mit `*` markierte Modelle werden in der Standardkonfiguration verwendet.

| Modell-ID                                        | Anbieter        | Denken | Multimodal | Preis (Eingabe/Ausgabe) | Anwendungsfall                           |
| ------------------------------------------------ | --------------- | ------ | ---------- | ----------------------- | ---------------------------------------- |
| `us.amazon.nova-2-lite-v1:0`                     | Amazon Nova     | ❌     | ✅         | $0,33/$2,75             | Adaptives Denken, effizientes Schlussfolgern |
| `us.amazon.nova-premier-v1:0`                    | Amazon Nova     | ❌     | ✅         | $2,50/$12,50            | Komplexes Schlussfolgern, fortgeschrittene Analyse |
| `us.amazon.nova-pro-v1:0`                        | Amazon Nova     | ❌     | ✅         | $0,80/$3,20             | Ausgewogene Genauigkeit, Geschwindigkeit, Kosten |
| `us.amazon.nova-lite-v1:0`                       | Amazon Nova     | ❌     | ✅         | $0,06/$0,24             | Schnelle Verarbeitung, Vorgänge mit hohem Volumen |
| `us.amazon.nova-micro-v1:0`                      | Amazon Nova     | ❌     | ❌         | $0,035/$0,14            | Ultra-niedrige Latenz, Echtzeit-Überwachung |
| `us.anthropic.claude-opus-4-6-v1`*               | Anthropic       | ✅     | ✅         | $5,00/$25,00            | Weltklasse-Codierung, Unternehmens-Agenten |
| `us.anthropic.claude-sonnet-4-6`                 | Anthropic       | ✅     | ✅         | $3,00/$15,00            | Grenzüberschreitende Intelligenz, Unternehmensmaßstab |
| `us.anthropic.claude-opus-4-5-20251101-v1:0`     | Anthropic       | ✅     | ✅         | $5,00/$25,00            | Mehrtägige Softwareentwicklung             |
| `us.anthropic.claude-haiku-4-5-20251001-v1:0`*   | Anthropic       | ✅     | ✅         | $1,00/$5,00             | Fast-Grenzleistung, hohe Geschwindigkeit   |
| `us.anthropic.claude-sonnet-4-5-20250929-v1:0`*  | Anthropic       | ✅     | ✅         | $3,00/$15,00            | Praxisnahe Agenten, Codierung auf Spitzenniveau |
| `us.anthropic.claude-sonnet-4-20250514-v1:0`     | Anthropic       | ✅     | ✅         | $3,00/$15,00            | Ausgewogene Leistung, produktionsbereit    |
| `us.anthropic.claude-3-5-haiku-20241022-v1:0`    | Anthropic       | ❌     | ❌         | $0,80/$4,00             | Schnellstes Modell, kosteneffizientes Scannen |
| `cohere.command-r-plus-v1:0`                     | Cohere          | ❌     | ❌         | $3,00/$15,00            | Großflächige Vorgänge, überlegenes RAG     |
| `deepseek.v3.2`                                  | DeepSeek        | ❌     | ❌         | $0,58/$1,68             | Langkontext-Schlussfolgern, Effizienz      |
| `openai.gpt-oss-120b-1:0`*                       | OpenAI (OSS)    | ✅     | ❌         | $0,15/$0,60             | Starkes Schlussfolgern, wissenschaftliche Analyse |
| `openai.gpt-oss-20b-1:0`                         | OpenAI (OSS)    | ✅     | ❌         | $0,07/$0,30             | Effizientes Codieren, Softwareentwicklung  |
| `qwen.qwen3-next-80b-a3b`                        | Qwen            | ❌     | ❌         | $0,15/$1,20             | Ultra-langer Kontext, Flaggschiff-Schlussfolgern |
| `qwen.qwen3-32b-v1:0`                            | Qwen            | ❌     | ❌         | $0,15/$0,60             | Ausgewogenes Schlussfolgern, Forschungsanwendungsfälle |
| `qwen.qwen3-coder-30b-a3b-v1:0`                  | Qwen            | ❌     | ❌         | $0,15/$0,60             | Vibe-Codierung, natürlichsprachlich zuerst |
| `qwen.qwen3-coder-next`                          | Qwen            | ❌     | ❌         | $0,45/$1,80             | Tool-Nutzung, funktionsaufrufoptimiert     |
| `mistral.mistral-large-3-675b-instruct`          | Mistral         | ❌     | ✅         | $4,00/$12,00            | Fortschrittliches Multimodal, langer Kontext |
| `moonshotai.kimi-k2.5`                           | Moonshot        | ❌     | ✅         | $0,60/$3,00             | Vision, Sprache, Code in einem Modell      |

**Preise**: Pro 1M Token. Modelle mit Denk-/Schlussfolgerungsunterstützung verursachen während der Denkphase zusätzliche Rechenkosten.

#### Getestete, aber inkompatible Modelle

Einige AWS-Bedrock-Modelle wurden getestet, werden aber aufgrund technischer Einschränkungen **nicht unterstützt**:

| Modellfamilie              | Grund für Inkompatibilität                                                                            |
| -------------------------- | ----------------------------------------------------------------------------------------------------- |
| **GLM (Z.AI)**             | Tool-Calling-Format inkompatibel mit Converse API (erwartet String statt JSON)                        |
| **AI21 Jamba**             | Starke Ratenbegrenzungen (1-2 Anfragen/Min) verhindern zuverlässige Tests und den Produktionseinsatz  |
| **Meta Llama 3.3/3.1**     | Instabile Verarbeitung von Tool-Call-Ergebnissen, verursacht unerwartete Fehler in Multi-Turn-Workflows|
| **Mistral Magistral**      | Tool Calling wird vom Modell nicht unterstellt                                                          |
| **Moonshot K2-Thinking**   | Instabiles Streaming-Verhalten mit Tool-Aufrufen, unzuverlässig in der Produktion                       |
| **Qwen3-VL**               | Instabiles Streaming mit Tool Calling, multimodale + Tools-Kombination schlägt zeitweise fehl            |

> [!IMPORTANT]
> **Ratenbegrenzungen und Kontingentverwaltung**
>
> Standardkontingente von AWS Bedrock für Claude-Modelle sind **extrem restriktiv** (2-20 Anfragen/Minute für neue Konten). Für produktiven Penetrationstests:
>
> 1. **Kontingenterhöhungen beantragen** über die AWS Service Quotas-Konsole für die Modelle, die Sie verwenden möchten
> 2. **Amazon Nova-Modelle verwenden** – höhere Standardkontingente und hervorragende Leistung
> 3. **Bereitgestellten Durchsatz aktivieren** für konsistentes Hochvolumen-Testing
> 4. **Nutzung überwachen** – AWS drosselt aggressiv an Kontingentgrenzen
>
> Ohne Kontingenterhöhungen ist mit häufigen Verzögerungen und Arbeitsablaufunterbrechungen zu rechnen.

> [!WARNING]
> **Converse-API-Anforderungen**
>
> PentAGI verwendet die Amazon Bedrock **Converse API** für einheitlichen Modellzugriff. Alle unterstützten Modelle erfordern:
>
> - ✅ Converse/ConverseStream-API-Unterstützung
> - ✅ Tool-Nutzung (Funktionsaufruf) für Penetrationstest-Workflows
> - ✅ Streaming-Tool-Nutzung für Echtzeit-Feedback
>
> Modellfähigkeiten überprüfen unter: [AWS Bedrock Model Features](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-supported-models-features.html)

**Wichtige Funktionen**:
- **Automatisches Prompt-Caching**: 40-70% Kostensenkung bei wiederholtem Kontext (Claude 4.x-Modelle)
- **Erweitertes Denken**: Schritt-für-Schritt-Schlussfolgerungen für komplexe Sicherheitsanalysen (Claude, DeepSeek R1, OpenAI GPT)
- **Multimodale Analyse**: Verarbeitung von Screenshots, Diagrammen, Videos für umfassende Tests (Nova, Claude, Mistral, Kimi)
- **Tool Calling**: Nahtlose Integration mit 20+ Penetrationstest-Tools via Funktionsaufruf
- **Streaming**: Echtzeit-Response-Streaming für interaktive Sicherheitsbewertungs-Workflows

### DeepSeek-Anbieterkonfiguration

PentAGI integriert DeepSeek und bietet Zugang zu fortschrittlichen KI-Modellen mit starken Schlussfolgerungs- und Codierungsfähigkeiten sowie Kontext-Caching zu wettbewerbsfähigen Preisen.

#### Konfigurationsvariablen

| Variable              | Standardwert                  | Beschreibung                                          |
| --------------------- | ----------------------------- | ----------------------------------------------------- |
| `DEEPSEEK_API_KEY`    |                               | DeepSeek-API-Schlüssel für die Authentifizierung      |
| `DEEPSEEK_SERVER_URL` | `https://api.deepseek.com`    | DeepSeek-API-Endpunkt-URL                             |
| `DEEPSEEK_PROVIDER`   |                               | Anbieterpräfix für LiteLLM-Integration (optional)     |

#### Konfigurationsbeispiele```bash
# Direct API usage
DEEPSEEK_API_KEY=your_deepseek_api_key
DEEPSEEK_SERVER_URL=https://api.deepseek.com

# With LiteLLM proxy
DEEPSEEK_API_KEY=your_litellm_key
DEEPSEEK_SERVER_URL=http://litellm-proxy:4000
DEEPSEEK_PROVIDER=deepseek  # Adds prefix to model names (deepseek/deepseek-v4-flash) for LiteLLM

#### Unterstützte Modelle

PentAGI unterstützt 13 GLM-Modelle mit Tool-Aufruf, Streaming, hybriden Denkmodi und Prompt-Caching. Mit `*` markierte Modelle werden in der Standardkonfiguration verwendet. Das Denken wird über `extra_body.thinking.type` ("enabled"/"disabled") gesteuert; im Gegensatz zu Kimi ist GLM in beiden Modi bezüglich der Temperatur nachsichtig.

**GLM-5.x Serie - Neueste Generation (200K Kontext, 128K max Ausgabe)**

| Modell-ID         | Denken | Kontext | Max Ausgabe | Preis (Input/Output/Cache) | Anwendungsfall                                                            |
| ---------------- | -------- | ------- | ---------- | -------------------------- | ------------------------------------------------------------------- |
| `glm-5.1`*       | ✅ Hybrid | 200K    | 128K       | $1.40/$4.40/$0.26          | Neuestes Flaggschiff: 8h anhaltende autonome Ausführung, Claude Opus 4.6-ausgerichtet (Generator/Refiner/Berater/Coder/Pentester Standard) |
| `glm-5`          | ✅ Hybrid | 200K    | 128K       | $1.00/$3.20/$0.20          | Grundlage für agentisches Engineering, MoE 744B/40B aktiv, Claude Opus 4.5-level Codierung |
| `glm-5-turbo`*   | ✅ Hybrid | 200K    | 128K       | $1.20/$4.00/$0.24          | OpenClaw-nativ: optimiert für Tool-Aufruf, persistente Aufgaben, langkettige Ausführung (primary_agent/assistant Standard) |

**GLM-4.7 Serie - Premium mit verschränktem Denken**

| Modell-ID          | Denken | Kontext | Max Ausgabe | Preis (Input/Output/Cache) | Anwendungsfall                                            |
| ----------------- | -------- | ------- | ---------- | -------------------------- | --------------------------------------------------- |
| `glm-4.7`         | ✅ Hybrid | 200K    | 128K       | $0.60/$2.20/$0.11          | Verbesserte Programmierung, stabiles mehrstufiges Denken   |
| `glm-4.7-flashx`  | ✅ Hybrid | 200K    | 128K       | $0.07/$0.40/$0.01          | Ultrabillig mit priorisierter GPU, aber niedrigeren RPM-Grenzen (für hochfrequente Nutzung vermeiden) |
| `glm-4.7-flash`   | ✅ Hybrid | 200K    | 128K       | Free/Free/Free             | Kostenloses ~30B SOTA-Modell, 1 gleichzeitige Anfrage          |

**GLM-4.6 Serie - Ausgewogen mit Auto-Denken**

| Modell-ID  | Denken | Kontext | Max Ausgabe | Preis (Input/Output/Cache) | Anwendungsfall                                          |
| --------- | -------- | ------- | ---------- | -------------------------- | ------------------------------------------------- |
| `glm-4.6` | ✅ Auto   | 200K    | 128K       | $0.60/$2.20/$0.11          | Ausgewogen, Streaming-Tool-Aufrufe, token-effizient   |

**GLM-4.5 Serie - Unified Reasoning/Coding/Agents**

| Modell-ID         | Denken | Kontext | Max Ausgabe | Preis (Input/Output/Cache) | Anwendungsfall                                          |
| ---------------- | -------- | ------- | ---------- | -------------------------- | ------------------------------------------------- |
| `glm-4.5`        | ✅ Auto   | 128K    | 96K        | $0.60/$2.20/$0.11          | Unified, MoE 355B/32B aktiv                      |
| `glm-4.5-x`      | ✅ Auto   | 128K    | 96K        | $2.20/$8.90/$0.45          | Ultra-schnelles Premium, niedrigste Latenz                |
| `glm-4.5-air`*   | ✅ Auto   | 128K    | 96K        | $0.20/$1.10/$0.03          | Kosteneffizientes MoE 106B/12B (simple/simple_json/reflector/searcher/enricher/installer Standard) |
| `glm-4.5-airx`   | ✅ Auto   | 128K    | 96K        | $1.10/$4.50/$0.22          | Beschleunigtes Air mit priorisierter GPU                 |
| `glm-4.5-flash`  | ✅ Auto   | 128K    | 96K        | Free/Free/Free             | Kostenlos mit Reasoning/Coding/Agents-Unterstützung         |

**GLM-4 Legacy - Dichte Architektur**

| Modell-ID              | Denken | Kontext | Max Ausgabe | Preis (Input/Output) | Anwendungsfall                                      |
| --------------------- | -------- | ------- | ---------- | -------------------- | --------------------------------------------- |
| `glm-4-32b-0414-128k` | ❌        | 128K    | 16K        | $0.10/$0.10          | Ultra-Budget dichte 32B, Parsen ohne Reasoning |

**Preise**: Pro 1M Tokens. Cache-Preis gilt für Prompt-Cache-Treffer; Cache-Speicher ist derzeit kostenlos gemäß Z.AI-Werbung. GLM-4-32B hat keine Cache-Unterstützung.

**Standard-Agent-Konfiguration**:

Strategie: `glm-5.1` (neuestes Flaggschiff, $1.40 Input) für kritisches Denken, `glm-5-turbo` (OpenClaw-nativ, agentenoptimiert) für Orchestrierung, `glm-4.5-air` (günstiges MoE mit hybridem Denken und zuverlässigen RPM) für alle Dienstprogramm/Installer-Agenten. `glm-4.7-flashx` wird als Standard vermieden, da niedrigere RPM-Grenzen bei hoher Frequenz häufige 429-Fehler verursachen.

| Agentenrolle                          | Standard-Modell | Denken | Temperatur | Top P | Max Ausgabe |
| ----------------------------------- | ------------- | -------- | ----------- | ----- | ---------- |
| Generator / Refiner                 | `glm-5.1`     | Aktiviert  | 1.0         | 0.95  | 32768      |
| Coder                               | `glm-5.1`     | Aktiviert  | 1.0         | 0.95  | 20480      |
| Berater / Pentester                 | `glm-5.1`     | Aktiviert  | 1.0         | 0.95  | 16384      |
| Primärer Agent / Assistent           | `glm-5-turbo` | Aktiviert  | 1.0         | 0.95  | 16384      |
| Installer                           | `glm-4.5-air` | Aktiviert  | 1.0         | 0.95  | 16384      |
| Einfach / Reflector                  | `glm-4.5-air` | Deaktiviert | 0.6         | 0.9   | 8192       |
| Sucher / Enricher / Simple JSON   | `glm-4.5-air` | Deaktiviert | 0.6         | 0.9   | 4096       |

> **Hinweis zur Temperatur**: GLM akzeptiert sowohl `1.0` als auch `0.6` im Denk- oder Nicht-Denk-Modus (laut Z.AI-Dokumentation). langchaingos `IsReasoningModel` erkennt die Präfixe `glm-4.5*`/`glm-4.6*`/`glm-4.7*` und überschreibt die Temperatur in `createChatRequest` zwangsweise auf 1.0 – dies ist für GLM harmlos (im Gegensatz zu Kimi), bedeutet jedoch, dass die Temperaturwerte für diese Modelle in YAML als Richtwerte zu verstehen sind. `glm-5`/`glm-5.1`/`glm-5-turbo` werden nicht erkannt, sodass explizite Werte unverändert durchgereicht werden.

**Denkmodi**:
- **Hybrid** (GLM-5.x, GLM-4.7): Expliziter Umschalter über `extra_body.thinking.type`
- **Auto** (GLM-4.6, GLM-4.5 Serie): Modell bestimmt automatisch, wann Reasoning erforderlich ist
- **Bewahrtes Denken** (Z.AI Coding-Fähigkeit): alle denkfähigen Agenten in PentAGI übergeben auch `extra_body.thinking.clear_thinking: false`, sodass `reasoning_content` von vorherigen Assistant-Durchläufen über das Gespräch hinweg erhalten bleibt. Dies ist auf dem Standard-API-Endpunkt (`/api/paas/v4`) erforderlich – auf dem Coding-Plan-Endpunkt wäre es standardmäßig aktiviert. Verbessert die Reasoning-Kontinuität und Cache-Trefferraten in mehrstufigen Tool-Aufruf-Ketten.
- Alle denkfähigen Agenten übergeben defensiv auch `extra_body.tool_choice: auto`

**Hauptfunktionen**:
- **Langzeithorizont-Aufgaben**: GLM-5.1 unterstützt 8-stündige anhaltende autonome Ausführung, ideal für komplexe mehrstufige agentische Arbeitsabläufe
- **OpenClaw-native Orchestrierung**: GLM-5-Turbo ist speziell optimiert für Tool-Aufruf, Befehlsbefolgung und langkettige Ausführung
- **Prompt-Caching**: Deutliche Kostenreduzierung bei wiederholtem Kontext (gezeigte Cache-Input-Preise)
- **Ultra-langer Kontext**: 200K Tokens für GLM-5.x/4.7/4.6 Serie
- **MoE-Architektur**: Effizient 744B/40B aktiv (GLM-5/5.1), 355B/32B (GLM-4.5), 106B/12B (GLM-4.5-Air)
- **Tool-Aufruf**: Nahtlose Integration mit über 20 Pentesting-Tools via Function Calling
- **Streaming**: Echtzeit-Streaming mit Unterstützung für Streaming-Tool-Aufrufe (GLM-4.6+)
- **Mehrsprachig**: Hervorragende NLP-Fähigkeiten für Chinesisch und Englisch
- **Kostenlose Optionen**: GLM-4.7-Flash und GLM-4.5-Flash für Prototyping und Experimente

**LiteLLM-Integration**: Setzen Sie `GLM_PROVIDER=zai`, um die Modellnamen-Präfixierung bei Verwendung der Standard-PentAGI-Konfigurationen mit dem LiteLLM-Proxy zu aktivieren. Lassen Sie es für die direkte API-Nutzung leer.

### Kimi-Anbieterkonfiguration

PentAGI integriert sich mit Kimi von Moonshot AI und bietet ultra-lange Kontextmodelle mit multimodalen Fähigkeiten, die sich perfekt für die Analyse umfangreicher Codebasen und Dokumentationen eignen.

#### Konfigurationsvariablen

| Variable           | Standardwert                  | Beschreibung                                         |
| ------------------ | ----------------------------- | --------------------------------------------------- |
| `KIMI_API_KEY`     |                              | Kimi-API-Schlüssel für die Authentifizierung                     |
| `KIMI_SERVER_URL`  | `https://api.moonshot.ai/v1` | Kimi-API-Endpunkt-URL (international)               |
| `KIMI_PROVIDER`    |                              | Anbieterpräfix für LiteLLM-Integration (optional)  |

#### Konfigurationsbeispiele```bash
# Direct API usage (international endpoint)
KIMI_API_KEY=your_kimi_api_key
KIMI_SERVER_URL=https://api.moonshot.ai/v1

# Alternative endpoint
KIMI_SERVER_URL=https://api.moonshot.cn/v1  # China

# With LiteLLM proxy
KIMI_API_KEY=your_litellm_key
KIMI_SERVER_URL=http://litellm-proxy:4000
KIMI_PROVIDER=moonshot  # Adds prefix to model names (moonshot/kimi-k2.5) for LiteLLM

---

[Read more](https://github.com/vxcontrol/pentagi)