pentagi — Système d'agents IA entièrement autonome capable d'effectuer des tâches complexes de tests d'intrusion. | Kitploit

Sécurisé et isolé. Toutes les opérations sont effectuées dans un environnement Docker isolé et sécurisé.
Entièrement autonome. Agent alimenté par l'IA qui détermine et exécute automatiquement les étapes de test d'intrusion avec une supervision optionnelle de l'exécution et une planification intelligente des tâches pour une fiabilité accrue.
Outils de pentesting professionnels. Suite intégrée de plus de 20 outils de sécurité professionnels, notamment nmap, metasploit, sqlmap, et bien d'autres.
Système de mémoire intelligent. Stockage à long terme des résultats de recherche et des approches réussies pour une utilisation future.
Intégration du graphe de connaissances. Graphe de connaissances propulsé par Graphiti utilisant Neo4j pour le suivi des relations sémantiques et une compréhension avancée du contexte.
Intelligence web. Navigateur intégré via scraper pour collecter les dernières informations à partir de sources web.
Systèmes de recherche externes. Intégration avec des API de recherche avancées, notamment Tavily, Traversaal, Perplexity, DuckDuckGo, Google Custom Search, Sploitus Search et Searxng pour une collecte complète d'informations.
Équipe de spécialistes. Système de délégation avec des agents IA spécialisés pour les tâches de recherche, développement et infrastructure, renforcé par une supervision optionnelle de l'exécution et une planification intelligente des tâches pour des performances optimales avec des modèles plus petits.
Surveillance complète. Journalisation détaillée et intégration avec Grafana/Prometheus pour une observation en temps réel du système.
Rapports détaillés. Génération de rapports de vulnérabilités complets avec des guides d'exploitation.
Gestion intelligente des conteneurs. Sélection automatique de l'image Docker en fonction des exigences spécifiques de la tâche.
Interface moderne. Interface web propre et intuitive pour la gestion et la surveillance du système.
API complètes. API REST et GraphQL complètes avec authentification par jeton Bearer pour l'automatisation et l'intégration.
Stockage persistant. Toutes les commandes et sorties sont stockées dans PostgreSQL avec l'extension pgvector.
Architecture évolutive. Conception basée sur les microservices prenant en charge la mise à l'échelle horizontale.
Solution auto-hébergée. Contrôle total sur votre déploiement et vos données.
Authentification flexible. Prise en charge de plus de 10 fournisseurs LLM (OpenAI, Anthropic, Google AI/Gemini, AWS Bedrock, Ollama, DeepSeek, GLM, Kimi, Qwen, Personnalisé) plus des agrégateurs (OpenRouter, DeepInfra). Pour les déploiements locaux en production, consultez notre guide vLLM + Qwen3.5-27B-FP8.
Authentification par jeton API. Système de jeton Bearer sécurisé pour l'accès programmatique aux API REST et GraphQL.
Déploiement rapide. Configuration facile via Docker Compose avec une configuration d'environnement complète.

pentester["👤 Security Engineer
(User of the system)"]

pentagi["✨ PentAGI
(Autonomous penetration testing system)"]

target["🎯 target-system
(System under test)"]
llm["🧠 llm-provider
(OpenAI/Anthropic/Ollama/Bedrock/Gemini/Custom)"]
search["🔍 search-systems
(Google/DuckDuckGo/Tavily/Traversaal/Perplexity/Sploitus/Searxng)"]
langfuse["📊 langfuse-ui
(LLM Observability Dashboard)"]
grafana["📈 grafana
(System Monitoring Dashboard)"]

pentester --> |Uses HTTPS| pentagi
pentester --> |Monitors AI HTTPS| langfuse
pentester --> |Monitors System HTTPS| grafana
pentagi --> |Tests Various protocols| target
pentagi --> |Queries HTTPS| llm
pentagi --> |Searches HTTPS| search
pentagi --> |Reports HTTPS| langfuse
pentagi --> |Reports HTTPS| grafana

class pentester person
class pentagi system
class target,llm,search,langfuse,grafana external

linkStyle default stroke:#ffffff,color:#ffffff

<details>
<summary><b>Architecture du conteneur</b> (cliquez pour développer)</summary>```mermaid
graph TB
    subgraph Core Services
        UI[Frontend UI<br/>React + TypeScript]
        API[Backend API<br/>Go + GraphQL]
        DB[(Vector Store<br/>PostgreSQL + pgvector)]
        MQ[Task Queue<br/>Async Processing]
        Agent[AI Agents<br/>Multi-Agent System]
    end

    subgraph Knowledge Graph
        Graphiti[Graphiti<br/>Knowledge Graph API]
        Neo4j[(Neo4j<br/>Graph Database)]
    end

    subgraph Monitoring
        Grafana[Grafana<br/>Dashboards]
        VictoriaMetrics[VictoriaMetrics<br/>Time-series DB]
        Jaeger[Jaeger<br/>Distributed Tracing]
        Loki[Loki<br/>Log Aggregation]
        OTEL[OpenTelemetry<br/>Data Collection]
    end

    subgraph Analytics
        Langfuse[Langfuse<br/>LLM Analytics]
        ClickHouse[ClickHouse<br/>Analytics DB]
        Redis[Redis<br/>Cache + Rate Limiter]
        MinIO[MinIO<br/>S3 Storage]
    end

    subgraph Security Tools
        Scraper[Web Scraper<br/>Isolated Browser]
        PenTest[Security Tools<br/>20+ Pro Tools<br/>Sandboxed Execution]
    end

    UI --> |HTTP/WS| API
    API --> |SQL| DB
    API --> |Events| MQ
    MQ --> |Tasks| Agent
    Agent --> |Commands| PenTest
    Agent --> |Queries| DB
    Agent --> |Knowledge| Graphiti
    Graphiti --> |Graph| Neo4j

    API --> |Telemetry| OTEL
    OTEL --> |Metrics| VictoriaMetrics
    OTEL --> |Traces| Jaeger
    OTEL --> |Logs| Loki

    Grafana --> |Query| VictoriaMetrics
    Grafana --> |Query| Jaeger
    Grafana --> |Query| Loki

    API --> |Analytics| Langfuse
    Langfuse --> |Store| ClickHouse
    Langfuse --> |Cache| Redis
    Langfuse --> |Files| MinIO

    classDef core fill:#f9f,stroke:#333,stroke-width:2px,color:#000
    classDef knowledge fill:#ffa,stroke:#333,stroke-width:2px,color:#000
    classDef monitoring fill:#bbf,stroke:#333,stroke-width:2px,color:#000
    classDef analytics fill:#bfb,stroke:#333,stroke-width:2px,color:#000
    classDef tools fill:#fbb,stroke:#333,stroke-width:2px,color:#000

    class UI,API,DB,MQ,Agent core
    class Graphiti,Neo4j knowledge
    class Grafana,VictoriaMetrics,Jaeger,Loki,OTEL monitoring
    class Langfuse,ClickHouse,Redis,MinIO analytics
    class Scraper,PenTest tools

Relation d'entités (cliquez pour développer)

```mermaid erDiagram Flow ||--o{ Task : contains Task ||--o{ SubTask : contains SubTask ||--o{ Action : contains Action ||--o{ Artifact : produces Action ||--o{ Memory : stores

Flow {
    string id PK
    string name "Flow name"
    string description "Flow description"
    string status "active/completed/failed"
    json parameters "Flow parameters"
    timestamp created_at
    timestamp updated_at
}

Task {
    string id PK
    string flow_id FK
    string name "Task name"
    string description "Task description"
    string status "pending/running/done/failed"
    json result "Task results"
    timestamp created_at
    timestamp updated_at
}

SubTask {
    string id PK
    string task_id FK
    string name "Subtask name"
    string description "Subtask description"
    string status "queued/running/completed/failed"
    string agent_type "researcher/developer/executor"
    json context "Agent context"
    timestamp created_at
    timestamp updated_at
}

Action {
    string id PK
    string subtask_id FK
    string type "command/search/analyze/etc"
    string status "success/failure"
    json parameters "Action parameters"
    json result "Action results"
    timestamp created_at
}

Artifact {
    string id PK
    string action_id FK
    string type "file/report/log"
    string path "Storage path"
    json metadata "Additional info"
    timestamp created_at
}

Memory {
    string id PK
    string action_id FK
    string type "observation/conclusion"
    vector embedding "Vector representation"
    text content "Memory content"
    timestamp created_at
}

</details>

<details>
<summary><b>Interaction de l'agent</b> (cliquez pour agrandir)</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

Système de mémoire (cliquer pour développer)

```mermaid graph TB subgraph "Long-term Memory" VS[(Vector Store
Embeddings DB)] KB[Knowledge Base
Domain Expertise] Tools[Tools Knowledge
Usage Patterns] end

subgraph "Working Memory"
    Context[Current Context<br/>Task State]
    Goals[Active Goals<br/>Objectives]
    State[System State<br/>Resources]
end

subgraph "Episodic Memory"
    Actions[Past Actions<br/>Commands History]
    Results[Action Results<br/>Outcomes]
    Patterns[Success Patterns<br/>Best Practices]
end

Context --> |Query| VS
VS --> |Retrieve| Context

Goals --> |Consult| KB
KB --> |Guide| Goals

State --> |Record| Actions
Actions --> |Learn| Patterns
Patterns --> |Store| VS

Tools --> |Inform| State
Results --> |Update| Tools

VS --> |Enhance| KB
KB --> |Index| VS

classDef ltm fill:#f9f,stroke:#333,stroke-width:2px,color:#000
classDef wm fill:#bbf,stroke:#333,stroke-width:2px,color:#000
classDef em fill:#bfb,stroke:#333,stroke-width:2px,color:#000

class VS,KB,Tools ltm
class Context,Goals,State wm
class Actions,Results,Patterns em

</details>

<details>
<summary><b>Résumé en chaîne</b> (cliquer pour développer)</summary>

Le système de résumé en chaîne gère la croissance du contexte de la conversation en résumant sélectivement les messages plus anciens. Ceci est essentiel pour éviter de dépasser les limites de tokens tout en maintenant la cohérence de la conversation.```mermaid
flowchart TD
    A[Input Chain] --> B{Needs Summarization?}
    B -->|No| C[Return Original Chain]
    B -->|Yes| D[Convert to ChainAST]
    D --> E[Apply Section Summarization]
    E --> F[Process Oversized Pairs]
    F --> G[Manage Last Section Size]
    G --> H[Apply QA Summarization]
    H --> I[Rebuild Chain with Summaries]
    I --> J{Is New Chain Smaller?}
    J -->|Yes| K[Return Optimized Chain]
    J -->|No| C

    classDef process fill:#bbf,stroke:#333,stroke-width:2px,color:#000
    classDef decision fill:#bfb,stroke:#333,stroke-width:2px,color:#000
    classDef output fill:#fbb,stroke:#333,stroke-width:2px,color:#000

    class A,D,E,F,G,H,I process
    class B,J decision
    class C,K output

L'algorithme opère sur une représentation structurée des chaînes de conversation (ChainAST) qui préserve les types de messages, y compris les appels d'outils et leurs réponses. Toutes les opérations de résumé maintiennent le flux critique de la conversation tout en réduisant la taille du contexte.

Options de configuration du résumeur global

Options de configuration du résumeur d'assistant

Les instances d'assistant peuvent utiliser des paramètres de résumé personnalisés pour affiner le comportement de gestion du contexte :

La configuration du résumeur d'assistant offre plus de mémoire pour la rétention de contexte par rapport aux paramètres globaux, conservant un historique de conversation plus récent tout en garantissant une utilisation efficace des tokens.

Configuration de l'environnement du résumeur```bash

Default values for global summarizer logic

SUMMARIZER_PRESERVE_LAST=true SUMMARIZER_USE_QA=true SUMMARIZER_SUM_MSG_HUMAN_IN_QA=false SUMMARIZER_LAST_SEC_BYTES=51200 SUMMARIZER_MAX_BP_BYTES=16384 SUMMARIZER_MAX_QA_SECTIONS=10 SUMMARIZER_MAX_QA_BYTES=65536 SUMMARIZER_KEEP_QA_SECTIONS=1

Default values for assistant summarizer logic

ASSISTANT_SUMMARIZER_PRESERVE_LAST=true ASSISTANT_SUMMARIZER_LAST_SEC_BYTES=76800 ASSISTANT_SUMMARIZER_MAX_BP_BYTES=16384 ASSISTANT_SUMMARIZER_MAX_QA_SECTIONS=7 ASSISTANT_SUMMARIZER_MAX_QA_BYTES=76800 ASSISTANT_SUMMARIZER_KEEP_QA_SECTIONS=3

</details>

<a id="advanced-agent-supervision"></a>
<details>
<summary><b>Supervision avancée des agents</b> (cliquez pour déplier)</summary>

PentAGI inclut des mécanismes de supervision multi-couches sophistiqués pour garantir une exécution efficace des tâches, éviter les boucles infinies et offrir une reprise intelligente en cas de blocage :

### Surveillance de l'exécution (Bêta)
- **Intervention automatique du mentor** : L'agent conseiller (mentor) est invoqué automatiquement lorsque les schémas d'exécution indiquent des problèmes potentiels
- **Détection de motifs** : Surveille les appels d'outils identiques (seuil : 5, configurable) et le nombre total d'appels d'outils (seuil : 10, configurable)
- **Analyse de progression** : Évalue si l'agent avance vers l'objectif de la sous-tâche, détecte les boucles et les inefficacités
- **Stratégies alternatives** : Recommande différentes approches lorsque la stratégie actuelle échoue
- **Guidage pour la recherche d'informations** : Suggère de chercher des solutions existantes plutôt que de réinventer
- **Format de réponse amélioré** : Les réponses des outils incluent les sections `<original_result>` et `<mentor_analysis>`
- **Configurable** : Activez via `EXECUTION_MONITOR_ENABLED` (défaut : false), personnalisez les seuils avec `EXECUTION_MONITOR_SAME_TOOL_LIMIT` et `EXECUTION_MONITOR_TOTAL_TOOL_LIMIT`

**Idéal pour** : Les modèles plus petits (< 32B paramètres), les scénarios d'attaque complexes nécessitant un guidage continu, éviter que les agents ne se bloquent sur une seule approche

**Impact sur les performances** : Augmentation de 2 à 3 fois du temps d'exécution et de l'utilisation des tokens, mais offre **une amélioration de 2x de la qualité des résultats** selon les tests avec Qwen3.5-27B-FP8

### Planification intelligente des tâches (Bêta)
- **Décomposition automatisée** : Le planificateur (conseiller en mode planification) génère 3 à 7 étapes spécifiques et actionnables avant que les agents spécialistes ne commencent leur travail
- **Plans contextuels** : Analyse le contexte d'exécution complet via l'agent enrichisseur pour créer des plans informés
- **Attribution structurée** : La demande originale est encapsulée dans une structure `<task_assignment>` avec le plan d'exécution et les instructions
- **Gestion du périmètre** : Empêche l'élargissement du scope en gardant les agents concentrés uniquement sur la sous-tâche actuelle
- **Instructions enrichies** : Les plans mettent en évidence les actions critiques, les pièges potentiels et les points de vérification
- **Configurable** : Activez via `AGENT_PLANNING_STEP_ENABLED` (défaut : false)

**Idéal pour** : Les modèles < 32B paramètres, les workflows de tests d'intrusion complexes, améliorer les taux de réussite sur les tâches sophistiquées

**Configuration renforcée du conseiller** : Fonctionne exceptionnellement bien lorsque l'agent conseiller utilise un modèle plus fort ou des paramètres améliorés. Exemple : utiliser le même modèle de base avec un mode de raisonnement maximal pour le conseiller (voir [`vllm-qwen3.5-27b-fp8.provider.yml`](https://github.com/vxcontrol/pentagi/blob/main/examples/configs/vllm-qwen3.5-27b-fp8.provider.yml)) permet une analyse complète des tâches et une planification stratégique à partir d'une architecture de modèle identique.

**Impact sur les performances** : Ajoute une surcharge de planification mais améliore considérablement les taux d'achèvement et réduit le travail redondant

### Limites d'appels d'outils (Toujours actif)
- **Limites strictes** : Empêchent les exécutions incontrôlées quel que soit l'état du mode de supervision
- **Différenciées par type d'agent** :
  - Agents généraux (Assistant, Agent principal, Pentester, Codeur, Installateur) : `MAX_GENERAL_AGENT_TOOL_CALLS` (défaut : 100)
  - Agents limités (Chercheur, Enrichisseur, Mémoriste, Générateur, Rapporteur, Conseiller, Réflecteur, Planificateur) : `MAX_LIMITED_AGENT_TOOL_CALLS` (défaut : 20)
- **Terminaison gracieuse** : Le réflecteur guide les agents vers une complétion appropriée lorsqu'ils approchent des limites
- **Protection des ressources** : Assure la stabilité du système et empêche l'épuisement des ressources

### Intégration du réflecteur (Toujours actif)
- **Correction automatique** : Invoqué lorsque le LLM ne parvient pas à générer d'appels d'outils après 3 tentatives
- **Guidage stratégique** : Analyse les échecs et guide les agents vers une utilisation correcte des outils ou des outils barrière (`done`, `ask`)
- **Mécanisme de récupération** : Fournit des conseils contextuels basés sur les schémas d'échec spécifiques
- **Application des limites** : Coordonne une terminaison gracieuse lorsque les limites d'appels d'outils sont atteintes

### Recommandations pour les modèles open source

**Indispensable pour les modèles < 32B paramètres** :
Les tests avec Qwen3.5-27B-FP8 montrent que l'activation de la surveillance de l'exécution et de la planification des tâches est **essentielle** pour les modèles open source plus petits :
- **Amélioration de la qualité** : Résultats 2x meilleurs par rapport à une exécution de base sans supervision
- **Prévention des boucles** : Réduit significativement les boucles infinies et le travail redondant
- **Diversité d'attaque** : Encourage l'exploration de multiples vecteurs d'attaque au lieu de se focaliser sur une seule approche
- **Déploiements isolés** : Permet un test d'intrusion autonome de niveau production dans des environnements réseau fermés avec inférence LLM locale

**Compromis** :
- Consommation de tokens : augmentation de 2 à 3 fois due aux invocations du mentor/planificateur
- Temps d'exécution : 2 à 3 fois plus long en raison des étapes d'analyse et de planification
- Qualité des résultats : amélioration de 2x en complétude, précision et couverture d'attaque
- Exigences du modèle : Fonctionne mieux lorsque le conseiller utilise une configuration renforcée (paramètres de raisonnement plus élevés, variante de modèle plus forte, ou modèle différent)

**Stratégie de configuration** :
Pour des performances optimales avec des modèles plus petits, configurez l'agent conseiller avec des paramètres renforcés :
- Utiliser le même modèle avec un mode de raisonnement maximal (exemple : [`vllm-qwen3.5-27b-fp8.provider.yml`](https://github.com/vxcontrol/pentagi/blob/main/examples/configs/vllm-qwen3.5-27b-fp8.provider.yml))
- Ou utiliser un modèle plus fort pour le conseiller tout en gardant le modèle de base pour les autres agents
- Ajuster les seuils de surveillance en fonction de la complexité des tâches et des capacités du modèle



</details>

L'architecture de PentAGI est conçue pour être modulaire, scalable et sécurisée. Voici les composants clés :

1. **Services principaux**
   - Interface utilisateur frontale : Interface web basée sur React avec TypeScript pour la sécurité des types
   - API backend : API REST et GraphQL en Go avec authentification par jeton Bearer pour un accès programmatique
   - Stockage vectoriel : PostgreSQL avec pgvector pour la recherche sémantique et le stockage mémoire
   - File d'attente de tâches : Système de traitement asynchrone des tâches pour un fonctionnement fiable
   - Agent IA : Système multi-agents avec des rôles spécialisés pour des tests efficaces

2. **Graphe de connaissances**
   - Graphiti : API de graphe de connaissances pour le suivi des relations sémantiques et la compréhension contextuelle
   - Neo4j : Base de données graphe pour stocker et interroger les relations entre entités, actions et résultats
   - Capture automatique des réponses des agents et des exécutions d'outils pour construire une base de connaissances complète

3. **Stack de surveillance**
   - OpenTelemetry : Collecte et corrélation unifiées des données d'observabilité
   - Grafana : Tableaux de bord de visualisation et d'alertes en temps réel
   - VictoriaMetrics : Stockage de métriques de séries temporelles haute performance
   - Jaeger : Traçage distribué de bout en bout pour le débogage
   - Loki : Agrégation et analyse de logs scalable

4. **Plateforme d'analyse**
   - Langfuse : Observabilité LLM avancée et analytique des performances
   - ClickHouse : Entrepôt de données analytique orienté colonnes
   - Redis : Cache haute vitesse et limitation de débit
   - MinIO : Stockage d'objets compatible S3 pour les artefacts

5. **Outils de sécurité**
   - Scraper web : Environnement de navigateur isolé pour une interaction web sécurisée
   - Outils de test d'intrusion : Suite complète de plus de 20 outils de sécurité professionnels
   - Exécution en bac à sable : Toutes les opérations s'exécutent dans des conteneurs isolés

6. **Systèmes de mémoire**
   - Mémoire à long terme : Stockage persistant des connaissances et des expériences
   - Mémoire de travail : Contexte actif et objectifs pour les opérations en cours
   - Mémoire épisodique : Actions historiques et modèles de succès
   - Base de connaissances : Expertise de domaine structurée et capacités des outils
   - Gestion du contexte : Gère intelligemment les fenêtres de contexte LLM croissantes en utilisant le résumé par chaîne

Le système utilise des conteneurs Docker pour l'isolation et un déploiement facile, avec des réseaux séparés pour les services principaux, la surveillance et l'analyse afin de garantir des limites de sécurité appropriées. Chaque composant est conçu pour s'adapter horizontalement et peut être configuré pour une haute disponibilité dans les environnements de production.

## Démarrage rapide

### Configuration système requise

- Docker et Docker Compose (ou Podman - voir [Configuration Podman](#exécution-de-pentagi-avec-podman))
- Minimum 2 vCPU
- Minimum 4 Go de RAM
- 20 Go d'espace disque libre
- Accès Internet pour télécharger les images et les mises à jour

### Utilisation de l'installateur (Recommandé)

PentAGI fournit un installateur interactif avec une interface utilisateur en terminal pour une configuration et un déploiement simplifiés. L'installateur vous guide à travers les vérifications système, la configuration du fournisseur LLM, la configuration du moteur de recherche et le durcissement de la sécurité.

**Plateformes supportées :**
- **Linux** : amd64 [téléchargement](https://pentagi.com/downloads/linux/amd64/installer-latest.zip) | arm64 [téléchargement](https://pentagi.com/downloads/linux/arm64/installer-latest.zip)
- **Windows** : amd64 [téléchargement](https://pentagi.com/downloads/windows/amd64/installer-latest.zip)
- **macOS** : amd64 (Intel) [téléchargement](https://pentagi.com/downloads/darwin/amd64/installer-latest.zip) | arm64 (série M) [téléchargement](https://pentagi.com/downloads/darwin/arm64/installer-latest.zip)

**Installation rapide (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

Prérequis & autorisations :

L'installateur nécessite des privilèges appropriés pour interagir avec l'API Docker pour un bon fonctionnement. Par défaut, il utilise le socket Docker (/var/run/docker.sock) qui nécessite soit :

Option 1 (Recommandée pour la production) : Exécutez l'installateur en tant que root : ```bash sudo ./installer
Option 2 (environnements de développement) : Accordez à votre utilisateur l'accès au socket Docker en l'ajoutant au groupe docker : ```bash

Add your user to the docker group

sudo usermod -aG docker $USER

Log out and log back in, or activate the group immediately

newgrp docker

Verify Docker access (should run without sudo)

docker ps

⚠️ Note de sécurité : L'ajout d'un utilisateur au groupe docker octroie des privilèges équivalents à root. Ne faites cela que pour des utilisateurs de confiance dans des environnements contrôlés. Pour les déploiements en production, envisagez d'utiliser le mode Docker sans root (rootless) ou d'exécuter l'installateur avec sudo.

L'installateur va :

Vérifications système : Vérifier Docker, la connectivité réseau et les prérequis système
Configuration de l'environnement : Créer et configurer le fichier .env avec des valeurs par défaut optimales
Configuration des fournisseurs : Configurer les fournisseurs LLM (OpenAI, Anthropic, Gemini, Bedrock, Ollama, Personnalisé)
Moteurs de recherche : Configurer DuckDuckGo, Google, Tavily, Traversaal, Perplexity, Sploitus, Searxng
Renforcement de la sécurité : Générer des identifiants sécurisés et configurer les certificats SSL
Déploiement : Démarrer PentAGI avec docker-compose

Couverture actuelle des paramètres Web

La console Web de PentAGI gère déjà plusieurs zones de paramètres une fois le serveur en cours d'exécution :

Paramètres -> Fournisseurs : Créer, modifier, supprimer et tester des profils de fournisseur définis par l'utilisateur pour les types de fournisseurs pris en charge. Ces profils contrôlent la sélection du modèle par agent, les paramètres d'exécution, les options de raisonnement et les métadonnées de tarification.
Paramètres -> Prompts : Gérer les modèles de prompts système, humain et outil.
Paramètres -> API PentAGI : Créer et gérer les jetons Bearer PentAGI pour l'accès REST et GraphQL.
Autres préférences gérées par l'interface : Les flux favoris sont stockés comme préférences utilisateur, et la sélection du thème est gérée depuis la barre latérale principale/les contrôles de profil plutôt que depuis les pages de paramètres.

Toujours géré côté serveur

Les zones de configuration suivantes doivent encore être définies sur le serveur via des variables d'environnement, des fichiers compose ou des fichiers de configuration montés :

Identifiants LLM et détails de connexion : Clés API, points de terminaison, modes d'authentification et paramètres de connexion spécifiques au fournisseur pour OpenAI, Anthropic, Bedrock, Ollama, fournisseurs personnalisés et backends similaires ; les paramètres de chemin de configuration ne s'appliquent que là où ils sont pris en charge, comme OLLAMA_SERVER_CONFIG_PATH et LLM_SERVER_CONFIG_PATH.
Identifiants et options des fournisseurs de recherche : Paramètres tels que DUCKDUCKGO_*, GOOGLE_*, TAVILY_API_KEY, TRAVERSAAL_API_KEY, PERPLEXITY_*, SEARXNG_* et SPLOITUS_ENABLED.
Intégrations tierces : Langfuse, Graphiti et services externes similaires restent une configuration côté serveur.
Gestion du serveur MCP : Les pages de paramètres MCP ne sont actuellement pas exposées comme fonctionnalité de console Web en direct.

Pour la production et une sécurité renforcée :

Pour les déploiements en production ou les environnements sensibles à la sécurité, nous recommandons vivement d'utiliser une architecture distribuée à deux nœuds où les opérations des workers sont isolées sur un serveur distinct. Cela empêche l'exécution de code non fiable et les problèmes d'accès réseau sur votre système principal.

Voir le guide détaillé : Configuration du nœud worker

La configuration à deux nœuds fournit :

Exécution isolée : Les conteneurs worker s'exécutent sur du matériel dédié
Isolation réseau : Limites réseau séparées pour les tests de pénétration
Limites de sécurité : Docker-in-Docker avec authentification TLS
Support des attaques OOB : Plages de ports dédiées pour les techniques hors bande (OOB)

Installation manuelle

Créez un répertoire de travail ou clonez le dépôt :```bash mkdir pentagi && cd pentagi

2. Copiez `.env.example` vers `.env` ou téléchargez-le :```bash
curl -o .env https://raw.githubusercontent.com/vxcontrol/pentagi/master/.env.example

Créez les fichiers d'exemples (example.custom.provider.yml, example.ollama.provider.yml) ou téléchargez-les :```bash curl -o example.custom.provider.yml https://raw.githubusercontent.com/vxcontrol/pentagi/master/examples/configs/custom-openai.provider.yml curl -o example.ollama.provider.yml https://raw.githubusercontent.com/vxcontrol/pentagi/master/examples/configs/ollama-llama318b.provider.yml

4. Remplissez les clés API requises dans le fichier `.env`.```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

Modifiez toutes les variables d'environnement liées à la sécurité dans le fichier .env pour améliorer la sécurité.

Variables d'environnement liées à la sécurité

Paramètres de sécurité principaux

COOKIE_SIGNING_SALT - Sel pour la signature des cookies, remplacez-le par une valeur aléatoire
PUBLIC_URL - URL publique de votre serveur (ex. https://pentagi.example.com)
SERVER_SSL_CRT et SERVER_SSL_KEY - Chemins personnalisés vers votre certificat SSL et votre clé existants pour HTTPS (ces chemins doivent être utilisés dans le fichier docker-compose.yml pour les monter en volumes)

Accès au scraper

SCRAPER_PUBLIC_URL - URL publique du scraper si vous souhaitez utiliser un serveur scraper différent pour les URL publiques
SCRAPER_PRIVATE_URL - URL privée du scraper (serveur scraper local dans le fichier docker-compose.yml pour accéder aux URL locales)

Identifiants d'accès

et - Identifiants PostgreSQL

Supprimez tous les commentaires en ligne du fichier .env si vous souhaitez l'utiliser dans VSCode ou d'autres IDE comme option envFile :```bash perl -i -pe 's/\s+#.*$//' .env

7. Exécutez la pile PentAGI :```bash
curl -O https://raw.githubusercontent.com/vxcontrol/pentagi/master/docker-compose.yml
docker compose up -d

Visitez localhost:8443 pour accéder à l'interface Web de PentAGI (par défaut [email protected] / admin)

Comptes de l'interface Web

PentAGI n'expose pas d'inscription publique en libre-service depuis la page de connexion. Une installation fraîche crée le compte administrateur local par défaut :

Email : [email protected]
Mot de passe : admin

Lors de la première connexion, modifiez le mot de passe par défaut avant d'utiliser l'instance pour un travail réel. Si le mot de passe administrateur est perdu ultérieurement, utilisez le menu de maintenance de l'installateur pour réinitialiser le mot de passe du compte [email protected] par défaut.

Pour les configurations multi-utilisateurs, un administrateur authentifié peut gérer les utilisateurs locaux via l'API REST Users (/api/v1/users/). L'interface OpenAPI est disponible à l'adresse https://localhost:8443/api/v1/swagger/index.html une fois l'instance en cours d'exécution.

[!NOTE] Si vous rencontrez une erreur concernant pentagi-network ou observability-network ou langfuse-network, vous devez d'abord exécuter docker-compose.yml pour créer ces réseaux, puis exécuter docker-compose-langfuse.yml, docker-compose-graphiti.yml et docker-compose-observability.yml pour utiliser les services Langfuse, Graphiti et Observability.

Vous devez configurer au moins un fournisseur de modèle de langage (OpenAI, Anthropic, Gemini, AWS Bedrock ou Ollama) pour utiliser PentAGI. AWS Bedrock offre un accès de niveau entreprise à plusieurs modèles fondamentaux des principales entreprises d'IA, tandis qu'Ollama fournit une inférence locale sans coût si vous disposez de ressources de calcul suffisantes. Des clés API supplémentaires pour les moteurs de recherche sont facultatives mais recommandées pour de meilleurs résultats.

Pour un déploiement entièrement local avec des modèles avancés : Consultez notre guide complet sur Exécution de PentAGI avec vLLM et Qwen3.5-27B-FP8 pour une configuration LLM locale de qualité production. Cette configuration atteint ~13 000 TPS pour le traitement des invites et ~650 TPS pour la complétion sur 4× GPU RTX 5090, prenant en charge plus de 12 flux simultanés avec une indépendance totale vis-à-vis des fournisseurs de cloud.

Les variables d'environnement LLM_SERVER_* sont une fonctionnalité expérimentale et seront modifiées à l'avenir. Pour l'instant, vous pouvez les utiliser pour spécifier une URL de serveur LLM personnalisée et un modèle pour tous les types d'agents.

Accéder à PentAGI depuis des réseaux externes

Par défaut, PentAGI se lie à 127.0.0.1 (localhost uniquement) pour des raisons de sécurité. Pour accéder à PentAGI depuis d'autres machines de votre réseau, vous devez configurer l'accès externe.

Étapes de configuration

Mettez à jour le fichier .env avec l'adresse IP de votre serveur :```bash

Network binding - allow external connections

PENTAGI_LISTEN_IP=0.0.0.0 PENTAGI_LISTEN_PORT=8443

Public URL - use your actual server IP or hostname

Replace 192.168.1.100 with your server's IP address

PUBLIC_URL=https://192.168.1.100:8443

CORS origins - list all URLs that will access PentAGI

Include localhost for local access AND your server IP for external access

CORS_ORIGINS=https://localhost:8443,https://192.168.1.100:8443

> [!IMPORTANT]
> - Remplacez `192.168.1.100` par l'adresse IP réelle de votre serveur
> - N'utilisez PAS `0.0.0.0` dans `PUBLIC_URL` ou `CORS_ORIGINS` - utilisez l'adresse IP réelle
> - Incluez à la fois localhost et l'IP de votre serveur dans `CORS_ORIGINS` pour plus de flexibilité

2. **Recréez les conteneurs** pour appliquer les modifications :```bash
docker compose down
docker compose up -d --force-recreate

Vérifier la liaison de port:```bash docker ps | grep pentagi

Vous devriez voir `0.0.0.0:8443->8443/tcp` ou `:::8443->8443/tcp`.

Si vous voyez `127.0.0.1:8443->8443/tcp`, la variable d'environnement n'a pas été prise en compte. Dans ce cas, éditez directement la ligne 31 de `docker-compose.yml` :```yaml
ports:
  - "0.0.0.0:8443:8443"

Recréez ensuite les conteneurs à nouveau.

Configurez le pare-feu pour autoriser les connexions entrantes sur le port 8443 :```bash

Ubuntu/Debian with UFW

sudo ufw allow 8443/tcp sudo ufw reload

CentOS/RHEL with firewalld

sudo firewall-cmd --permanent --add-port=8443/tcp sudo firewall-cmd --reload

5. **Accès à PentAGI :**

- **Accès local :** `https://localhost:8443`
- **Accès réseau :** `https://your-server-ip:8443`

> [!NOTE]
> Vous devrez accepter l'avertissement concernant le certificat SSL auto-signé dans votre navigateur lors de l'accès via une adresse IP.

---

### Exécuter PentAGI avec Podman

PentAGI prend pleinement en charge Podman comme alternative à Docker. Cependant, lors de l'utilisation de **Podman en mode rootless**, le service scraper nécessite une configuration spéciale car les conteneurs rootless ne peuvent pas lier les ports privilégiés (ports en dessous de 1024).

#### Configuration rootless de Podman

La configuration par défaut du scraper utilise le port 443 (HTTPS), qui est un port privilégié. Pour Podman en mode rootless, reconfigurez le scraper pour utiliser un port non privilégié :

**1. Modifiez `docker-compose.yml`** - modifiez le service `scraper` (vers la ligne 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

2. Mettez à jour le fichier .env - changez l'URL du scraper pour utiliser HTTP et le port 3000 :```bash

Scraper configuration for Podman rootless

SCRAPER_PRIVATE_URL=http://someuser:somepass@scraper:3000/ LOCAL_SCRAPER_USERNAME=someuser LOCAL_SCRAPER_PASSWORD=somepass

> [!IMPORTANT]
> Modifications clés pour Podman :
> - Utilisez **HTTP** au lieu de HTTPS pour `SCRAPER_PRIVATE_URL`
> - Utilisez le port **3000** au lieu de 443
> - Changez l'`expose` interne en `3000/tcp`
> - Mettez à jour le mappage de ports pour cibler `3000` au lieu de `443`

**3. Recréer les conteneurs :**```bash
podman-compose down
podman-compose up -d --force-recreate

4. Tester la connectivité du scraper :```bash

Test from within the pentagi container

podman exec -it pentagi wget -O- "http://someuser:somepass@scraper:3000/html?url=http://example.com"

Si vous voyez une sortie HTML, le scraper fonctionne correctement.

#### Mode Rootful de Podman

Si vous exécutez Podman en mode rootful (avec sudo), vous pouvez utiliser la configuration par défaut sans modifications. Le scraper fonctionnera sur le port 443 comme prévu.

#### Compatibilité Docker

Toutes les configurations Podman restent entièrement compatibles avec Docker. L'approche du port non privilégié fonctionne à l'identique sur les deux environnements d'exécution de conteneurs.

### Configuration de l'assistant

PentAGI vous permet de configurer le comportement par défaut des assistants :

| Variable               | Défaut | Description                                                             |
| ---------------------- | ------- | ----------------------------------------------------------------------- |
| `ASSISTANT_USE_AGENTS` | `false` | Contrôle la valeur par défaut pour l'utilisation des agents lors de la création de nouveaux assistants |

Le paramètre `ASSISTANT_USE_AGENTS` affecte l'état initial du bouton « Utiliser les agents » lors de la création d'un nouvel assistant dans l'interface utilisateur :
- `false` (par défaut) : Les nouveaux assistants sont créés avec la délégation d'agents désactivée par défaut
- `true` : Les nouveaux assistants sont créés avec la délégation d'agents activée par défaut

Notez que les utilisateurs peuvent toujours remplacer ce paramètre en basculant le bouton « Utiliser les agents » dans l'interface utilisateur lors de la création ou de la modification d'un assistant. Cette variable d'environnement ne contrôle que l'état par défaut initial.

## Comment utiliser PentAGI après la connexion

Une fois la pile en fonctionnement et que vous pouvez vous connecter à l'interface web, la manière la plus rapide de commencer est via le workflow Flows.

### 1. Créez votre premier flux

1. Ouvrez **Flows** dans la barre latérale.
2. Cliquez sur **Nouveau flux**.
3. Choisissez le mode qui correspond à votre objectif :
   - **Automation** : exécution entièrement autonome pour un objectif de test que vous souhaitez que PentAGI effectue de bout en bout
   - **Assistant** : aide interactive aller-retour lorsque vous souhaitez diriger l'enquête étape par étape. Dans ce mode, vous pouvez également activer le bouton **Utiliser les agents** pour permettre à PentAGI de déléguer des sous-tâches à des sous-agents spécialisés pour des enquêtes plus complexes.
4. Sélectionnez le fournisseur LLM que vous souhaitez utiliser pour ce flux.
5. Décrivez la cible et l'objectif en langage naturel dans la zone de message.

Les bons premiers messages incluent généralement :

- le système cible ou l'URL
- le type d'évaluation souhaité
- les limitations de périmètre ou les règles d'engagement
- le résultat attendu, tel qu'un rapport de vulnérabilité ou la validation d'une hypothèse

Exemple :```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.

Testez uniquement les systèmes que vous possédez ou pour lesquels vous êtes explicitement autorisé à effectuer une évaluation. Consultez EULA.md pour les conditions d'utilisation acceptables.

2. Utiliser des modèles pour des flux de travail reproductibles

Le nouveau formulaire de flux comprend un sélecteur de modèles, qui peut pré-remplir la boîte de message avec un modèle de flux sauvegardé. Cela est utile lorsque vous réalisez des évaluations similaires de manière répétée.

Utilisez un modèle existant si vous en avez déjà un sauvegardé dans Modèles
Partez de l'exemple de prompt dans examples/prompts/base_web_pentest.md si vous avez besoin d'une base pratique pour les tests web
Ajustez la cible, le périmètre et les contraintes avant de démarrer le flux

Les modèles sont des points de départ. Vous n'avez pas besoin de syntaxe spéciale pour utiliser PentAGI : des instructions en langage naturel simple fonctionnent bien tant que la cible et l'objectif sont clairs.

3. Surveiller l'exécution et examiner les résultats

Après avoir soumis le flux, PentAGI ouvre automatiquement la page du flux.

Utilisez la vue principale du flux pour suivre les messages, l'activité des agents et la progression des tâches
Inspectez l'activité des outils et la sortie du terminal pendant l'exécution du flux
Examinez les tâches et sous-tâches générées pour comprendre ce que fait PentAGI

Une fois que le flux a suffisamment de résultats, utilisez le menu Rapport sur la page du flux pour :

ouvrir le rapport dans une vue web
copier le rapport généré dans le presse-papiers
télécharger le rapport au format Markdown
télécharger le rapport au format PDF

4. Utiliser la vue Assistant pour piloter un flux actif

Chaque flux comprend également une vue Assistant pour un guidage interactif. Cela est utile lorsque l'exécution autonome découvre quelque chose nécessitant une direction humaine plutôt qu'un redémarrage complet.

Ouvrez la vue Assistant pour le même flux lorsque vous souhaitez inspecter l'état actuel avant de modifier quoi que ce soit.
Utilisez l'assistant pour vérifier l'état du flux, arrêter la tâche en cours, soumettre des instructions de suivi ou modifier les sous-tâches planifiées restantes avant l'exécution de l'étape suivante.
Considérez cela comme un chemin de contrôle explicite pour le flux actuel, et non comme une file d'attente invisible en arrière-plan. Si vous souhaitez changer de direction, dites-le clairement et reliez la nouvelle instruction au périmètre de l'engagement en cours.
Cela fonctionne le mieux pour clarifier le périmètre, rediriger les priorités après des résultats intermédiaires, ou répondre à un point de contrôle d'automatisation sans perdre le reste du contexte du flux.

5. Gérer les fichiers liés au flux

Chaque flux possède son propre onglet Fichiers dans la page du flux. Les fichiers sont limités au flux parent : ils résident dans {dataDir}/flow-{id}-data/ sur l'hôte et ne fuient jamais vers d'autres flux.

L'onglet expose trois sources de fichiers :

Téléversements (uploads/) : fichiers que vous fournissez depuis l'interface web. Utilisez l'action Téléverser des fichiers ou faites glisser-déposer directement sur l'onglet Fichiers. Pendant que le conteneur de l'agent est en cours d'exécution, les fichiers téléversés sont également poussés dans celui-ci à /work/uploads/ afin que l'agent puisse les lire avec les outils shell normaux.
Ressources (resources/) : fichiers attachés depuis votre bibliothèque de ressources utilisateur sauvegardée via Attacher des ressources depuis la bibliothèque. Les ressources attachées sont copiées dans le flux et poussées dans le conteneur en cours d'exécution à /work/resources/.
Conteneur (container/) : instantanés extraits du conteneur de l'agent en cours d'exécution via Extraire un fichier ou un répertoire du conteneur. Ceux-ci sont en lecture seule côté flux et ne sont jamais renvoyés vers le conteneur.

Les actions par fichier dans l'onglet Fichiers incluent Télécharger, Copier le chemin, Enregistrer comme ressource (promouvoir un fichier de flux dans votre bibliothèque de ressources réutilisables) et Supprimer. L'action Extraire est désactivée lorsque le conteneur n'est pas en cours d'exécution, avec l'info-bulle « Le conteneur ne fonctionne pas ».

Les fichiers téléversés et les ressources attachées sont listés automatiquement dans les invites système de l'agent via la variable de modèle {{.UserFiles}}, qui génère un bloc XML compact <task_files> (avec des sections <uploads> et <resources> imbriquées), de sorte que l'assistant et les agents d'automatisation puissent les référencer par chemin sans que vous ayez à coller le contenu dans le chat. Les instantanés de conteneur sont visibles uniquement dans l'interface utilisateur et ne sont pas réinjectés automatiquement dans l'invite.

Limites et restrictions actuelles à prendre en compte :

La taille maximale des fichiers téléversés est de 300 Mo ; par demande de téléversement, jusqu'à 1 000 fichiers et 2 Go au total. Les noms de fichiers sont limités à 255 octets (environ 255 caractères ASCII ; les noms non ASCII utilisent plusieurs octets par caractère).
Les téléversements et les ressources sont répliqués dans le conteneur en cours d'exécution aux chemins fixes /work/uploads/ et /work/resources/ ; les fichiers écrits dans d'autres chemins du conteneur ne sont pas automatiquement répliqués dans le modèle de fichiers du flux. Les instantanés de conteneur peuvent provenir de n'importe quel chemin de conteneur que vous extrayez (par exemple /etc/...) et sont mis en cache côté flux sous container/ ; ils ne sont pas repoussés dans le conteneur.
Les instantanés de conteneur sont des extractions ponctuelles. Modifier un instantané dans l'interface utilisateur ne l'écrit pas dans le conteneur en cours d'exécution.
Supprimer un flux aujourd'hui supprime l'enregistrement du flux et ses entrées de mémoire à long terme, mais n'archive ni ne supprime encore le répertoire flow-{id}-data/ du flux sur le disque. Les opérateurs doivent toujours nettoyer manuellement le répertoire de données s'ils souhaitent récupérer l'espace.

Pour les tests précoces, commencez par une cible étroite et un seul objectif clair. Cela rend les résultats plus faciles à examiner et vous aide à affiner vos invites avant d'exécuter des évaluations plus importantes.

Accès API

PentAGI offre un accès programmatique complet via les API REST et GraphQL, vous permettant d'intégrer les flux de travail de tests de pénétration dans vos pipelines d'automatisation, vos processus CI/CD et vos applications personnalisées.

Génération de jetons API

Les jetons API sont gérés via l'interface web de PentAGI :

Accédez à Paramètres → Jetons API dans l'interface web
Cliquez sur Créer un jeton pour générer un nouveau jeton API
Configurez les propriétés du jeton :
- Nom (optionnel) : Un nom descriptif pour le jeton
- Date d'expiration : Quand le jeton expirera (minimum 1 minute, maximum 3 ans)
Cliquez sur Créer et copiez le jeton immédiatement - il ne sera affiché qu'une seule fois pour des raisons de sécurité
Utilisez le jeton comme jeton Bearer dans vos requêtes API

Chaque jeton est associé à votre compte utilisateur et hérite des permissions de votre rôle.

Utilisation des jetons API

Incluez le jeton API dans l'en-tête Authorization de vos requêtes HTTP :```bash

GraphQL API example

curl -X POST https://your-pentagi-instance:8443/api/v1/graphql
-H "Authorization: Bearer YOUR_API_TOKEN"
-H "Content-Type: application/json"
-d '{"query": "{ flows { id title status } }"}'

REST API example

curl https://your-pentagi-instance:8443/api/v1/flows
-H "Authorization: Bearer YOUR_API_TOKEN"

### Exploration et test d'API

PentAGI fournit une documentation interactive pour explorer et tester les endpoints d'API :

#### GraphQL Playground

Accédez au GraphQL Playground à l'adresse `https://your-pentagi-instance:8443/api/v1/graphql/playground`

1. Cliquez sur l'onglet **HTTP Headers** en bas
2. Ajoutez votre authorization header :   ```json
   {
     "Authorization": "Bearer YOUR_API_TOKEN"
   }

Explorez le schéma, exécutez des requêtes et testez les mutations de manière interactive

Swagger UI

Accédez à la documentation de l'API REST à l'adresse https://your-pentagi-instance:8443/api/v1/swagger/index.html

Cliquez sur le bouton Authorize
Saisissez votre jeton au format : Bearer YOUR_API_TOKEN
Cliquez sur Authorize pour appliquer
Testez les points de terminaison directement depuis l'interface Swagger UI

Génération de clients API

Vous pouvez générer des clients API sécurisés par typage pour votre langage de programmation préféré en utilisant les fichiers de schéma inclus avec PentAGI :

Clients GraphQL

Le schéma GraphQL est disponible à :

Interface Web : Naviguez vers Paramètres pour télécharger schema.graphqls
Fichier direct : backend/pkg/graph/schema.graphqls dans le dépôt

Générez des clients à l'aide d'outils comme :

GraphQL Code Generator (JavaScript/TypeScript) : https://the-guild.dev/graphql/codegen
genqlient (Go) : https://github.com/Khan/genqlient
Apollo iOS (Swift) : https://www.apollographql.com/docs/ios

Clients API REST

La spécification OpenAPI est disponible à :

Swagger JSON : https://your-pentagi-instance:8443/api/v1/swagger/doc.json
Swagger YAML : Disponible dans backend/pkg/server/docs/swagger.yaml

Générez des clients en utilisant :

OpenAPI Generator : https://openapi-generator.tech ```bash openapi-generator-cli generate
-i https://your-pentagi-instance:8443/api/v1/swagger/doc.json
-g python
-o ./pentagi-client
Swagger Codegen: https://github.com/swagger-api/swagger-codegen ```bash swagger-codegen generate
-i https://your-pentagi-instance:8443/api/v1/swagger/doc.json
-l typescript-axios
-o ./pentagi-client
swagger-typescript-api (TypeScript): https://github.com/acacode/swagger-typescript-api ```bash npx swagger-typescript-api
-p https://your-pentagi-instance:8443/api/v1/swagger/doc.json
-o ./src/api
-n pentagi-api.ts

Exemples d'utilisation de l'API

Créer un nouveau flux (GraphQL)

```graphql mutation CreateFlow { createFlow( modelProvider: "openai" input: "Test the security of https://example.com" ) { id title status createdAt } } ```

Liste des flux (API REST)

```bash curl https://your-pentagi-instance:8443/api/v1/flows \ -H "Authorization: Bearer YOUR_API_TOKEN" \ | jq '.flows[] | {id, title, status}' ```

Exemple de client Python

```python import requests

class PentAGIClient: def init(self, base_url, api_token): self.base_url = base_url self.headers = { "Authorization": f"Bearer {api_token}", "Content-Type": "application/json" }

def create_flow(self, provider, target):
    query = """
    mutation CreateFlow($provider: String!, $input: String!) {
      createFlow(modelProvider: $provider, input: $input) {
        id
        title
        status
      }
    }
    """
    response = requests.post(
        f"{self.base_url}/api/v1/graphql",
        json={
            "query": query,
            "variables": {
                "provider": provider,
                "input": target
            }
        },
        headers=self.headers
    )
    return response.json()

def get_flows(self):
    response = requests.get(
        f"{self.base_url}/api/v1/flows",
        headers=self.headers
    )
    return response.json()

Usage

client = PentAGIClient( "https://your-pentagi-instance:8443", "your_api_token_here" )

Create a new flow

flow = client.create_flow("openai", "Scan https://example.com for vulnerabilities") print(f"Created flow: {flow}")

List all flows

flows = client.get_flows() print(f"Total flows: {len(flows['flows'])}")

</details>

<details>
<summary><b>Exemple de client TypeScript</b></summary>```typescript
import axios, { AxiosInstance } from 'axios';

interface Flow {
  id: string;
  title: string;
  status: string;
  createdAt: string;
}

class PentAGIClient {
  private client: AxiosInstance;

  constructor(baseURL: string, apiToken: string) {
    this.client = axios.create({
      baseURL: `${baseURL}/api/v1`,
      headers: {
        'Authorization': `Bearer ${apiToken}`,
        'Content-Type': 'application/json',
      },
    });
  }

  async createFlow(provider: string, input: string): Promise<Flow> {
    const query = `
      mutation CreateFlow($provider: String!, $input: String!) {
        createFlow(modelProvider: $provider, input: $input) {
          id
          title
          status
          createdAt
        }
      }
    `;

    const response = await this.client.post('/graphql', {
      query,
      variables: { provider, input },
    });

    return response.data.data.createFlow;
  }

  async getFlows(): Promise<Flow[]> {
    const response = await this.client.get('/flows');
    return response.data.flows;
  }

  async getFlow(flowId: string): Promise<Flow> {
    const response = await this.client.get(`/flows/${flowId}`);
    return response.data;
  }
}

// Usage
const client = new PentAGIClient(
  'https://your-pentagi-instance:8443',
  'your_api_token_here'
);

// Create a new flow
const flow = await client.createFlow(
  'openai',
  'Perform penetration test on https://example.com'
);
console.log('Created flow:', flow);

// List all flows
const flows = await client.getFlows();
console.log(`Total flows: ${flows.length}`);

Bonnes pratiques de sécurité

Lorsque vous travaillez avec des jetons API :

Ne jamais commettre les jetons dans le contrôle de version - utilisez des variables d'environnement ou une gestion des secrets
Renouvelez les jetons régulièrement - définissez des dates d'expiration appropriées et créez périodiquement de nouveaux jetons
Utilisez des jetons distincts pour différentes applications - facilite la révocation d'accès si nécessaire
Surveillez l'utilisation des jetons - examinez l'activité des jetons API dans la page Paramètres
Révoquez les jetons inutilisés - désactivez ou supprimez les jetons qui ne sont plus nécessaires
Utilisez uniquement HTTPS - n'envoyez jamais de jetons API sur des connexions non chiffrées

Gestion des jetons

Afficher les jetons : consultez tous vos jetons actifs dans Paramètres → Jetons API
Modifier les jetons : mettez à jour les noms des jetons ou révoquez des jetons
Supprimer les jetons : supprimez définitivement des jetons (cette action est irréversible)
ID du jeton : chaque jeton possède un identifiant unique qui peut être copié pour référence

La liste des jetons affiche :

Nom du jeton (si fourni)
ID du jeton (identifiant unique)
Statut (actif/révoqué/expiré)
Date de création
Date d'expiration

Configuration personnalisée du fournisseur LLM

Lorsque vous utilisez des fournisseurs LLM personnalisés avec les variables LLM_SERVER_*, vous pouvez affiner le format de raisonnement utilisé dans les requêtes.

[!TIP] Pour les déploiements locaux de niveau production, envisagez d'utiliser vLLM avec Qwen3.5-27B-FP8 pour des performances optimales. Consultez notre guide de déploiement complet qui comprend les exigences matérielles, les modèles de configuration (mode réflexion et mode sans réflexion), ainsi que des benchmarks de performance montrant un traitement de 13K TPS sur 4 × GPU RTX 5090.

Le paramètre LLM_SERVER_PROVIDER est particulièrement utile lorsque vous utilisez le proxy LiteLLM, qui ajoute un préfixe de fournisseur aux noms de modèles. Par exemple, lors de la connexion à l'API Moonshot via LiteLLM, les modèles comme kimi-2.5 deviennent moonshot/kimi-2.5. En définissant LLM_SERVER_PROVIDER=moonshot, vous pouvez utiliser le même fichier de configuration du fournisseur pour l'accès direct à l'API et l'accès via le proxy LiteLLM sans modifications.

Le paramètre LLM_SERVER_LEGACY_REASONING affecte la façon dont les paramètres de raisonnement sont envoyés au LLM :

false (par défaut) : utilise le format moderne où le raisonnement est envoyé comme un objet structuré avec le paramètre max_tokens
true : utilise le format hérité avec le paramètre reasoning_effort sous forme de chaîne

Ce paramètre est important lorsque vous travaillez avec différents fournisseurs LLM car ils peuvent s'attendre à des formats de raisonnement différents dans leurs requêtes API. Si vous rencontrez des erreurs liées au raisonnement avec des fournisseurs personnalisés, essayez de modifier ce paramètre.

Le paramètre LLM_SERVER_PRESERVE_REASONING contrôle si le contenu du raisonnement est conservé dans les conversations multitours :

false (par défaut) : le contenu du raisonnement n'est pas conservé dans l'historique de la conversation
true : le contenu du raisonnement est conservé et envoyé dans les appels API ultérieurs

Ce paramètre est requis par certains fournisseurs LLM (ex. Moonshot) qui renvoient des erreurs comme « thinking is enabled but reasoning_content is missing in assistant tool call message » lorsque le contenu du raisonnement n'est pas inclus dans les conversations multitours. Activez ce paramètre si votre fournisseur nécessite la conservation du contenu du raisonnement.

Configuration du fournisseur Ollama

PentAGI prend en charge Ollama pour l'inférence LLM locale (coût zéro, confidentialité renforcée) et Ollama Cloud (service géré avec un niveau gratuit).

Variables de configuration

Configuration d'Ollama Cloud

Ollama Cloud fournit une inférence gérée avec un niveau gratuit généreux et des forfaits payants évolutifs.

Configuration du niveau gratuit (modèle unique)```bash

Free tier allows one model at a time

OLLAMA_SERVER_URL=https://ollama.com OLLAMA_SERVER_API_KEY=your_ollama_cloud_api_key OLLAMA_SERVER_MODEL=gpt-oss:120b # Example: OpenAI OSS 120B model

**Forfait payant (Multi-modèle avec configuration préconstruite)**

Pour les forfaits payants prenant en charge plusieurs modèles simultanément, utilisez la configuration préconstruite Ollama Cloud :```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

La configuration pré-intégrée ollama-cloud.provider.yml inclut des attributions de modèles optimisées pour tous les types d'agents :

Simple/Assistant : nemotron-3-super:cloud - Modèle polyvalent rapide
Agent principal : qwen3-coder-next:cloud - Raisonnement avancé avec mode haute intensité
Codeur/Pentester : qwen3-coder-next:cloud - Modèles de codage spécialisés
Chercheur : qwen3.5:397b-cloud - Grand contexte pour la collecte d'informations
Reformulateur/Refactor : glm-5:cloud - Raffinement de texte de haute qualité
Conseiller/Enrichisseur : minimax-m2.7:cloud - Tâches de conseil efficaces
Installeur : devstral-2:123b-cloud - Tâches d'installation et de configuration

Configuration personnalisée (Avancé)

Pour créer votre propre configuration d'agent, montez un fichier personnalisé depuis votre système de fichiers hôte :```bash

Using custom provider configuration

OLLAMA_SERVER_URL=https://ollama.com OLLAMA_SERVER_API_KEY=your_ollama_cloud_api_key OLLAMA_SERVER_CONFIG_PATH=/opt/pentagi/conf/ollama.provider.yml

Mount custom configuration from host filesystem (in .env or docker-compose override)

PENTAGI_OLLAMA_SERVER_CONFIG_PATH=/path/on/host/my-ollama-config.yml

La variable d'environnement `PENTAGI_OLLAMA_SERVER_CONFIG_PATH` mappe votre fichier de configuration hôte vers `/opt/pentagi/conf/ollama.provider.yml` à l'intérieur du conteneur.

**Exemple de configuration personnalisée** (`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

Configuration locale d'Ollama

Pour les instances Ollama auto-hébergées :```bash

Basic local Ollama setup

OLLAMA_SERVER_URL=http://localhost:11434 OLLAMA_SERVER_MODEL=llama3.1:8b-instruct-q8_0

Production setup with auto-pull and model discovery

OLLAMA_SERVER_URL=http://ollama-server:11434 OLLAMA_SERVER_PULL_MODELS_ENABLED=true OLLAMA_SERVER_PULL_MODELS_TIMEOUT=900 OLLAMA_SERVER_LOAD_MODELS_ENABLED=true

Using pre-built configurations from Docker image

OLLAMA_SERVER_CONFIG_PATH=/opt/pentagi/conf/ollama-llama318b.provider.yml

or

OLLAMA_SERVER_CONFIG_PATH=/opt/pentagi/conf/ollama-qwen332b-fp16-tc.provider.yml

or

OLLAMA_SERVER_CONFIG_PATH=/opt/pentagi/conf/ollama-qwq32b-fp16-tc.provider.yml

**Performance Considerations:**

- **Model Discovery** (`OLLAMA_SERVER_LOAD_MODELS_ENABLED=true`) : Ajoute 1 à 2 secondes de latence au démarrage en interrogeant l'API Ollama
- **Auto-pull** (`OLLAMA_SERVER_PULL_MODELS_ENABLED=true`) : Le premier démarrage peut prendre plusieurs minutes pour télécharger les modèles
- **Pull timeout** (`OLLAMA_SERVER_PULL_MODELS_TIMEOUT=900`) : 15 minutes en secondes
- **Static Config** : Désactivez les deux indicateurs et spécifiez les modèles dans le fichier de configuration pour un démarrage plus rapide

#### Création de modèles Ollama personnalisés avec contexte étendu

PentAGI nécessite des modèles avec des fenêtres de contexte plus grandes que les configurations par défaut d'Ollama. Vous devez créer des modèles personnalisés avec un paramètre `num_ctx` accru via des Modelfiles. Alors que les workflows d'agents typiques consomment environ 64K jetons, PentAGI utilise une taille de contexte de 110K pour une marge de sécurité et pour gérer des scénarios complexes de tests de pénétration.

**Important** : Le paramètre `num_ctx` ne peut être défini que lors de la création du modèle via Modelfile - il ne peut être modifié après la création du modèle ou remplacé lors de l'exécution.

##### Exemple : Qwen3 32B FP16 avec contexte étendu

Créez un Modelfile nommé `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

Construire le modèle personnalisé :```bash ollama create qwen3:32b-fp16-tc -f Modelfile_qwen3_32b_fp16_tc

##### Exemple : QwQ 32B FP16 avec contexte étendu

Créez un Modelfile nommé `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

Construire le modèle personnalisé :```bash ollama create qwq:32b-fp16-tc -f Modelfile_qwq_32b_fp16_tc

> **Remarque** : Le modèle QwQ 32B FP16 nécessite environ **71.3 Go de VRAM** pour l'inférence. Assurez-vous que votre système dispose de suffisamment de mémoire GPU avant de tenter d'utiliser ce modèle.

Ces modèles personnalisés sont référencés dans les fichiers de configuration du fournisseur préconstruits (`ollama-qwen332b-fp16-tc.provider.yml` et `ollama-qwq32b-fp16-tc.provider.yml`) qui sont inclus dans l'image Docker sous `/opt/pentagi/conf/`.

### Configuration du fournisseur OpenAI

PentAGI s'intègre à la gamme complète de modèles d'OpenAI, offrant des capacités de raisonnement avancées avec une chaîne de pensée étendue, des modèles agentiques avec une intégration d'outils améliorée, et des modèles de code spécialisés pour l'ingénierie de la sécurité.

#### Variables de configuration

| Variable             | Par défaut                  | Description                 |
| -------------------- | --------------------------- | --------------------------- |
| `OPEN_AI_KEY`        |                             | Clé API pour les services OpenAI |
| `OPEN_AI_SERVER_URL` | `https://api.openai.com/v1` | Point de terminaison de l'API OpenAI |

#### Exemples de configuration```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

Modèles pris en charge

PentAGI prend en charge 31 modèles OpenAI avec appel d'outils, streaming, modes de raisonnement et mise en cache des invites. Les modèles marqués d'un * sont utilisés dans la configuration par défaut.

Série GPT-5.2 - Dernier modèle phare agentique (décembre 2025)

Série GPT-5/5.1 - Modèles agentiques avancés

Série Codex GPT-5/5.1 - Spécialisée dans le code

Série GPT-4.1 - Intelligence améliorée

Série GPT-4o - Modèle phare multimodal

Model ID	Thinking	Price (Input/Output/Cache)	Use Case
`gpt-4o`	❌	$2.50/$10.00/$1.25

Série o - Modèles de raisonnement avancés

Prix : Par 1M de tokens. Les modèles de raisonnement incluent les tokens de réflexion dans le prix de sortie.

[!WARNING] Modèles GPT-5 - Accès de confiance requis*

Tous les modèles de la série GPT-5 (gpt-5, gpt-5.1, gpt-5.2, gpt-5-pro, gpt-5.2-pro et toutes les variantes Codex) fonctionnent de manière instable avec PentAGI et peuvent déclencher les mécanismes de sécurité cybersécurité d'OpenAI sans accès vérifié.

Pour utiliser les modèles GPT-5 de manière fiable :*

Utilisateurs individuels : Vérifiez votre identité sur chatgpt.com/cyber

Équipes d'entreprise : Demandez un accès de confiance via votre représentant OpenAI

Chercheurs en sécurité : Postulez au Programme de subventions en cybersécurité (comprend 10 millions de dollars en crédits API)

Alternatives recommandées sans vérification :

Utilisez les modèles de la série o (o3, o4-mini, o1) pour les tâches de raisonnement

Utilisez la série gpt-4.1 pour l'intelligence générale et l'appel de fonctions

Tous les modèles de la série o et gpt-4.x fonctionnent de manière fiable sans accès spécial

Niveaux d'effort de raisonnement :

Élevé : Profondeur de raisonnement maximale (refiner - o3 avec effort élevé)
Moyen : Raisonnement équilibré (primary_agent, assistant, reflector - o4-mini/o3 avec effort moyen)
Faible : Raisonnement ciblé efficace (coder, installer, pentester - o3/o4-mini avec effort faible ; adviser - gpt-5.2 avec effort faible)

Fonctionnalités clés :

Raisonnement étendu : Modèles de la série o avec chaîne de pensée pour une analyse de sécurité complexe
Intelligence agentique : Série GPT-5/5.1/5.2 avec intégration d'outils améliorée et capacités autonomes
Mise en cache des invites : Réduction des coûts sur le contexte répété (10-50 % du prix d'entrée)
Spécialisation dans le code : Modèles Codex dédiés pour la découverte de vulnérabilités et le développement d'exploits
Support multimodal : Série GPT-4o pour les évaluations de sécurité basées sur la vision
Appel d'outils : Appel de fonctions robuste sur tous les modèles pour l'orchestration d'outils de pentesting
Streaming : Diffusion en continu des réponses en temps réel pour des flux de travail interactifs
Bilan éprouvé : Modèles leaders de l'industrie avec découvertes de CVE et applications de sécurité réelles

Configuration du fournisseur Anthropic

PentAGI s'intègre aux modèles Claude d'Anthropic, offrant des capacités de réflexion étendue avancées, des mécanismes de sécurité exceptionnels et une compréhension sophistiquée des contextes de sécurité complexes avec mise en cache des invites.

Variables de configuration

Variable	Default	Description
`ANTHROPIC_API_KEY`		Clé API pour les services Anthropic
`ANTHROPIC_SERVER_URL`	`https://api.anthropic.com/v1`	Point de terminaison de l'API Anthropic

Exemples de configuration```bash

Basic Anthropic setup

ANTHROPIC_API_KEY=your_anthropic_api_key ANTHROPIC_SERVER_URL=https://api.anthropic.com/v1

Using with proxy for secure environments

ANTHROPIC_API_KEY=your_anthropic_api_key PROXY_URL=http://your-proxy:8080

> [!NOTE]
> **Google Vertex AI pour les modèles Claude**
>
> PentAGI n'expose pas actuellement de chemin de configuration Google Vertex AI dédié pour Anthropic Claude dans `.env`. Il n'y a pas de champ de clé API Vertex AI distinct pour le moment, et les variables Anthropic existantes (`ANTHROPIC_API_KEY`, `ANTHROPIC_SERVER_URL`) ciblent l'API Anthropic directe. Les routes prises en charge pour Claude sont :
>
> - **API Anthropic directe** : `ANTHROPIC_API_KEY` et `ANTHROPIC_SERVER_URL` (voir ci-dessus).
> - **AWS Bedrock** : variables `BEDROCK_*` (voir [Configuration du fournisseur AWS Bedrock](#aws-bedrock-provider-configuration)).
>
> Si vous devez utiliser Vertex AI aujourd'hui, la solution de contournement prise en charge la plus sûre est d'exposer Vertex AI via un proxy ou une passerelle compatible OpenAI qui traduit les appels Vertex AI au format Chat Completions tout en préservant le comportement de chat et d'appel d'outil sur lequel PentAGI s'appuie, puis de pointer le fournisseur LLM personnalisé vers cette passerelle via `LLM_SERVER_URL`, `LLM_SERVER_KEY` et `LLM_SERVER_MODEL`. Cette voie n'est aussi fiable que la passerelle que vous choisissez.

#### Modèles pris en charge

PentAGI prend en charge 10 modèles Claude avec appel d'outil, streaming, réflexion étendue, réflexion adaptative et mise en cache des invites. Les modèles marqués d'un `*` sont utilisés dans la configuration par défaut.

**Série Claude 4 - Derniers modèles (2025-2026)**

| ID du modèle            | Réflexion | Date de sortie | Prix (Entrée/Sortie/Cache R/W) | Cas d'utilisation                                   |
| ----------------------- | --------- | -------------- | ------------------------------ | --------------------------------------------------- |
| `claude-opus-4-6`*      | ✅         | Mai 2025       | $5.00/$25.00/$0.50/$6.25       | Modèle le plus intelligent pour les agents autonomes et le codage. Réflexion étendue + adaptative pour le développement d'exploits complexes, simulation d'attaques multi-étapes |
| `claude-sonnet-4-6`*    | ✅         | Août 2025      | $3.00/$15.00/$0.30/$3.75       | Meilleur équilibre vitesse/intelligence avec réflexion adaptative. Évaluations de sécurité multi-phases, analyse intelligente des vulnérabilités, chasse aux menaces en temps réel |
| `claude-haiku-4-5`*     | ✅         | Oct 2025       | $1.00/$5.00/$0.10/$1.25        | Modèle le plus rapide avec une intelligence quasi-frontalière. Analyse à haute fréquence, surveillance en temps réel, tests automatisés en masse |

**Modèles hérités - Toujours pris en charge**

| ID du modèle            | Réflexion | Date de sortie | Prix (Entrée/Sortie/Cache R/W) | Cas d'utilisation                                   |
| ----------------------- | --------- | -------------- | ------------------------------ | --------------------------------------------------- |
| `claude-sonnet-4-5`     | ✅         | Sep 2025       | $3.00/$15.00/$0.30/$3.75       | Raisonnement de pointe (remplacé par 4-6). Tests d'intrusion sophistiqués, analyse avancée des menaces |
| `claude-opus-4-5`       | ✅         | Nov 2025       | $5.00/$25.00/$0.50/$6.25       | Raisonnement ultime (remplacé par opus-4-6). Recherche critique en sécurité, découverte de zero-day, opérations d'équipe rouge |
| `claude-opus-4-1`       | ✅         | Août 2025      | $15.00/$75.00/$1.50/$18.75     | Raisonnement avancé (remplacé). Tests d'intrusion complexes, modélisation sophistiquée des menaces |
| `claude-sonnet-4-0`     | ✅         | Mai 2025       | $3.00/$15.00/$0.30/$3.75       | Raisonnement haute performance (remplacé). Modélisation complexe des menaces, coordination multi-outils |
| `claude-opus-4-0`       | ✅         | Mai 2025       | $15.00/$75.00/$1.50/$18.75     | Première génération Opus (remplacé). Développement d'exploits multi-étapes, workflows de pentesting autonomes |

**Modèles obsolètes - Migrer vers les modèles actuels**

| ID du modèle                    | Réflexion | Date de sortie | Prix (Entrée/Sortie/Cache R/W) | Notes                                        |
| ------------------------------- | --------- | -------------- | ------------------------------ | -------------------------------------------- |
| `claude-3-haiku-20240307`       | ❌         | Mar 2024       | $0.25/$1.25/$0.03/$0.30        | Sera retiré le 19 avril 2026. Migrer vers claude-haiku-4-5 |

**Prix** : Par million de tokens. Le prix du cache inclut les coûts de lecture et d'écriture.

**Configuration de la réflexion étendue**:
- **Max Tokens 4096** : Générateur (claude-opus-4-6) pour une profondeur de raisonnement maximale sur le développement d'exploits complexes
- **Max Tokens 2048** : Codeur (claude-sonnet-4-6) pour une analyse de code équilibrée et la recherche de vulnérabilités
- **Max Tokens 1024** : Agent principal, assistant, affineur, conseiller, réflecteur, chercheur, installateur, testeur d'intrusion pour un raisonnement ciblé sur des tâches spécifiques
- **Réflexion étendue** : Tous les modèles Claude 4.5+ et 4.6 prennent en charge une réflexion étendue configurable pour les tâches de raisonnement approfondi

**Fonctionnalités clés** :
- **Réflexion étendue** : Tous les modèles Claude 4.5+ et 4.6 avec profondeurs de raisonnement configurables pour une analyse de sécurité complexe
- **Réflexion adaptative** : La série Claude 4.6 (Opus/Sonnet) ajuste dynamiquement la profondeur de raisonnement en fonction de la complexité de la tâche pour des performances optimales
- **Mise en cache des invites** : Réduction significative des coûts avec des prix séparés pour la lecture et l'écriture (10% lecture, 125% écriture de l'entrée)
- **Fenêtre de contexte étendue** : 200K tokens standard, jusqu'à 1M tokens (bêta) pour Claude Opus/Sonnet 4.6 pour une analyse complète de la base de code
- **Appel d'outil** : Appel de fonction robuste avec une précision exceptionnelle pour l'orchestration des outils de sécurité
- **Streaming** : Diffusion en continu des réponses en temps réel pour les workflows interactifs de test d'intrusion
- **Conception priorisant la sécurité** : Mécanismes de sécurité intégrés garantissant des pratiques de test de sécurité responsables
- **Prise en charge multimodale** : Capacités de vision dans les derniers modèles pour l'analyse de captures d'écran et l'évaluation de la sécurité de l'interface utilisateur
- **IA constitutionnelle** : Formation avancée à la sécurité fournissant des conseils de sécurité fiables et éthiques

### Configuration du fournisseur Google AI (Gemini)

PentAGI s'intègre aux modèles Gemini de Google via l'API Google AI, offrant des capacités de raisonnement multimodal de pointe avec réflexion étendue et mise en cache du contexte.

#### Variables de configuration

| Variable            | Défaut                                       | Description                         |
| ------------------- | -------------------------------------------- | ----------------------------------- |
| `GEMINI_API_KEY`    |                                              | Clé API pour les services Google AI |
| `GEMINI_SERVER_URL` | `https://generativelanguage.googleapis.com`  | Point d'accès API Google AI         |

#### Exemples de configuration```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

Modèles pris en charge

PentAGI prend en charge 9 modèles Gemini avec appel d'outils, streaming, modes de réflexion et mise en cache de contexte. Les modèles marqués d'un * sont utilisés dans la configuration par défaut.

Gamme Gemini 3.5 - Flash stable le plus récent (Mai 2026)

Model ID	Thinking	Context	Price (Input/Output/Cache)	Use Case
`gemini-3.5-flash`*	✅	1M	$1.50/$9.00/$0.15	Modèle Flash le plus intelligent avec des performances de pointe soutenues pour les tâches agentiques et de codage, recherche et ancrage supérieurs

Gamme Gemini 3.1 - Flash-Lite stable + Aperçu Pro (Fév-Mai 2026)

Gamme Gemini 2.5 - Modèles de réflexion avancée (actifs jusqu'au 16 octobre 2026)

Modèles open-source Gemma 4 (Apache 2.0, Niveau gratuit)

Prix : Par 1M de tokens (niveau payant standard). La fenêtre de contexte est la limite de tokens en entrée.

[!NOTE] Arrêt de la gamme Gemini 2.5

gemini-2.5-pro, gemini-2.5-flash et gemini-2.5-flash-lite seront arrêtés le 16 octobre 2026. Migrations recommandées :

gemini-2.5-pro → gemini-3.1-pro-preview (même niveau de prix d'entrée à $2.00)

gemini-2.5-flash → gemini-3.5-flash (capacités de pointe améliorées)

gemini-2.5-flash-lite → gemini-3.1-flash-lite (même prix d'entrée à $0.25)

Affectations de modèles par défaut (config.yml) :

gemini-3.1-pro-preview - primary_agent, assistant, generator, refiner, adviser, coder, pentester
gemini-3.5-flash - reflector, searcher, enricher, installer
gemini-3.1-flash-lite - simple,

Fonctionnalités clés :

Réflexion étendue : Raisonnement étape par étape pour une analyse de sécurité complexe (tous les modèles Gemini 3.x, série 2.5 et Gemma 4 avec réflexion activable)
Mise en cache de contexte : Réduction significative des coûts sur les contextes répétés (10% du prix d'entrée pour la plupart des modèles)
Contexte ultra-long : 1M de tokens pour les modèles de chat Gemini, 256K tokens pour les modèles open-source Gemma 4
Prise en charge multimodale : Traitement de texte, image, vidéo, audio et PDF pour des évaluations complètes
Appel d'outils : Intégration transparente avec plus de 20 outils de pentesting via l'appel de fonctions
Streaming : Diffusion en temps réel des réponses pour des workflows de sécurité interactifs
Exécution de code : Exécution de code intégrée pour les tests d'outils offensifs et la validation d'exploits
Ancrage de recherche : Intégration de la recherche Google pour le renseignement sur les menaces et la recherche de CVE
Recherche de fichiers : Récupération de documents et capacités RAG pour des évaluations basées sur les connaissances
API Batch : Réduction de 50% des coûts pour le traitement par lots non en temps réel
Point de terminaison d'outils personnalisés : Route dédiée gemini-3.1-pro-preview-customtools pour les workflows agentiques lourds en outils qui préfèrent les outils enregistrés à bash

Niveaux d'effort de réflexion :

Élevé : Profondeur de réflexion maximale pour une analyse complexe en plusieurs étapes (generator)
Moyen : Raisonnement équilibré pour les tâches agentiques générales (primary_agent, assistant, refiner, adviser)
Faible : Réflexion efficace pour les tâches ciblées (coder, installer, pentester)

Configuration du fournisseur AWS Bedrock

PentAGI s'intègre à Amazon Bedrock, offrant l'accès à plus de 20 modèles fondateurs des principales sociétés d'IA, notamment Anthropic, Amazon, Cohere, DeepSeek, OpenAI, Qwen, Mistral et Moonshot.

Variables de configuration

Priorité d'authentification : BEDROCK_DEFAULT_AUTH → BEDROCK_BEARER_TOKEN → BEDROCK_ACCESS_KEY_ID+BEDROCK_SECRET_ACCESS_KEY

Exemples de configuration```bash

Recommended: Default AWS SDK authentication (EC2/ECS/Lambda roles)

BEDROCK_REGION=us-east-1 BEDROCK_DEFAULT_AUTH=true

Bearer token authentication (AWS STS, custom auth)

BEDROCK_REGION=us-east-1 BEDROCK_BEARER_TOKEN=your_bearer_token

Static credentials (development, testing)

BEDROCK_REGION=us-east-1 BEDROCK_ACCESS_KEY_ID=your_aws_access_key BEDROCK_SECRET_ACCESS_KEY=your_aws_secret_key

With proxy and custom endpoint

BEDROCK_REGION=us-east-1 BEDROCK_DEFAULT_AUTH=true BEDROCK_SERVER_URL=https://bedrock-runtime.us-east-1.vpce-xxx.amazonaws.com PROXY_URL=http://your-proxy:8080

#### Modèles pris en charge

PentAGI prend en charge 21 modèles AWS Bedrock avec appel d'outils, streaming et capacités multimodales. Les modèles marqués d'un `*` sont utilisés dans la configuration par défaut.

| ID du modèle                                      | Fournisseur    | Réflexion | Multimodal | Prix (Entrée/Sortie) | Cas d'utilisation                                |
| ------------------------------------------------ | --------------- | -------- | ---------- | -------------------- | --------------------------------------- |
| `us.amazon.nova-2-lite-v1:0`                     | Amazon Nova     | ❌        | ✅          | $0.33/$2.75          | Raisonnement adaptatif, réflexion efficace  |
| `us.amazon.nova-premier-v1:0`                    | Amazon Nova     | ❌        | ✅          | $2.50/$12.50         | Raisonnement complexe, analyse avancée    |
| `us.amazon.nova-pro-v1:0`                        | Amazon Nova     | ❌        | ✅          | $0.80/$3.20          | Précision, vitesse et coût équilibrés          |
| `us.amazon.nova-lite-v1:0`                       | Amazon Nova     | ❌        | ✅          | $0.06/$0.24          | Traitement rapide, opérations à volume élevé |
| `us.amazon.nova-micro-v1:0`                      | Amazon Nova     | ❌        | ❌          | $0.035/$0.14         | Latence ultra-faible, surveillance en temps réel |
| `us.anthropic.claude-opus-4-6-v1`*               | Anthropic       | ✅        | ✅          | $5.00/$25.00         | Codage de classe mondiale, agents d'entreprise   |
| `us.anthropic.claude-sonnet-4-6`                 | Anthropic       | ✅        | ✅          | $3.00/$15.00         | Intelligence de pointe, échelle entreprise |
| `us.anthropic.claude-opus-4-5-20251101-v1:0`     | Anthropic       | ✅        | ✅          | $5.00/$25.00         | Développement logiciel sur plusieurs jours          |
| `us.anthropic.claude-haiku-4-5-20251001-v1:0`*   | Anthropic       | ✅        | ✅          | $1.00/$5.00          | Performances proches de la frontière, vitesse élevée   |
| `us.anthropic.claude-sonnet-4-5-20250929-v1:0`*  | Anthropic       | ✅        | ✅          | $3.00/$15.00         | Agence du monde réel, excellence en codage    |
| `us.anthropic.claude-sonnet-4-20250514-v1:0`     | Anthropic       | ✅        | ✅          | $3.00/$15.00         | Performances équilibrées, prêt pour la production  |
| `us.anthropic.claude-3-5-haiku-20241022-v1:0`    | Anthropic       | ❌        | ❌          | $0.80/$4.00          | Modèle le plus rapide, analyse économique  |
| `cohere.command-r-plus-v1:0`                     | Cohere          | ❌        | ❌          | $3.00/$15.00         | Opérations à grande échelle, RAG supérieur    |
| `deepseek.v3.2`                                  | DeepSeek        | ❌        | ❌          | $0.58/$1.68          | Raisonnement à long contexte, efficacité      |
| `openai.gpt-oss-120b-1:0`*                       | OpenAI (OSS)    | ✅        | ❌          | $0.15/$0.60          | Raisonnement solide, analyse scientifique   |
| `openai.gpt-oss-20b-1:0`                         | OpenAI (OSS)    | ✅        | ❌          | $0.07/$0.30          | Codage efficace, développement logiciel  |
| `qwen.qwen3-next-80b-a3b`                        | Qwen            | ❌        | ❌          | $0.15/$1.20          | Contexte ultra-long, raisonnement phare  |
| `qwen.qwen3-32b-v1:0`                            | Qwen            | ❌        | ❌          | $0.15/$0.60          | Raisonnement équilibré, cas de recherche  |
| `qwen.qwen3-coder-30b-a3b-v1:0`                  | Qwen            | ❌        | ❌          | $0.15/$0.60          | Vibe coding, priorité au langage naturel     |
| `qwen.qwen3-coder-next`                          | Qwen            | ❌        | ❌          | $0.45/$1.80          | Utilisation d'outils, appel de fonction optimisé    |
| `mistral.mistral-large-3-675b-instruct`          | Mistral         | ❌        | ✅          | $4.00/$12.00         | Multimodal avancé, long contexte       |
| `moonshotai.kimi-k2.5`                           | Moonshot        | ❌        | ✅          | $0.60/$3.00          | Vision, langage et code en un seul modèle     |

**Prix** : Par million de tokens. Les modèles avec prise en charge de la réflexion/raisonnement entraînent des coûts de calcul supplémentaires pendant la phase de raisonnement.

#### Modèles testés mais incompatibles

Certains modèles AWS Bedrock ont été testés mais ne sont **pas pris en charge** en raison de limitations techniques :

| Famille de modèles              | Raison de l'incompatibilité                                                                |
| ------------------------- | ----------------------------------------------------------------------------------------- |
| **GLM (Z.AI)**            | Format d'appel d'outils incompatible avec l'API Converse (attend une chaîne au lieu de JSON)       |
| **AI21 Jamba**            | Limites de débit sévères (1-2 req/min) empêchent les tests fiables et l'utilisation en production              |
| **Meta Llama 3.3/3.1**    | Traitement instable des résultats d'appel d'outils, provoque des échecs inattendus dans les flux multitours  |
| **Mistral Magistral**     | L'appel d'outils n'est pas pris en charge par le modèle                                                   |
| **Moonshot K2-Thinking**  | Comportement de streaming instable avec les appels d'outils, peu fiable en production                     |
| **Qwen3-VL**              | Streaming instable avec appel d'outils, la combinaison multimodale + outils échoue par intermittence |

> [!IMPORTANT]
> **Gestion des limites de débit et des quotas**
>
> Les quotas par défaut d'AWS Bedrock pour les modèles Claude sont **extrêmement restrictifs** (2-20 requêtes/minute pour les nouveaux comptes). Pour les tests d'intrusion en production :
>
> 1. **Demandez des augmentations de quota** via la console AWS Service Quotas pour les modèles que vous prévoyez d'utiliser
> 2. **Utilisez les modèles Amazon Nova** - quotas par défaut plus élevés et excellentes performances
> 3. **Activez le débit provisionné** pour des tests à volume élevé cohérents
> 4. **Surveillez l'utilisation** - AWS limite agressivement aux limites de quota
>
> Sans augmentation des quotas, attendez-vous à des retards fréquents et des interruptions de flux de travail.

> [!WARNING]
> **Exigences de l'API Converse**
>
> PentAGI utilise l'**API Converse** d'Amazon Bedrock pour un accès unifié aux modèles. Tous les modèles pris en charge nécessitent :
>
> - ✅ Prise en charge de l'API Converse/ConverseStream
> - ✅ Utilisation d'outils (appel de fonction) pour les flux de test d'intrusion
> - ✅ Utilisation d'outils en streaming pour un retour en temps réel
>
> Vérifiez les capacités des modèles sur : [AWS Bedrock Model Features](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-supported-models-features.html)

**Fonctionnalités clés** :
- **Mise en cache automatique des prompts** : réduction de 40 à 70 % des coûts sur le contexte répété (modèles Claude 4.x)
- **Réflexion étendue** : raisonnement étape par étape pour l'analyse de sécurité complexe (Claude, DeepSeek R1, OpenAI GPT)
- **Analyse multimodale** : traite les captures d'écran, diagrammes, vidéos pour des tests complets (Nova, Claude, Mistral, Kimi)
- **Appel d'outils** : intégration transparente avec plus de 20 outils de test d'intrusion via l'appel de fonction
- **Streaming** : diffusion en temps réel des réponses pour des flux d'évaluation de sécurité interactifs

### Configuration du fournisseur DeepSeek

PentAGI s'intègre avec DeepSeek, offrant l'accès à des modèles d'IA avancés avec un raisonnement solide, des capacités de codage et une mise en cache du contexte à des prix compétitifs.

#### Variables de configuration

| Variable              | Valeur par défaut           | Description                                         |
| --------------------- | -------------------------- | --------------------------------------------------- |
| `DEEPSEEK_API_KEY`    |                            | Clé API DeepSeek pour l'authentification                 |
| `DEEPSEEK_SERVER_URL` | `https://api.deepseek.com` | URL du point de terminaison de l'API DeepSeek                           |
| `DEEPSEEK_PROVIDER`   |                            | Préfixe du fournisseur pour l'intégration LiteLLM (optionnel)  |

#### Exemples de configuration```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

Modèles pris en charge

PentAGI prend en charge 2 modèles DeepSeek V4 avec appel d'outils, diffusion en continu, modes de pensée hybrides/non-pensée, et mise en cache du contexte. Les deux modèles prennent en charge le mode pensée par défaut et peuvent être basculés en mode non-pensée via extra_body. Les modèles marqués d'un * sont utilisés dans la configuration par défaut.

Tarifs : Par million de tokens. Les tarifs de cache s'appliquent aux tokens de prompt servis depuis le cache (entrée cache hit, réduit à 1/10 du prix de lancement depuis le 26/04/2026). Les deux modèles prennent en charge la pensée hybride — le mode thinking est activé par défaut ; passez extra_body.thinking.type: disabled pour basculer en mode non-pensée pour des réponses plus rapides/moins chères.

Note tarifaire (deepseek-v4-pro) : La remise promotionnelle de 75 % sur deepseek-v4-pro a officiellement pris fin le 31/05/2026 à 15:59 UTC. Les tarifs ci-dessus reflètent les tarifs standard post-promotion. Si vous avez des configurations héritées utilisant les tarifs réduits ($0.435/$0.87/$0.003625), mettez-les à jour avec les tarifs actuels pour un suivi précis des coûts.

Les noms de modèles hérités deepseek-chat et deepseek-reasoner doivent être dépréciés par DeepSeek d'ici le 24/07/2026. Les configurations utilisateur existantes qui référencent ces noms hérités continueront de fonctionner jusqu'à cette date ; les valeurs par défaut ci-dessus utilisent les noms V4 actuels. deepseek-chat correspond à deepseek-v4-flash en mode non-pensée ; deepseek-reasoner correspond à deepseek-v4-flash en mode pensée.

Configuration par défaut des agents :

Stratégie : préférez deepseek-v4-flash (entrée 12x moins chère, sortie 12x moins chère) comme cheval de bataille pour les agents utilitaires/légers ; réservez deepseek-v4-pro pour le raisonnement complexe multi-étapes. L'agent installer fonctionne sur Flash avec la pensée activée car les tâches de configuration de l'environnement (commandes shell, modifications de configuration) nécessitent rarement un raisonnement de niveau Pro. Réalisez des tests A/B sur vos propres charges de travail avant de promouvoir plus d'agents vers Pro.

Note : Quand le mode pensée est activé, DeepSeek ignore silencieusement temperature, top_p, presence_penalty et frequency_penalty. Le client langchaingo nullifie automatiquement temperature/top_p lorsque reasoning_effort est défini, donc ils apparaissent comme '(auto)' dans le tableau ci-dessus. Tous les agents activés pour la pensée passent également explicitement extra_body.thinking.type: enabled comme mesure défensive contre les futurs changements de valeurs par défaut du fournisseur.

Fonctionnalités clés :

Modes de pensée hybrides : Basculez entre mode pensée (raisonnement approfondi) et mode non-pensée (rapide) via extra_body.thinking.type
Mise en cache automatique des prompts : Réduction significative des coûts sur les contextes répétés grâce aux tarifs de cache hit (1/10 du prix de lancement)
Pensée étendue : CoT par apprentissage par renforcement pour l'analyse de sécurité complexe (les deux modèles V4)
Codage puissant : Optimisé pour la génération de code et le développement d'exploits
Contexte long : Fenêtre de contexte de 1M tokens avec jusqu'à 384K tokens de sortie
Appel d'outils : Intégration transparente avec plus de 20 outils de pentesting via function calling
Diffusion en continu : Diffusion en continu des réponses en temps réel pour des workflows interactifs
Multilingue : Excellent support du chinois et de l'anglais
Fonctionnalités supplémentaires : Sortie JSON, achèvement par préfixe de chat (bêta), achèvement FIM/Infill (mode non-pensée uniquement)

Limites de concurrence : deepseek-v4-flash : 2500 requêtes simultanées ; deepseek-v4-pro : 500 requêtes simultanées.

Intégration LiteLLM : Définissez DEEPSEEK_PROVIDER=deepseek pour activer le préfixage des noms de modèles lors de l'utilisation des configurations PentAGI par défaut avec le proxy LiteLLM. Laissez vide pour une utilisation directe de l'API.

Configuration du fournisseur GLM

PentAGI s'intègre avec GLM de Zhipu AI (Z.AI), fournissant des modèles de langage avancés avec architecture MoE, un raisonnement puissant et des capacités agentiques développées par l'Université Tsinghua.

Variables de configuration

Variable	Valeur par défaut	Description
`GLM_API_KEY`

Exemples de configuration```bash

Direct API usage (international endpoint)

GLM_API_KEY=your_glm_api_key GLM_SERVER_URL=https://api.z.ai/api/paas/v4

Alternative endpoints

GLM_SERVER_URL=https://open.bigmodel.cn/api/paas/v4 # China GLM_SERVER_URL=https://api.z.ai/api/coding/paas/v4 # Coding-specific

With LiteLLM proxy

GLM_API_KEY=your_litellm_key GLM_SERVER_URL=http://litellm-proxy:4000 GLM_PROVIDER=zai # Adds prefix to model names (zai/glm-4) for LiteLLM

#### Modèles pris en charge

PentAGI prend en charge 13 modèles GLM avec appel d'outils, streaming, modes de réflexion hybrides et mise en cache des prompts. Les modèles marqués d'un `*` sont utilisés dans la configuration par défaut. La réflexion est contrôlée via `extra_body.thinking.type` ("enabled"/"disabled") ; contrairement à Kimi, GLM est permissif en ce qui concerne la température dans les deux modes.

**Série GLM-5.x - Dernière génération (contexte 200K, sortie max 128K)**

| Model ID         | Thinking | Context | Max Output | Price (Input/Output/Cache) | Use Case                                                            |
| ---------------- | -------- | ------- | ---------- | -------------------------- | ------------------------------------------------------------------- |
| `glm-5.1`*       | ✅ Hybride | 200K    | 128K       | $1.40/$4.40/$0.26          | Dernier vaisseau amiral : exécution autonome soutenue pendant 8h, aligné sur Claude Opus 4.6 (générateur/affineur/conseiller/codeur/pentester par défaut) |
| `glm-5`          | ✅ Hybride | 200K    | 128K       | $1.00/$3.20/$0.20          | Fondation pour l'ingénierie agentique, MoE 744B/40B actif, codage de niveau Claude Opus 4.5 |
| `glm-5-turbo`*   | ✅ Hybride | 200K    | 128K       | $1.20/$4.00/$0.24          | Natif OpenClaw : optimisé pour l'invocation d'outils, les tâches persistantes, l'exécution en chaîne longue (primary_agent/assistant par défaut) |

**Série GLM-4.7 - Premium avec réflexion entrelacée**

| Model ID          | Thinking | Context | Max Output | Price (Input/Output/Cache) | Use Case                                            |
| ----------------- | -------- | ------- | ---------- | -------------------------- | --------------------------------------------------- |
| `glm-4.7`         | ✅ Hybride | 200K    | 128K       | $0.60/$2.20/$0.11          | Programmation améliorée, raisonnement multi-étapes stable   |
| `glm-4.7-flashx`  | ✅ Hybride | 200K    | 128K       | $0.07/$0.40/$0.01          | Ultra-bon marché avec GPU prioritaire, mais limites RPM inférieures (éviter pour une utilisation à haute fréquence) |
| `glm-4.7-flash`   | ✅ Hybride | 200K    | 128K       | Free/Free/Free             | Modèle SOTA ~30B gratuit, 1 requête simultanée          |

**Série GLM-4.6 - Équilibrée avec réflexion automatique**

| Model ID  | Thinking | Context | Max Output | Price (Input/Output/Cache) | Use Case                                          |
| --------- | -------- | ------- | ---------- | -------------------------- | ------------------------------------------------- |
| `glm-4.6` | ✅ Auto   | 200K    | 128K       | $0.60/$2.20/$0.11          | Équilibré, appels d'outils en streaming, efficace en tokens   |

**Série GLM-4.5 - Raisonnement/Codage/Agents unifié**

| Model ID         | Thinking | Context | Max Output | Price (Input/Output/Cache) | Use Case                                          |
| ---------------- | -------- | ------- | ---------- | -------------------------- | ------------------------------------------------- |
| `glm-4.5`        | ✅ Auto   | 128K    | 96K        | $0.60/$2.20/$0.11          | Unifié, MoE 355B/32B actif                      |
| `glm-4.5-x`      | ✅ Auto   | 128K    | 96K        | $2.20/$8.90/$0.45          | Premium ultra-rapide, latence la plus faible                |
| `glm-4.5-air`*   | ✅ Auto   | 128K    | 96K        | $0.20/$1.10/$0.03          | MoE 106B/12B économique (simple/simple_json/reflector/searcher/enricher/installer par défaut) |
| `glm-4.5-airx`   | ✅ Auto   | 128K    | 96K        | $1.10/$4.50/$0.22          | Air accéléré avec GPU prioritaire                 |
| `glm-4.5-flash`  | ✅ Auto   | 128K    | 96K        | Free/Free/Free             | Gratuit avec prise en charge du raisonnement/codage/agents         |

**GLM-4 Legacy - Architecture dense**

| Model ID              | Thinking | Context | Max Output | Price (Input/Output) | Use Case                                      |
| --------------------- | -------- | ------- | ---------- | -------------------- | --------------------------------------------- |
| `glm-4-32b-0414-128k` | ❌        | 128K    | 16K        | $0.10/$0.10          | Dense 32B ultra-économique, analyse sans raisonnement |

**Prix** : Par million de tokens. Le prix du cache est pour le cache de prompt ; le stockage en cache est actuellement gratuit selon la promotion Z.AI. GLM-4-32B n'a pas de support de cache.

**Configuration par défaut de l'agent** :

Stratégie : `glm-5.1` (dernier vaisseau amiral, entrée à 1,40 $) pour le raisonnement critique, `glm-5-turbo` (natif OpenClaw, optimisé pour les agents) pour l'orchestration, `glm-4.5-air` (MoE bon marché avec réflexion hybride et RPM fiable) pour tous les agents utilitaires/installateurs. `glm-4.7-flashx` est évité par défaut en raison de limites RPM inférieures provoquant fréquemment des erreurs 429 à haute fréquence.

| Agent Role                          | Default Model | Thinking | Temperature | Top P | Max Output |
| ----------------------------------- | ------------- | -------- | ----------- | ----- | ---------- |
| Generator / Refiner                 | `glm-5.1`     | Activé  | 1.0         | 0.95  | 32768      |
| Coder                               | `glm-5.1`     | Activé  | 1.0         | 0.95  | 20480      |
| Adviser / Pentester                 | `glm-5.1`     | Activé  | 1.0         | 0.95  | 16384      |
| Primary Agent / Assistant           | `glm-5-turbo` | Activé  | 1.0         | 0.95  | 16384      |
| Installer                           | `glm-4.5-air` | Activé  | 1.0         | 0.95  | 16384      |
| Simple / Reflector                  | `glm-4.5-air` | Désactivé | 0.6         | 0.9   | 8192       |
| Searcher / Enricher / Simple JSON   | `glm-4.5-air` | Désactivé | 0.6         | 0.9   | 4096       |

> **Remarque sur la température** : GLM accepte à la fois `1.0` et `0.6` en mode réflexion ou non (selon la documentation Z.AI). Le `IsReasoningModel` de langchaingo correspond aux préfixes `glm-4.5*`/`glm-4.6*`/`glm-4.7*` et force la température à 1.0 dans `createChatRequest` — cela est inoffensif pour GLM (contrairement à Kimi) mais signifie que les valeurs de température pour ces modèles dans YAML sont indicatives. `glm-5`/`glm-5.1`/`glm-5-turbo` ne sont pas concernés, donc les valeurs explicites sont transmises inchangées.

**Modes de réflexion** :
- **Hybride** (GLM-5.x, GLM-4.7) : Activation explicite via `extra_body.thinking.type`
- **Automatique** (séries GLM-4.6, GLM-4.5) : Le modèle détermine automatiquement quand un raisonnement est nécessaire
- **Réflexion préservée** (capacité de codage Z.AI) : tous les agents activés pour la réflexion dans PentAGI transmettent également `extra_body.thinking.clear_thinking: false` afin que le `reasoning_content` des tours précédents de l'assistant soit conservé au fil de la conversation. Cela est requis sur le point de terminaison API standard (`/api/paas/v4`) — sur le point de terminaison du plan de codage, il serait activé par défaut. Améliore la continuité du raisonnement et les taux de succès du cache dans les chaînes d'appels d'outils multi-tours.
- Tous les agents activés pour la réflexion transmettent également `extra_body.tool_choice: auto` par mesure de sécurité

**Fonctionnalités clés** :

---

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

PENTAGI_POSTGRES_USER

PENTAGI_POSTGRES_PASSWORD

simple_json

Preserve Last	`SUMMARIZER_PRESERVE_LAST`	`true`	Si tous les messages de la dernière section doivent être conservés intacts
Use QA Pairs	`SUMMARIZER_USE_QA`	`true`	Si la stratégie de résumé par paires QA doit être utilisée
Summarize Human in QA	`SUMMARIZER_SUM_MSG_HUMAN_IN_QA`	`false`	Si les messages humains dans les paires QA doivent être résumés
Last Section Size	`SUMMARIZER_LAST_SEC_BYTES`	`51200`	Taille maximale en octets de la dernière section (50 Ko)
Max Body Pair Size	`SUMMARIZER_MAX_BP_BYTES`	`16384`	Taille maximale en octets d'une seule paire de corps (16 Ko)
Max QA Sections	`SUMMARIZER_MAX_QA_SECTIONS`	`10`	Nombre maximal de sections de paires QA à conserver
Max QA Size	`SUMMARIZER_MAX_QA_BYTES`	`65536`	Taille maximale en octets des sections de paires QA (64 Ko)
Keep QA Sections	`SUMMARIZER_KEEP_QA_SECTIONS`	`1`	Nombre de sections QA récentes à conserver sans résumé

Preserve Last	`ASSISTANT_SUMMARIZER_PRESERVE_LAST`	`true`	Si tous les messages de la dernière section de l'assistant doivent être conservés
Last Section Size	`ASSISTANT_SUMMARIZER_LAST_SEC_BYTES`	`76800`	Taille maximale en octets de la dernière section de l'assistant (75 Ko)
Max Body Pair Size	`ASSISTANT_SUMMARIZER_MAX_BP_BYTES`	`16384`	Taille maximale en octets d'une seule paire de corps dans le contexte de l'assistant (16 Ko)
Max QA Sections	`ASSISTANT_SUMMARIZER_MAX_QA_SECTIONS`	`7`	Nombre maximal de sections QA à conserver dans le contexte de l'assistant
Max QA Size	`ASSISTANT_SUMMARIZER_MAX_QA_BYTES`	`76800`	Taille maximale en octets des sections QA de l'assistant (75 Ko)
Keep QA Sections	`ASSISTANT_SUMMARIZER_KEEP_QA_SECTIONS`	`3`	Nombre de sections QA récentes à conserver sans résumé dans l'assistant

`LLM_SERVER_URL`		URL de base du point de terminaison de l'API LLM personnalisée
`LLM_SERVER_KEY`		Clé API pour le fournisseur LLM personnalisé
`LLM_SERVER_MODEL`		Modèle par défaut à utiliser (peut être remplacé dans la configuration du fournisseur)
`LLM_SERVER_CONFIG_PATH`		Chemin vers le fichier de configuration YAML pour les modèles spécifiques à l'agent
`LLM_SERVER_PROVIDER`		Préfixe du nom du fournisseur pour les noms de modèles (ex. `openrouter`, `deepseek` pour le proxy LiteLLM)
`LLM_SERVER_LEGACY_REASONING`	`false`	Contrôle le format de raisonnement dans les requêtes API
`LLM_SERVER_PRESERVE_REASONING`	`false`	Conserver le contenu de raisonnement dans les conversations multitours (requis par certains fournisseurs)

`OLLAMA_SERVER_URL`		URL de votre serveur Ollama ou Ollama Cloud
`OLLAMA_SERVER_API_KEY`		Clé API pour l'authentification Ollama Cloud
`OLLAMA_SERVER_MODEL`		Modèle par défaut pour l'inférence
`OLLAMA_SERVER_CONFIG_PATH`		Chemin vers le fichier de configuration de l'agent personnalisé
`OLLAMA_SERVER_PULL_MODELS_TIMEOUT`	`600`	Délai d'expiration pour le téléchargement des modèles (secondes)
`OLLAMA_SERVER_PULL_MODELS_ENABLED`	`false`	Téléchargement automatique des modèles au démarrage
`OLLAMA_SERVER_LOAD_MODELS_ENABLED`	`false`	Interroger le serveur pour les modèles disponibles

`gpt-5.2`*	✅	$1.75/$14.00/$0.18	Dernier modèle phare avec raisonnement amélioré et intégration d'outils, recherche en sécurité autonome
`gpt-5.2-pro`	✅	$21.00/$168.00/$0.00	Version premium avec codage agentique supérieur, recherche en sécurité critique, découverte de zero-day
`gpt-5.2-codex`	✅	$1.75/$14.00/$0.18	Le plus avancé spécialisé dans le code, compactage de contexte, capacités cybersécurité fortes

`gpt-5`	✅	$1.25/$10.00/$0.13	Modèle agentique premier avec raisonnement avancé, recherche en sécurité autonome, développement de chaînes d'exploitation
`gpt-5.1`	✅	$1.25/$10.00/$0.13	Agentique amélioré avec raisonnement adaptatif, tests de pénétration équilibrés avec coordination d'outils solide
`gpt-5-pro`	✅	$15.00/$120.00/$0.00	Version premium avec améliorations majeures du raisonnement, hallucinations réduites, opérations de sécurité critiques
`gpt-5-mini`	✅	$0.25/$2.00/$0.03	Efficace équilibrant vitesse et intelligence, analyse automatisée des vulnérabilités, génération d'exploits
`gpt-5-nano`	✅	$0.05/$0.40/$0.01	Le plus rapide pour le scan à haut débit, reconnaissance, détection massive de vulnérabilités

`gpt-5.1-codex-max`	✅	$1.25/$10.00/$0.13	Raisonnement amélioré pour un codage sophistiqué, découvertes de CVE prouvées, développement systématique d'exploits
`gpt-5.1-codex`	✅	$1.25/$10.00/$0.13	Code optimisé standard avec raisonnement solide, génération d'exploits, analyse de vulnérabilités
`gpt-5-codex`	✅	$1.25/$10.00/$0.13	Fondamental spécialisé dans le code, scan de vulnérabilités, génération d'exploits de base
`gpt-5.1-codex-mini`	✅	$0.25/$2.00/$0.03	Compact haute performance, capacité 4x supérieure, détection rapide des vulnérabilités
`codex-mini-latest`	✅	$1.50/$6.00/$0.38	Dernier modèle de code compact, revue de code automatisée, analyse de vulnérabilités de base

`gpt-4.1`	❌	$2.00/$8.00/$0.50	Modèle phare amélioré avec appel de fonction supérieur, analyse de menaces complexes, développement d'exploits sophistiqué
`gpt-4.1-mini`*	❌	$0.40/$1.60/$0.10	Performance équilibrée avec efficacité améliorée, évaluations de sécurité de routine, analyse de code automatisée
`gpt-4.1-nano`	❌	$0.10/$0.40/$0.03	Léger ultra-rapide, scan de sécurité en masse, reconnaissance rapide, surveillance continue

`o4-mini`*	✅	$1.10/$4.40/$0.28	Raisonnement de nouvelle génération avec vitesse améliorée, évaluations de sécurité méthodiques, développement systématique d'exploits
`o3`*	✅	$2.00/$8.00/$0.50	Puissance de raisonnement avancée, chaînes d'attaque multi-étapes, analyse approfondie des vulnérabilités
`o3-mini`	✅	$1.10/$4.40/$0.55	Raisonnement compact avec réflexion étendue, planification d'attaque étape par étape, enchaînement logique de vulnérabilités
`o1`	✅	$15.00/$60.00/$7.50	Raisonnement premier avec profondeur maximale, tests de pénétration avancés, recherche d'exploits novateurs
`o3-pro`	✅	$20.00/$80.00/$0.00	Raisonnement le plus avancé, 80 % moins cher que o1-pro, recherche de zero-day, enquêtes de sécurité critiques
`o1-pro`	✅	$150.00/$600.00/$0.00	Raisonnement premium de génération précédente, analyse de sécurité exhaustive, défis critiques

`gemini-3.1-pro-preview`*	✅	1M	$2.00/$12.00/$0.20	Dernier modèle phare avec réflexion affinée, efficacité token améliorée, optimisé pour le génie logiciel et les workflows agentiques
`gemini-3.1-pro-preview-customtools`	✅	1M	$2.00/$12.00/$0.20	Point de terminaison d'outils personnalisés optimisé pour la priorisation de bash et des outils personnalisés (view_file, search_code)
`gemini-3.1-flash-lite`*	✅	1M	$0.25/$1.50/$0.025	Modèle multimodal stable le plus rentable, performances de niveau supérieur pour les tâches agentiques à volume élevé et les applications à faible latence

`gemini-2.5-pro`	✅	1M	$1.25/$10.00/$0.125	État de l'art pour le codage complexe et le raisonnement, modélisation sophistiquée des menaces
`gemini-2.5-flash`	✅	1M	$0.30/$2.50/$0.03	Premier modèle de raisonnement hybride avec budgets de réflexion, meilleur rapport qualité-prix pour les évaluations à grande échelle
`gemini-2.5-flash-lite`	✅	1M	$0.10/$0.40/$0.01	Le plus petit et le plus rentable pour une utilisation à grande échelle, analyse à haut débit

`gemma-4-31b-it`	✅	256K	Gratuit/Gratuit/Gratuit	Le plus grand modèle dense open-source Gemma 4 (~31B paramètres), multimodal texte+image, 140+ langues, opérations de sécurité sur site
`gemma-4-26b-a4b-it`	✅	256K	Gratuit/Gratuit/Gratuit	Architecture MoE (~26B total / ~3,8B paramètres actifs), inférence très efficace sur GPU grand public pour l'analyse à haut débit sur site

`BEDROCK_REGION`	`us-east-1`	Région AWS pour le service Bedrock
`BEDROCK_DEFAULT_AUTH`	`false`	Utiliser la chaîne d'identification par défaut du SDK AWS (environnement, rôle EC2, ~/.aws/credentials) - priorité la plus élevée
`BEDROCK_BEARER_TOKEN`		Authentification par jeton Bearer - priorité sur les informations d'identification statiques
`BEDROCK_ACCESS_KEY_ID`		ID de clé d'accès AWS pour les informations d'identification statiques
`BEDROCK_SECRET_ACCESS_KEY`		Clé d'accès secrète AWS pour les informations d'identification statiques
`BEDROCK_SESSION_TOKEN`		Jeton de session AWS pour les informations d'identification temporaires (optionnel, utilisé avec les informations d'identification statiques)
`BEDROCK_SERVER_URL`		Point de terminaison Bedrock personnalisé (points de terminaison VPC, tests locaux)

`deepseek-v4-flash`*	✅ hybride	384K	1M	$0.14/$0.28/$0.0028	Agents utilitaires, dialogue général, appel d'outils rapide
`deepseek-v4-pro`*	✅ hybride	384K	1M	$1.74/$3.48/$0.0145	Raisonnement avancé, logique complexe, analyse de sécurité

Générateur / Raffineur	`deepseek-v4-pro`	Activé	Élevé	32768	(auto)	(auto)
Codeur	`deepseek-v4-pro`	Activé	Élevé	20480	(auto)	(auto)
Agent principal / Assistant / Pentester	`deepseek-v4-pro`	Activé	Élevé	16384	(auto)	(auto)
Conseiller (mentor/planificateur)	`deepseek-v4-pro`	Activé	Élevé	8192	(auto)	(auto)
Installateur	`deepseek-v4-flash`	Activé	Élevé	12288	(auto)	(auto)
Réflecteur / Chercheur / Enrichisseur	`deepseek-v4-flash`	Désactivé	—	4096	0.5	0.9
Simple / Simple JSON	`deepseek-v4-flash`	Désactivé	—	2048	0.3	0.9

pentagi

Populaires

PentAGI

Table des matières

Aperçu

Fonctionnalités

Limites actuelles des capacités

Architecture

Contexte système```mermaid

Options de configuration du résumeur global

Options de configuration du résumeur d'assistant

Configuration de l'environnement du résumeur```bash

Default values for global summarizer logic

Default values for assistant summarizer logic

Add your user to the docker group

Log out and log back in, or activate the group immediately

Verify Docker access (should run without sudo)

Couverture actuelle des paramètres Web

Toujours géré côté serveur

Installation manuelle

Paramètres de sécurité principaux

Accès au scraper

Identifiants d'accès

Comptes de l'interface Web

Accéder à PentAGI depuis des réseaux externes

Étapes de configuration

Network binding - allow external connections

Public URL - use your actual server IP or hostname

Replace 192.168.1.100 with your server's IP address

CORS origins - list all URLs that will access PentAGI

Include localhost for local access AND your server IP for external access

Ubuntu/Debian with UFW

CentOS/RHEL with firewalld

Scraper configuration for Podman rootless

Test from within the pentagi container

2. Utiliser des modèles pour des flux de travail reproductibles

3. Surveiller l'exécution et examiner les résultats

4. Utiliser la vue Assistant pour piloter un flux actif

5. Gérer les fichiers liés au flux

Accès API

Génération de jetons API

Utilisation des jetons API

GraphQL API example

REST API example

Swagger UI

Génération de clients API

Clients GraphQL

Clients API REST

Exemples d'utilisation de l'API

Usage

Create a new flow

List all flows

Bonnes pratiques de sécurité

Gestion des jetons

Configuration personnalisée du fournisseur LLM

Configuration du fournisseur Ollama

Variables de configuration

Configuration d'Ollama Cloud

Free tier allows one model at a time

Using custom provider configuration

Mount custom configuration from host filesystem (in .env or docker-compose override)

Configuration locale d'Ollama

Basic local Ollama setup

Production setup with auto-pull and model discovery

Using pre-built configurations from Docker image

or

or

Modèles pris en charge

Configuration du fournisseur Anthropic

Variables de configuration

Exemples de configuration```bash

Basic Anthropic setup

Using with proxy for secure environments

Modèles pris en charge

Configuration du fournisseur AWS Bedrock

Variables de configuration

Exemples de configuration```bash

Recommended: Default AWS SDK authentication (EC2/ECS/Lambda roles)

Bearer token authentication (AWS STS, custom auth)

Static credentials (development, testing)