PentAGI

Penetração teste Artificial Geral Inteligência

Junte-se à Comunidade! Conecte-se com pesquisadores de segurança, entusiastas de IA e hackers éticos. Obtenha suporte, compartilhe ideias e fique atualizado com os últimos desenvolvimentos do PentAGI.

⠀

Índice

Visão Geral
Recursos
Arquitetura
- Supervisão de Agentes
Início Rápido
Como Usar o PentAGI Após o Login
Acesso à API
- Configuração de Provedor LLM
  - Ollama
  - OpenAI
  - Anthropic
  - Google AI (Gemini)
  - AWS Bedrock
  - DeepSeek
  - GLM
  - Kimi
  - Qwen
Configuração Avançada
Desenvolvimento
Testando Agentes LLM
Configuração e Teste de Embeddings
Teste de Funções com ftester
Compilação
Créditos
Licença

Visão Geral

PentAGI é uma ferramenta inovadora para testes de segurança automatizados que utiliza tecnologias de inteligência artificial de ponta. O projeto é projetado para profissionais de segurança da informação, pesquisadores e entusiastas que precisam de uma solução poderosa e flexível para realizar testes de penetração.

Você pode assistir ao vídeo Visão geral do PentAGI:

Recursos

Seguro e Isolado. Todas as operações são realizadas em um ambiente Docker em sandbox com isolamento completo.
Totalmente Autônomo. Agente baseado em IA que determina e executa automaticamente as etapas de teste de penetração, com monitoramento opcional de execução e planejamento inteligente de tarefas para maior confiabilidade.
Ferramentas Profissionais de Pentest. Conjunto integrado de mais de 20 ferramentas de segurança profissionais, incluindo nmap, metasploit, sqlmap e muito mais.
Sistema de Memória Inteligente. Armazenamento de longo prazo de resultados de pesquisa e abordagens bem-sucedidas para uso futuro.
Integração com Grafo de Conhecimento. Grafo de conhecimento alimentado por Graphiti usando Neo4j para rastreamento de relações semânticas e compreensão avançada de contexto.
Inteligência Web. Navegador integrado via scraper para coletar as informações mais recentes de fontes web.
Sistemas de Busca Externa. Integração com APIs de busca avançadas, incluindo Tavily, Traversaal, Perplexity, DuckDuckGo, Google Custom Search, Sploitus Search e Searxng para coleta abrangente de informações.
Equipe de Especialistas. Sistema de delegação com agentes de IA especializados para tarefas de pesquisa, desenvolvimento e infraestrutura, aprimorado com monitoramento opcional de execução e planejamento inteligente de tarefas para desempenho ideal com modelos menores.
Monitoramento Abrangente. Log detalhado e integração com Grafana/Prometheus para observação do sistema em tempo real.
Relatórios Detalhados. Geração de relatórios completos de vulnerabilidades com guias de exploração.
Gerenciamento Inteligente de Contêineres. Seleção automática de imagem Docker com base nos requisitos específicos da tarefa.
Interface Moderna. Interface web limpa e intuitiva para gerenciamento e monitoramento do sistema.
APIs Abrangentes. APIs REST e GraphQL completas com autenticação via token Bearer para automação e integração.
Armazenamento Persistente. Todos os comandos e saídas são armazenados em PostgreSQL com extensão pgvector.
Arquitetura Escalável. Design baseado em microsserviços que suporta escalabilidade horizontal.

Limites Atuais de Capacidade

PentAGI hoje é uma plataforma de teste de penetração autônoma e assistida por guia, não um produto de Simulação de Violação e Ataque (BAS) estilo CALDERA ou simulação de adversário com campanhas ou planos de ataque predefinidos.
Scripts de ataque criados por agente estilo BAS devem ser tratados como trabalho conceitual ou futuro, não como um recurso implementado hoje.
A interface atual de relatório de fluxo suporta visualização web, cópia para área de transferência, download em Markdown e PDF. A exportação de relatório de fluxo em JSON não está documentada como formato de saída suportado atualmente.
A flexibilidade de provedores está disponível hoje através de provedores integrados e endpoints customizados/compatíveis com OpenAI. Consulte Configuração de Provedor LLM Personalizado e o guia vLLM + Qwen3.5-27B-FP8.

Arquitetura

Contexto do Sistema```mermaid

flowchart TB classDef person fill:#08427B,stroke:#073B6F,color:#fff classDef system fill:#1168BD,stroke:#0B4884,color:#fff classDef external fill:#666666,stroke:#0B4884,color:#fff

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>Arquitetura do Contêiner</b> (clique para expandir)</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

Relacionamento entre Entidades (clique para expandir)

```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
}

Sistema de Memória (clique para expandir)

```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>Chain Summarization</b> (clique para expandir)</summary>

O sistema de sumarização em cadeia gerencia o crescimento do contexto da conversa ao resumir seletivamente mensagens mais antigas. Isso é crucial para evitar que os limites de token sejam excedidos, mantendo a coerência da conversa.```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

</details> <a id="advanced-agent-supervision"></a> <details> <summary><b>Supervisão Avançada de Agentes</b> (clique para expandir)</summary> O PentAGI inclui mecanismos sofisticados de supervisão de agentes em múltiplas camadas para garantir execução eficiente de tarefas, evitar loops infinitos e fornecer recuperação inteligente de estados travados: ### Monitoramento de Execução (Beta) - **Intervenção Automática do Mentor**: O agente conselheiro (mentor) é invocado automaticamente quando padrões de execução indicam possíveis problemas - **Detecção de Padrões**: Monitora chamadas de ferramentas idênticas (limiar: 5, configurável) e total de chamadas de ferramentas (limiar: 10, configurável) - **Análise de Progresso**: Avalia se o agente avança em direção ao objetivo da subtarefa, detecta loops e ineficiências - **Estratégias Alternativas**: Recomenda diferentes abordagens quando a estratégia atual falha - **Orientação para Recuperação de Informações**: Sugere buscar soluções estabelecidas em vez de reinventar - **Formato de Resposta Aprimorado**: As respostas das ferramentas incluem seções `<original_result>` e `<mentor_analysis>` - **Configurável**: Ative via `EXECUTION_MONITOR_ENABLED` (padrão: false), personalize limites com `EXECUTION_MONITOR_SAME_TOOL_LIMIT` e `EXECUTION_MONITOR_TOTAL_TOOL_LIMIT` **Melhor para**: Modelos menores (< 32B parâmetros), cenários de ataque complexos que exigem orientação contínua, prevenindo que agentes fiquem presos em uma única abordagem **Impacto no Desempenho**: Aumento de 2-3x no tempo de execução e uso de tokens, mas proporciona **melhoria de 2x na qualidade dos resultados** com base em testes com Qwen3.5-27B-FP8 ### Planejamento Inteligente de Tarefas (Beta) - **Decomposição Automatizada**: O planejador (conselheiro em modo de planejamento) gera 3-7 etapas específicas e acionáveis antes de os agentes especialistas começarem o trabalho - **Planos Conscientes do Contexto**: Analisa o contexto completo de execução por meio do agente enriquecedor para criar planos informados - **Atribuição Estruturada**: A solicitação original é encapsulada em estrutura `<task_assignment>` com plano de execução e instruções - **Gerenciamento de Escopo**: Evita aumento de escopo mantendo os agentes focados apenas na subtarefa atual - **Instruções Enriquecedoras**: Os planos destacam ações críticas, possíveis armadilhas e pontos de verificação - **Configurável**: Ative via `AGENT_PLANNING_STEP_ENABLED` (padrão: false) **Melhor para**: Modelos < 32B parâmetros, fluxos de trabalho complexos de teste de penetração, melhorando taxas de sucesso em tarefas sofisticadas **Configuração Aprimorada do Conselheiro**: Funciona excepcionalmente bem quando o agente conselheiro usa um modelo mais forte ou configurações aprimoradas. Exemplo: usar o mesmo modelo base com modo de raciocínio máximo para o conselheiro (veja [`vllm-qwen3.5-27b-fp8.provider.yml`](https://github.com/vxcontrol/pentagi/blob/HEAD/examples/configs/vllm-qwen3.5-27b-fp8.provider.yml)) permite análise abrangente de tarefas e planejamento estratégico a partir da mesma arquitetura de modelo. **Impacto no Desempenho**: Adiciona overhead de planejamento, mas melhora significativamente as taxas de conclusão e reduz trabalho redundante ### Limites de Chamadas de Ferramentas (Sempre Ativo) - **Limites Rígidos**: Evitam execuções descontroladas independentemente do modo de supervisão - **Diferenciado por Tipo de Agente**: - Agentes gerais (Assistente, Agente Principal, Pentester, Codificador, Instalador): `MAX_GENERAL_AGENT_TOOL_CALLS` (padrão: 100) - Agentes limitados (Pesquisador, Enriquecedor, Memorista, Gerador, Relator, Conselheiro, Refletor, Planejador): `MAX_LIMITED_AGENT_TOOL_CALLS` (padrão: 20) - **Término Gracioso**: O refletor guia os agentes para a conclusão adequada quando se aproximam dos limites - **Proteção de Recursos**: Garante estabilidade do sistema e evita esgotamento de recursos ### Integração do Refletor (Sempre Ativo) - **Correção Automática**: Invocado quando o LLM falha ao gerar chamadas de ferramentas após 3 tentativas - **Orientação Estratégica**: Analisa falhas e guia os agentes para o uso adequado de ferramentas ou ferramentas de barreira (`done`, `ask`) - **Mecanismo de Recuperação**: Fornece orientação contextual com base em padrões específicos de falha - **Aplicação de Limites**: Coordena o término gracioso quando os limites de chamadas de ferramentas são atingidos ### Recomendações para Modelos Open Source **Essencial para Modelos < 32B Parâmetros**: Testes com Qwen3.5-27B-FP8 demonstram que ativar tanto o Monitoramento de Execução quanto o Planejamento de Tarefas é **essencial** para modelos open source menores: - **Melhoria de Qualidade**: Resultados 2x melhores em comparação com a execução base sem supervisão - **Prevenção de Loops**: Reduz significativamente loops infinitos e trabalho redundante - **Diversidade de Ataques**: Incentiva a exploração de múltiplos vetores de ataque em vez de fixar-se em uma única abordagem - **Implantações Isoladas (Air-Gapped)**: Permite testes de penetração autônomos de nível profissional em ambientes de rede fechados com inferência LLM local **Compensações**: - Consumo de tokens: aumento de 2-3x devido a invocações do mentor/planejador - Tempo de execução: 2-3x maior devido a etapas de análise e planejamento - Qualidade dos resultados: melhoria de 2x em integridade, precisão e cobertura de ataque - Requisitos de modelo: Funciona melhor quando o conselheiro usa configuração aprimorada (parâmetros de raciocínio mais altos, variante de modelo mais forte ou modelo diferente) **Estratégia de Configuração**: Para desempenho ideal com modelos menores, configure o agente conselheiro com configurações aprimoradas: - Use o mesmo modelo com modo de raciocínio máximo (exemplo: [`vllm-qwen3.5-27b-fp8.provider.yml`](https://github.com/vxcontrol/pentagi/blob/HEAD/examples/configs/vllm-qwen3.5-27b-fp8.provider.yml)) - Ou use um modelo mais forte para o conselheiro enquanto mantém o modelo base para outros agentes - Ajuste os limites de monitoramento com base na complexidade da tarefa e nas capacidades do modelo </details> A arquitetura do PentAGI é projetada para ser modular, escalável e segura. Aqui estão os componentes principais: 1. **Serviços Principais** - Interface do Frontend: Interface web baseada em React com TypeScript para segurança de tipos - API de Backend: APIs REST e GraphQL em Go com autenticação por token Bearer para acesso programático - Armazenamento de Vetores: PostgreSQL com pgvector para busca semântica e armazenamento de memória - Fila de Tarefas: Sistema de processamento assíncrono de tarefas para operação confiável - Agente de IA: Sistema multiagente com funções especializadas para testes eficientes 2. **Grafo de Conhecimento** - Graphiti: API de grafo de conhecimento para rastreamento de relações semânticas e compreensão contextual - Neo4j: Banco de dados de grafos para armazenar e consultar relações entre entidades, ações e resultados - Captura automática de respostas de agentes e execuções de ferramentas para construir base de conhecimento abrangente 3. **Pilha de Monitoramento** - OpenTelemetry: Coleta e correlação unificada de dados de observabilidade - Grafana: Visualização em tempo real e painéis de alerta - VictoriaMetrics: Armazenamento de métricas de série temporal de alto desempenho - Jaeger: Rastreamento distribuído de ponta a ponta para depuração - Loki: Agregação e análise de logs escalável 4. **Plataforma de Analytics** - Langfuse: Observabilidade avançada de LLM e análise de desempenho - ClickHouse: Data warehouse analítico orientado a colunas - Redis: Cache de alta velocidade e limitação de taxa - MinIO: Armazenamento de objetos compatível com S3 para artefatos 5. **Ferramentas de Segurança** - Raspador Web: Ambiente de navegador isolado para interação web segura - Ferramentas de Teste de Penetração: Conjunto abrangente de mais de 20 ferramentas de segurança profissionais - Execução em Sandbox: Todas as operações executadas em contêineres isolados 6. **Sistemas de Memória** - Memória de Longo Prazo: Armazenamento persistente de conhecimento e experiências - Memória de Trabalho: Contexto ativo e objetivos para operações atuais - Memória Episódica: Ações históricas e padrões de sucesso - Base de Conhecimento: Expertise de domínio estruturada e capacidades de ferramentas - Gerenciamento de Contexto: Gerencia inteligentemente o crescimento do contexto do LLM usando sumarização em cadeia O sistema usa contêineres Docker para isolamento e implantação fácil, com redes separadas para serviços principais, monitoramento e analytics para garantir limites de segurança adequados. Cada componente é projetado para escalar horizontalmente e pode ser configurado para alta disponibilidade em ambientes de produção. ## Início Rápido ### Requisitos do Sistema - Docker e Docker Compose (ou Podman - veja [Configuração do Podman](#executando-pentagi-com-podman)) - Mínimo de 2 vCPU - Mínimo de 4GB de RAM - 20GB de espaço livre em disco - Acesso à Internet para baixar imagens e atualizações ### Usando o Instalador (Recomendado) O PentAGI fornece um instalador interativo com uma interface de usuário baseada em terminal para configuração e implantação simplificadas. O instalador guia você através de verificações do sistema, configuração do provedor LLM, configuração do mecanismo de busca e fortalecimento de segurança. **Plataformas Suportadas:** - **Linux**: amd64 [download](https://pentagi.com/downloads/linux/amd64/installer-latest.zip) | arm64 [download](https://pentagi.com/downloads/linux/arm64/installer-latest.zip) - **Windows**: amd64 [download](https://pentagi.com/downloads/windows/amd64/installer-latest.zip) - **macOS**: amd64 (Intel) [download](https://pentagi.com/downloads/darwin/amd64/installer-latest.zip) | arm64 (M-series) [download](https://pentagi.com/downloads/darwin/arm64/installer-latest.zip) **Instalação Rápida (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

4. Preencha as chaves de API necessárias no arquivo `.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

Se você vir saída HTML, o scraper está funcionando corretamente. #### Modo Rootful do Podman Se você estiver executando o Podman em modo rootful (com sudo), pode usar a configuração padrão sem modificações. O scraper funcionará na porta 443 conforme pretendido. #### Compatibilidade com Docker Todas as configurações do Podman permanecem totalmente compatíveis com Docker. A abordagem de porta não privilegiada funciona de forma idêntica em ambos os runtimes de contêiner. ### Configuração do Assistente O PentAGI permite configurar o comportamento padrão para assistentes: | Variável | Padrão | Descrição | | -------------------- | ------- | ------------------------------------------------------------------ | | `ASSISTANT_USE_AGENTS` | `false` | Controla o valor padrão para uso de agentes ao criar novos assistentes | A configuração `ASSISTANT_USE_AGENTS` afeta o estado inicial da opção "Usar Agentes" ao criar um novo assistente na interface: - `false` (padrão): Novos assistentes são criados com delegação de agentes desativada por padrão - `true`: Novos assistentes são criados com delegação de agentes ativada por padrão Note que os usuários podem sempre sobrescrever essa configuração alternando o botão "Usar Agentes" na interface ao criar ou editar um assistente. Esta variável de ambiente controla apenas o estado padrão inicial. ## Como Usar o PentAGI Após o Login Assim que o stack estiver em execução e você puder fazer login na interface web, a maneira mais rápida de começar é através do fluxo de trabalho Flows. ### 1. Crie seu primeiro fluxo 1. Abra **Flows** na barra lateral. 2. Clique em **Novo Fluxo**. 3. Escolha o modo que se adequa ao seu objetivo: - **Automação**: execução totalmente autônoma para um objetivo de teste que você deseja que o PentAGI realize do início ao fim - **Assistente**: ajuda interativa de ida e volta quando você deseja conduzir a investigação passo a passo. Neste modo, você também pode ativar a opção **Usar Agentes** para permitir que o PentAGI delegue subtarefas a subagentes especializados para investigações mais complexas. 4. Selecione o provedor LLM que deseja usar para este fluxo. 5. Descreva o alvo e o objetivo em linguagem natural na caixa de mensagem. Bons prompts iniciais geralmente incluem: - o sistema alvo ou URL - o tipo de avaliação que você deseja - quaisquer limitações de escopo ou regras de engajamento - o resultado que você espera, como um relatório de vulnerabilidade ou validação de uma hipótese Exemplo:```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.

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()

List all flows

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

</details>

<details>
<summary><b>Exemplo de Cliente 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}`);

> [!NOTE] > **Google Vertex AI para modelos Claude** > > O PentAGI atualmente não expõe um caminho de configuração dedicado do Google Vertex AI para Anthropic Claude no `.env`. Não há um campo de chave de API Vertex AI separado neste momento, e as variáveis Anthropic existentes (`ANTHROPIC_API_KEY`, `ANTHROPIC_SERVER_URL`) visam a API Anthropic direta. As rotas suportadas para Claude são: > > - **API Anthropic Direta**: `ANTHROPIC_API_KEY` e `ANTHROPIC_SERVER_URL` (veja acima). > - **AWS Bedrock**: Variáveis `BEDROCK_*` (veja [Configuração do Provedor AWS Bedrock](#aws-bedrock-provider-configuration)). > > Se você precisar usar o Vertex AI hoje, a solução alternativa suportada mais segura é expor o Vertex AI através de um proxy ou gateway compatível com OpenAI que traduza as chamadas do Vertex AI para o formato Chat Completions, preservando o comportamento de chat e chamada de ferramentas do qual o PentAGI depende, e então aponte o provedor LLM Personalizado para esse gateway via `LLM_SERVER_URL`, `LLM_SERVER_KEY` e `LLM_SERVER_MODEL`. Este caminho é tão confiável quanto o gateway que você escolher. #### Modelos Suportados O PentAGI suporta 10 modelos Claude com chamada de ferramentas, streaming, pensamento estendido, pensamento adaptativo e cache de prompt. Os modelos marcados com `*` são usados na configuração padrão. **Série Claude 4 - Modelos Mais Recentes (2025-2026)** | ID do Modelo | Pensamento | Data de Lançamento | Preço (Entrada/Saída/Cache R/W) | Caso de Uso | | ------------------------ | ---------- | ------------------ | ------------------------------- | ----------------------------------------------- | | `claude-opus-4-6`* | ✅ | Maio 2025 | $5,00/$25,00/$0,50/$6,25 | Modelo mais inteligente para agentes autônomos e codificação. Pensamento estendido + adaptativo para desenvolvimento complexo de exploits, simulação de ataque em múltiplos estágios | | `claude-sonnet-4-6`* | ✅ | Agosto 2025 | $3,00/$15,00/$0,30/$3,75 | Melhor equilíbrio velocidade/inteligência com pensamento adaptativo. Avaliações de segurança em várias fases, análise inteligente de vulnerabilidades, caça a ameaças em tempo real | | `claude-haiku-4-5`* | ✅ | Outubro 2025 | $1,00/$5,00/$0,10/$1,25 | Modelo mais rápido com inteligência quase de ponta. Varredura de alta frequência, monitoramento em tempo real, testes automatizados em lote | **Modelos Legados - Ainda Suportados** | ID do Modelo | Pensamento | Data de Lançamento | Preço (Entrada/Saída/Cache R/W) | Caso de Uso | | ------------------------ | ---------- | ------------------ | ------------------------------- | ----------------------------------------------- | | `claude-sonnet-4-5` | ✅ | Setembro 2025 | $3,00/$15,00/$0,30/$3,75 | Raciocínio de ponta (substituído pela série 4-6). Testes de penetração sofisticados, análise avançada de ameaças | | `claude-opus-4-5` | ✅ | Novembro 2025 | $5,00/$25,00/$0,50/$6,25 | Raciocínio definitivo (substituído por opus-4-6). Pesquisa crítica de segurança, descoberta de zero-day, operações de red team | | `claude-opus-4-1` | ✅ | Agosto 2025 | $15,00/$75,00/$1,50/$18,75 | Raciocínio avançado (substituído). Testes de penetração complexos, modelagem sofisticada de ameaças | | `claude-sonnet-4-0` | ✅ | Maio 2025 | $3,00/$15,00/$0,30/$3,75 | Raciocínio de alto desempenho (substituído). Modelagem complexa de ameaças, coordenação de múltiplas ferramentas | | `claude-opus-4-0` | ✅ | Maio 2025 | $15,00/$75,00/$1,50/$18,75 | Primeira geração Opus (substituído). Desenvolvimento de exploits em várias etapas, fluxos de trabalho autônomos de pentest | **Modelos Descontinuados - Migre para Modelos Atuais** | ID do Modelo | Pensamento | Data de Lançamento | Preço (Entrada/Saída/Cache R/W) | Notas | | ---------------------------- | ---------- | ------------------ | ------------------------------- | -------------------------------------------- | | `claude-3-haiku-20240307` | ❌ | Março 2024 | $0,25/$1,25/$0,03/$0,30 | Será desativado em 19 de abril de 2026. Migre para claude-haiku-4-5 | **Preços**: Por 1M de tokens. O preço do cache inclui custos de Leitura e Escrita. **Configuração de Pensamento Estendido**: - **Max Tokens 4096**: Gerador (claude-opus-4-6) para profundidade máxima de raciocínio em desenvolvimento complexo de exploits - **Max Tokens 2048**: Codificador (claude-sonnet-4-6) para análise equilibrada de código e pesquisa de vulnerabilidades - **Max Tokens 1024**: Agente primário, assistente, refinador, conselheiro, refletor, pesquisador, instalador, testador de penetração para raciocínio focado em tarefas específicas - **Pensamento Estendido**: Todos os modelos Claude 4.5+ e 4.6 suportam pensamento estendido configurável para tarefas de raciocínio profundo **Principais Recursos**: - **Pensamento Estendido**: Todos os modelos Claude 4.5+ e 4.6 com profundidades configuráveis de raciocínio em cadeia de pensamento para análise de segurança complexa - **Pensamento Adaptativo**: A série Claude 4.6 (Opus/Sonnet) ajusta dinamicamente a profundidade do raciocínio com base na complexidade da tarefa para desempenho ideal - **Cache de Prompt**: Redução significativa de custos com preços separados de leitura/escrita (10% leitura, 125% escrita do valor de entrada) - **Janela de Contexto Estendida**: 200 mil tokens padrão, até 1 milhão de tokens (beta) para Claude Opus/Sonnet 4.6 para análise abrangente de base de código - **Chamada de Ferramentas**: Chamada de função robusta com exatidão excepcional para orquestração de ferramentas de segurança - **Streaming**: Streaming de resposta em tempo real para fluxos de trabalho interativos de teste de penetração - **Design Focado em Segurança**: Mecanismos de segurança integrados garantindo práticas responsáveis de teste de segurança - **Suporte Multimodal**: Capacidades de visão nos modelos mais recentes para análise de capturas de tela e avaliação de segurança de interface do usuário - **IA Constitucional**: Treinamento avançado de segurança fornecendo orientação de segurança confiável e ética ### Configuração do Provedor Google AI (Gemini) O PentAGI integra-se com os modelos Gemini do Google através da API Google AI, oferecendo capacidades multimodais de raciocínio de ponta com pensamento estendido e cache de contexto. #### Variáveis de Configuração | Variável | Padrão | Descrição | | ------------------ | -------------------------------------------- | ------------------------------ | | `GEMINI_API_KEY` | | Chave de API para serviços Google AI | | `GEMINI_SERVER_URL`| `https://generativelanguage.googleapis.com` | Endpoint da API Google AI | #### Exemplos de Configuração```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

#### Modelos Suportados PentAGI suporta 21 modelos AWS Bedrock com capacidades de chamada de ferramenta, streaming e multimodal. Modelos marcados com `*` são usados na configuração padrão. | Model ID | Provedor | Pensamento | Multimodal | Preço (Entrada/Saída) | Caso de Uso | | ------------------------------------------------ | --------------- | ---------- | ---------- | --------------------- | ------------------------------------------ | | `us.amazon.nova-2-lite-v1:0` | Amazon Nova | ❌ | ✅ | $0.33/$2.75 | Raciocínio adaptativo, pensamento eficiente | | `us.amazon.nova-premier-v1:0` | Amazon Nova | ❌ | ✅ | $2.50/$12.50 | Raciocínio complexo, análise avançada | | `us.amazon.nova-pro-v1:0` | Amazon Nova | ❌ | ✅ | $0.80/$3.20 | Precisão balanceada, velocidade, custo | | `us.amazon.nova-lite-v1:0` | Amazon Nova | ❌ | ✅ | $0.06/$0.24 | Processamento rápido, operações de alto volume | | `us.amazon.nova-micro-v1:0` | Amazon Nova | ❌ | ❌ | $0.035/$0.14 | Latência ultrabaixa, monitoramento em tempo real | | `us.anthropic.claude-opus-4-6-v1`* | Anthropic | ✅ | ✅ | $5.00/$25.00 | Codificação de classe mundial, agentes empresariais | | `us.anthropic.claude-sonnet-4-6` | Anthropic | ✅ | ✅ | $3.00/$15.00 | Inteligência de fronteira, escala empresarial | | `us.anthropic.claude-opus-4-5-20251101-v1:0` | Anthropic | ✅ | ✅ | $5.00/$25.00 | Desenvolvimento de software de vários dias | | `us.anthropic.claude-haiku-4-5-20251001-v1:0`* | Anthropic | ✅ | ✅ | $1.00/$5.00 | Desempenho próximo da fronteira, alta velocidade | | `us.anthropic.claude-sonnet-4-5-20250929-v1:0`* | Anthropic | ✅ | ✅ | $3.00/$15.00 | Agentes do mundo real, excelência em codificação | | `us.anthropic.claude-sonnet-4-20250514-v1:0` | Anthropic | ✅ | ✅ | $3.00/$15.00 | Desempenho balanceado, pronto para produção | | `us.anthropic.claude-3-5-haiku-20241022-v1:0` | Anthropic | ❌ | ❌ | $0.80/$4.00 | Modelo mais rápido, varredura econômica | | `cohere.command-r-plus-v1:0` | Cohere | ❌ | ❌ | $3.00/$15.00 | Operações em larga escala, RAG superior | | `deepseek.v3.2` | DeepSeek | ❌ | ❌ | $0.58/$1.68 | Raciocínio de contexto longo, eficiência | | `openai.gpt-oss-120b-1:0`* | OpenAI (OSS) | ✅ | ❌ | $0.15/$0.60 | Raciocínio forte, análise científica | | `openai.gpt-oss-20b-1:0` | OpenAI (OSS) | ✅ | ❌ | $0.07/$0.30 | Codificação eficiente, desenvolvimento de software | | `qwen.qwen3-next-80b-a3b` | Qwen | ❌ | ❌ | $0.15/$1.20 | Contexto ultra longo, raciocínio de ponta | | `qwen.qwen3-32b-v1:0` | Qwen | ❌ | ❌ | $0.15/$0.60 | Raciocínio balanceado, casos de uso de pesquisa | | `qwen.qwen3-coder-30b-a3b-v1:0` | Qwen | ❌ | ❌ | $0.15/$0.60 | Codificação por vibração, primeiramente em linguagem natural | | `qwen.qwen3-coder-next` | Qwen | ❌ | ❌ | $0.45/$1.80 | Uso de ferramentas, chamada de função otimizada | | `mistral.mistral-large-3-675b-instruct` | Mistral | ❌ | ✅ | $4.00/$12.00 | Multimodal avançado, contexto longo | | `moonshotai.kimi-k2.5` | Moonshot | ❌ | ✅ | $0.60/$3.00 | Visão, linguagem, código em um modelo | **Preços**: Por 1M tokens. Modelos com suporte a pensamento/raciocínio incorrem em custos de computação adicionais durante a fase de raciocínio. #### Modelos Testados mas Incompatíveis Alguns modelos AWS Bedrock foram testados, mas **não são suportados** devido a limitações técnicas: | Família do Modelo | Motivo da Incompatibilidade | | ------------------------ | -------------------------------------------------------------------------------------------- | | **GLM (Z.AI)** | Formato de chamada de ferramenta incompatível com a API Converse (espera string em vez de JSON) | | **AI21 Jamba** | Limites de taxa severos (1-2 req/min) impedem testes confiáveis e uso em produção | | **Meta Llama 3.3/3.1** | Processamento instável de resultados de chamada de ferramenta, causando falhas inesperadas em fluxos de trabalho de múltiplas rodadas | | **Mistral Magistral** | Chamada de ferramenta não suportada pelo modelo | | **Moonshot K2-Thinking** | Comportamento de streaming instável com chamadas de ferramenta, não confiável em produção | | **Qwen3-VL** | Streaming instável com chamada de ferramenta, combinação multimodal + ferramentas falha intermitentemente | > [!IMPORTANT] > **Gerenciamento de Limites de Taxa e Cotas** > > As cotas padrão do AWS Bedrock para modelos Claude são **extremamente restritivas** (2-20 solicitações/minuto para novas contas). Para testes de penetração em produção: > > 1. **Solicite aumentos de cota** através do console AWS Service Quotas para os modelos que você planeja usar > 2. **Use modelos Amazon Nova** - cotas padrão mais altas e excelente desempenho > 3. **Habilite throughput provisionado** para testes consistentes de alto volume > 4. **Monitore o uso** - a AWS limita agressivamente nos limites de cota > > Sem aumentos de cota, espere atrasos frequentes e interrupções no fluxo de trabalho. > [!WARNING] > **Requisitos da API Converse** > > PentAGI usa a **API Converse** do Amazon Bedrock para acesso unificado ao modelo. Todos os modelos suportados requerem: > > - ✅ Suporte à API Converse/ConverseStream > - ✅ Uso de ferramentas (chamada de função) para fluxos de trabalho de teste de penetração > - ✅ Uso de ferramentas em streaming para feedback em tempo real > > Verifique as capacidades do modelo em: [AWS Bedrock Model Features](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-supported-models-features.html) **Principais Recursos**: - **Cache Automático de Prompt**: redução de 40-70% nos custos em contexto repetido (modelos Claude 4.x) - **Pensamento Estendido**: raciocínio passo a passo para análise de segurança complexa (Claude, DeepSeek R1, OpenAI GPT) - **Análise Multimodal**: Processar capturas de tela, diagramas, vídeo para testes abrangentes (Nova, Claude, Mistral, Kimi) - **Chamada de Ferramenta**: Integração perfeita com mais de 20 ferramentas de pentest via chamada de função - **Streaming**: Fluxo de resposta em tempo real para fluxos de trabalho interativos de avaliação de segurança ### Configuração do Provedor DeepSeek PentAGI se integra ao DeepSeek, fornecendo acesso a modelos avançados de IA com forte raciocínio, capacidades de codificação e cache de contexto a preços competitivos. #### Variáveis de Configuração | Variável | Valor Padrão | Descrição | | --------------------- | ------------------------------ | ------------------------------------------------ | | `DEEPSEEK_API_KEY` | | Chave da API DeepSeek para autenticação | | `DEEPSEEK_SERVER_URL` | `https://api.deepseek.com` | URL do endpoint da API DeepSeek | | `DEEPSEEK_PROVIDER` | | Prefixo do provedor para integração com LiteLLM (opcional) | #### Exemplos de Configuração```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

#### Modelos Suportados O PentAGI suporta 13 modelos GLM com chamada de ferramentas, streaming, modos de pensamento híbridos e cache de prompt. Modelos marcados com `*` são usados na configuração padrão. O pensamento é controlado via `extra_body.thinking.type` ("enabled"/"disabled"); diferente do Kimi, o GLM é permissivo quanto à temperatura em ambos os modos. **Série GLM-5.x - Última Geração (contexto de 200K, saída máxima de 128K)** | ID do Modelo | Pensamento | Contexto | Saída Máx. | Preço (Entrada/Saída/Cache) | Caso de Uso | | --------------- | ---------- | -------- | ---------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | | `glm-5.1`* | ✅ Híbrido | 200K | 128K | $1,40/$4,40/$0,26 | Principal mais recente: execução autônoma sustentada por 8h, alinhado ao Claude Opus 4.6 (padrão para gerador/refinador/conselheiro/pentester) | | `glm-5` | ✅ Híbrido | 200K | 128K | $1,00/$3,20/$0,20 | Fundação para Engenharia de Agentes, MoE 744B/40B ativos, codificação no nível Claude Opus 4.5 | | `glm-5-turbo`* | ✅ Híbrido | 200K | 128K | $1,20/$4,00/$0,24 | Nativo OpenClaw: otimizado para invocação de ferramentas, tarefas persistentes, execução de longa cadeia (padrão para agente_principal/assistente) | **Série GLM-4.7 - Premium com Pensamento Intercalado** | ID do Modelo | Pensamento | Contexto | Saída Máx. | Preço (Entrada/Saída/Cache) | Caso de Uso | | ---------------- | ---------- | -------- | ---------- | ---------------------------- | ------------------------------------------------------------------------- | | `glm-4.7` | ✅ Híbrido | 200K | 128K | $0,60/$2,20/$0,11 | Programação aprimorada, raciocínio multi-etapas estável | | `glm-4.7-flashx` | ✅ Híbrido | 200K | 128K | $0,07/$0,40/$0,01 | Ultra barato com GPU prioritária, mas limites RPM mais baixos (evite para uso de alta frequência) | | `glm-4.7-flash` | ✅ Híbrido | 200K | 128K | Grátis/Grátis/Grátis | Modelo SOTA ~30B gratuito, 1 requisição concorrente | **Série GLM-4.6 - Equilibrado com Pensamento Automático** | ID do Modelo | Pensamento | Contexto | Saída Máx. | Preço (Entrada/Saída/Cache) | Caso de Uso | | ------------ | ---------- | -------- | ---------- | ---------------------------- | ----------------------------------------------------- | | `glm-4.6` | ✅ Auto | 200K | 128K | $0,60/$2,20/$0,11 | Equilibrado, chamadas de ferramentas em streaming, eficiente em tokens | **Série GLM-4.5 - Raciocínio/Codificação/Agentes Unificados** | ID do Modelo | Pensamento | Contexto | Saída Máx. | Preço (Entrada/Saída/Cache) | Caso de Uso | | ------------------- | ---------- | -------- | ---------- | ---------------------------- | ---------------------------------------------------- | | `glm-4.5` | ✅ Auto | 128K | 96K | $0,60/$2,20/$0,11 | Unificado, MoE 355B/32B ativos | | `glm-4.5-x` | ✅ Auto | 128K | 96K | $2,20/$8,90/$0,45 | Premium ultra-rápido, menor latência | | `glm-4.5-air`* | ✅ Auto | 128K | 96K | $0,20/$1,10/$0,03 | MoE 106B/12B econômico (padrão para simple/simple_json/reflector/searcher/enricher/installer) | | `glm-4.5-airx` | ✅ Auto | 128K | 96K | $1,10/$4,50/$0,22 | Air acelerado com GPU prioritária | | `glm-4.5-flash` | ✅ Auto | 128K | 96K | Grátis/Grátis/Grátis | Gratuito com suporte a raciocínio/codificação/agentes | **GLM-4 Legado - Arquitetura Densa** | ID do Modelo | Pensamento | Contexto | Saída Máx. | Preço (Entrada/Saída) | Caso de Uso | | -------------------------- | ---------- | -------- | ---------- | --------------------- | -------------------------------------------------- | | `glm-4-32b-0414-128k` | ❌ | 128K | 16K | $0,10/$0,10 | Denso 32B ultra-econômico, análise sem raciocínio | **Preços**: Por 1 milhão de tokens. O preço de cache é para acerto de cache do prompt; o armazenamento de cache é atualmente gratuito conforme promoção do Z.AI. GLM-4-32B não possui suporte a cache. **Configuração Padrão de Agentes**: Estratégia: `glm-5.1` (principal mais recente, $1,40 de entrada) para raciocínio crítico, `glm-5-turbo` (nativo OpenClaw, otimizado para agentes) para orquestração, `glm-4.5-air` (MoE barato com pensamento híbrido e RPM confiável) para todos os agentes utilitários/instaladores. `glm-4.7-flashx` é evitado como padrão devido aos limites RPM mais baixos que causam erros 429 frequentes em alta frequência. | Função do Agente | Modelo Padrão | Pensamento | Temperatura | Top P | Saída Máx. | | --------------------------------- | ------------- | ---------- | ----------- | ----- | ---------- | | Gerador / Refinador | `glm-5.1` | Ativado | 1,0 | 0,95 | 32768 | | Codificador | `glm-5.1` | Ativado | 1,0 | 0,95 | 20480 | | Conselheiro / Pentester | `glm-5.1` | Ativado | 1,0 | 0,95 | 16384 | | Agente Principal / Assistente | `glm-5-turbo` | Ativado | 1,0 | 0,95 | 16384 | | Instalador | `glm-4.5-air` | Ativado | 1,0 | 0,95 | 16384 | | Simples / Refletor | `glm-4.5-air` | Desativado | 0,6 | 0,9 | 8192 | | Pesquisador / Enriquecedor / JSON Simples | `glm-4.5-air` | Desativado | 0,6 | 0,9 | 4096 | > **Nota sobre temperatura**: GLM aceita tanto `1.0` quanto `0.6` em ambos os modos de pensamento/não pensamento (conforme docs do Z.AI). O `IsReasoningModel` do langchaingo corresponde aos prefixos `glm-4.5*`/`glm-4.6*`/`glm-4.7*` e força a substituição da temperatura para 1.0 em `createChatRequest` — isso é inofensivo para GLM (diferente do Kimi), mas significa que os valores de temperatura para esses modelos no YAML são meramente informativos. `glm-5`/`glm-5.1`/`glm-5-turbo` não são correspondidos, portanto os valores explícitos passam sem alteração. **Modos de Pensamento**: - **Híbrido** (GLM-5.x, GLM-4.7): Alternância explícita via `extra_body.thinking.type` - **Automático** (séries GLM-4.6, GLM-4.5): O modelo determina automaticamente quando o raciocínio é necessário - **Pensamento Preservado** (capacidade de Codificação Z.AI): todos os agentes com pensamento ativado no PentAGI também passam `extra_body.thinking.clear_thinking: false` para que o `reasoning_content` de turnos anteriores do assistente seja mantido ao longo da conversa. Isso é necessário no endpoint padrão da API (`/api/paas/v4`) — no endpoint do Plano de Codificação estaria ativado por padrão. Melhora a continuidade do raciocínio e as taxas de acerto de cache em cadeias de chamadas de ferramentas com múltiplos turnos. - Todos os agentes com pensamento ativado também passam `extra_body.tool_choice: auto` defensivamente **Principais Características**: - **Tarefas de Longo Horizonte**: GLM-5.1 suporta execução autônoma sustentada por 8 horas, ideal para workflows agentivos complexos de múltiplas etapas - **Orquestração Nativa OpenClaw**: GLM-5-Turbo é especificamente otimizado para invocação de ferramentas, seguimento de instruções e execução de longa cadeia - **Cache de Prompt**: Redução significativa de custos em contexto repetido (preço de entrada em cache mostrado) - **Contexto Ultra Longo**: 200K tokens para as séries GLM-5.x/4.7/4.6 - **Arquitetura MoE**: Eficiente 744B/40B ativos (GLM-5/5.1), 355B/32B (GLM-4.5), 106B/12B (GLM-4.5-Air) - **Chamada de Ferramentas**: Integração perfeita com mais de 20 ferramentas de pentest via chamada de funções - **Streaming**: Streaming em tempo real com suporte a chamadas de ferramentas em streaming (GLM-4.6+) - **Multilíngue**: Capacidades excepcionais de PNL em Chinês e Inglês - **Opções Gratuitas**: GLM-4.7-Flash e GLM-4.5-Flash para prototipagem e experimentação **Integração LiteLLM**: Defina `GLM_PROVIDER=zai` para ativar o prefixo do nome do modelo ao usar configurações padrão do PentAGI com proxy LiteLLM. Deixe vazio para uso direto da API. ### Configuração do Provedor Kimi O PentAGI integra-se com o Kimi da Moonshot AI, fornecendo modelos de contexto ultra longo com capacidades multimodais perfeitas para analisar bases de código e documentação extensas. #### Variáveis de Configuração | Variável | Valor Padrão | Descrição | | ------------------ | ------------------------------ | -------------------------------------------------- | | `KIMI_API_KEY` | | Chave da API Kimi para autenticação | | `KIMI_SERVER_URL` | `https://api.moonshot.ai/v1` | URL do endpoint da API Kimi (internacional) | | `KIMI_PROVIDER` | | Prefixo do provedor para integração LiteLLM (opcional) | #### Exemplos de Configuração```bash # Direct API usage (international endpoint) KIMI_API_KEY=your_kimi_api_key KIMI_SERVER_URL=https://api.moonshot.ai/v1 # Alternative endpoint KIMI_SERVER_URL=https://api.moonshot.cn/v1 # China # With LiteLLM proxy KIMI_API_KEY=your_litellm_key KIMI_SERVER_URL=http://litellm-proxy:4000 KIMI_PROVIDER=moonshot # Adds prefix to model names (moonshot/kimi-k2.5) for LiteLLM

Parâmetro	Variável de Ambiente	Padrão	Descrição
Preservar Último	`SUMMARIZER_PRESERVE_LAST`	`true`	Se deve manter todas as mensagens da última seção intactas
Usar Pares QA	`SUMMARIZER_USE_QA`	`true`	Se deve usar a estratégia de sumarização de pares QA
Sumarizar Humano em QA	`SUMMARIZER_SUM_MSG_HUMAN_IN_QA`	`false`	Se deve sumarizar mensagens humanas em pares QA
Tamanho da Última Seção	`SUMMARIZER_LAST_SEC_BYTES`	`51200`	Tamanho máximo em bytes para a última seção (50KB)
Tamanho Máx. do Par Corpo	`SUMMARIZER_MAX_BP_BYTES`	`16384`	Tamanho máximo em bytes para um único par de corpo (16KB)
Máx. Seções QA	`SUMMARIZER_MAX_QA_SECTIONS`	`10`	Número máximo de seções de pares QA a preservar
Tamanho Máx. QA	`SUMMARIZER_MAX_QA_BYTES`	`65536`	Tamanho máximo em bytes para seções de pares QA (64KB)
Manter Seções QA	`SUMMARIZER_KEEP_QA_SECTIONS`	`1`	Número de seções QA recentes a manter sem sumarização

Parâmetro	Variável de Ambiente	Padrão	Descrição
Preservar Último	`ASSISTANT_SUMMARIZER_PRESERVE_LAST`	`true`	Se deve preservar todas as mensagens na última seção do assistente
Tamanho da Última Seção	`ASSISTANT_SUMMARIZER_LAST_SEC_BYTES`	`76800`	Tamanho máximo em bytes para a última seção do assistente (75KB)
Tamanho Máx. do Par Corpo	`ASSISTANT_SUMMARIZER_MAX_BP_BYTES`	`16384`	Tamanho máximo em bytes para um único par de corpo no contexto do assistente (16KB)
Máx. Seções QA	`ASSISTANT_SUMMARIZER_MAX_QA_SECTIONS`	`7`	Número máximo de seções QA a preservar no contexto do assistente
Tamanho Máx. QA	`ASSISTANT_SUMMARIZER_MAX_QA_BYTES`	`76800`	Tamanho máximo em bytes para seções QA do assistente (75KB)
Manter Seções QA	`ASSISTANT_SUMMARIZER_KEEP_QA_SECTIONS`	`3`	Número de seções QA recentes a preservar sem sumarização

Variável	Padrão	Descrição
`LLM_SERVER_URL`		URL base para o endpoint da API de LLM personalizada
`LLM_SERVER_KEY`		Chave de API para o provedor de LLM personalizado
`LLM_SERVER_MODEL`		Modelo padrão a ser usado (pode ser sobrescrito na configuração do provedor)
`LLM_SERVER_CONFIG_PATH`		Caminho para o arquivo de configuração YAML para modelos específicos de agente
`LLM_SERVER_PROVIDER`		Prefixo do nome do provedor para nomes de modelos (ex.: `openrouter`, `deepseek` para proxy LiteLLM)
`LLM_SERVER_LEGACY_REASONING`	`false`	Controla o formato de raciocínio nas requisições da API
`LLM_SERVER_PRESERVE_REASONING`	`false`	Preserva o conteúdo de raciocínio em conversas de múltiplas rodadas (exigido por alguns provedores)

Variável	Padrão	Descrição
`OLLAMA_SERVER_URL`		URL do seu servidor Ollama ou Ollama Cloud
`OLLAMA_SERVER_API_KEY`		Chave de API para autenticação no Ollama Cloud
`OLLAMA_SERVER_MODEL`		Modelo padrão para inferência
`OLLAMA_SERVER_CONFIG_PATH`		Caminho para o arquivo de configuração do agente personalizado
`OLLAMA_SERVER_PULL_MODELS_TIMEOUT`	`600`	Tempo limite para download de modelos (segundos)
`OLLAMA_SERVER_PULL_MODELS_ENABLED`	`false`	Baixar modelos automaticamente na inicialização
`OLLAMA_SERVER_LOAD_MODELS_ENABLED`	`false`	Consultar o servidor por modelos disponíveis

ID do Modelo	Raciocínio	Preço (Entrada/Saída/Cache)	Caso de Uso
`gpt-5.2`*	✅	$1.75/$14.00/$0.18	Principal mais recente com raciocínio aprimorado e integração de ferramentas, pesquisa autônoma de segurança
`gpt-5.2-pro`	✅	$21.00/$168.00/$0.00	Versão premium com programação agente superior, pesquisa de segurança de missão crítica, descoberta de dia zero
`gpt-5.2-codex`	✅	$1.75/$14.00/$0.18	Mais avançado especializado em código, compactação de contexto, fortes capacidades de cibersegurança

ID do Modelo	Raciocínio	Preço (Entrada/Saída/Cache)	Caso de Uso
`gpt-5`	✅	$1.25/$10.00/$0.13	Principal agente com raciocínio avançado, pesquisa autônoma de segurança, desenvolvimento de cadeias de exploit
`gpt-5.1`	✅	$1.25/$10.00/$0.13	Agente aprimorado com raciocínio adaptativo, testes de penetração equilibrados com forte coordenação de ferramentas
`gpt-5-pro`	✅	$15.00/$120.00/$0.00	Versão premium com grandes melhorias de raciocínio, redução de alucinações, operações críticas de segurança
`gpt-5-mini`	✅	$0.25/$2.00/$0.03	Eficiente equilibrando velocidade e inteligência, análise automatizada de vulnerabilidades, geração de exploits
`gpt-5-nano`	✅	$0.05/$0.40/$0.01	Mais rápido para varreduras de alto rendimento, reconhecimento, detecção em massa de vulnerabilidades

ID do Modelo	Raciocínio	Preço (Entrada/Saída/Cache)	Caso de Uso
`gpt-5.1-codex-max`	✅	$1.25/$10.00/$0.13	Raciocínio aprimorado para programação sofisticada, descobertas comprovadas de CVE, desenvolvimento sistemático de exploits
`gpt-5.1-codex`	✅	$1.25/$10.00/$0.13	Otimizado para código padrão com forte raciocínio, geração de exploits, análise de vulnerabilidades
`gpt-5-codex`	✅	$1.25/$10.00/$0.13	Especializado em código fundamental, varredura de vulnerabilidades, geração básica de exploits
`gpt-5.1-codex-mini`	✅	$0.25/$2.00/$0.03	Compacto de alto desempenho, capacidade 4x maior, detecção rápida de vulnerabilidades
`codex-mini-latest`	✅	$1.50/$6.00/$0.38	Modelo de código compacto mais recente, revisão automática de código, análise básica de vulnerabilidades

ID do Modelo	Raciocínio	Preço (Entrada/Saída/Cache)	Caso de Uso
`gpt-4.1`	❌	$2.00/$8.00/$0.50	Principal aprimorado com chamada de função superior, análise complexa de ameaças, desenvolvimento sofisticado de exploits
`gpt-4.1-mini`*	❌	$0.40/$1.60/$0.10	Desempenho equilibrado com eficiência melhorada, avaliações de segurança de rotina, análise automática de código
`gpt-4.1-nano`	❌	$0.10/$0.40/$0.03	Leve ultrarrápido, varredura de segurança em massa, reconhecimento rápido, monitoramento contínuo

ID do Modelo	Raciocínio	Preço (Entrada/Saída/Cache)	Caso de Uso
`gpt-4o`	❌	$2.50/$10.00/$1.25	Principal multimodal com visão, análise de imagens, avaliação de interface web, orquestração de múltiplas ferramentas
`gpt-4o-mini`	❌	$0.15/$0.60/$0.08	Multimodal compacto com forte chamada de função, varredura de alta frequência, operações em massa econômicas

ID do Modelo	Raciocínio	Preço (Entrada/Saída/Cache)	Caso de Uso
`o4-mini`*	✅	$1.10/$4.40/$0.28	Raciocínio de próxima geração com velocidade aprimorada, avaliações metódicas de segurança, desenvolvimento sistemático de exploits
`o3`*	✅	$2.00/$8.00/$0.50	Potência de raciocínio avançado, cadeias de ataque em múltiplos estágios, análise profunda de vulnerabilidades
`o3-mini`	✅	$1.10/$4.40/$0.55	Raciocínio compacto com pensamento estendido, planejamento passo a passo de ataques, encadeamento lógico de vulnerabilidades
`o1`	✅	$15.00/$60.00/$7.50	Raciocínio principal com profundidade máxima, testes avançados de penetração, pesquisa de exploits inovadores
`o3-pro`	✅	$20.00/$80.00/$0.00	Raciocínio mais avançado, 80% mais barato que o1-pro, pesquisa de dia zero, investigações críticas de segurança
`o1-pro`	✅	$150.00/$600.00/$0.00	Raciocínio premium de geração anterior, análise exaustiva de segurança, desafios críticos de missão

Variável	Padrão	Descrição
`ANTHROPIC_API_KEY`		Chave da API para serviços Anthropic
`ANTHROPIC_SERVER_URL`	`https://api.anthropic.com/v1`	Endpoint da API Anthropic

ID do Modelo	Pensamento	Contexto	Preço (Entrada/Saída/Cache)	Caso de Uso
`gemini-3.1-pro-preview`*	✅	1M	$2,00/$12,00/$0,20	Último carro-chefe com pensamento refinado, eficiência de token aprimorada, otimizado para engenharia de software e fluxos de trabalho agênticos
`gemini-3.1-pro-preview-customtools`	✅	1M	$2,00/$12,00/$0,20	Endpoint de ferramentas personalizadas otimizado para bash e priorização de ferramentas personalizadas (view_file, search_code)
`gemini-3.1-flash-lite`*	✅	1M	$0,25/$1,50/$0,025	Modelo multimodal estável mais econômico, desempenho de classe fronteiriça para tarefas agênticas de alto volume e aplicações de baixa latência

ID do Modelo	Pensamento	Contexto	Preço (Entrada/Saída/Cache)	Caso de Uso
`gemini-2.5-pro`	✅	1M	$1,25/$10,00/$0,125	Estado da arte para codificação e raciocínio complexos, modelagem de ameaças sofisticada
`gemini-2.5-flash`	✅	1M	$0,30/$2,50/$0,03	Primeiro modelo de raciocínio híbrido com orçamentos de pensamento, melhor relação custo-desempenho para avaliações em larga escala
`gemini-2.5-flash-lite`	✅	1M	$0,10/$0,40/$0,01	Menor e mais econômico para uso em escala, varredura de alto rendimento

ID do Modelo	Pensamento	Contexto	Preço (Entrada/Saída/Cache)	Caso de Uso
`gemma-4-31b-it`	✅	256K	Gratuito/Gratuito/Gratuito	Maior modelo denso open-source Gemma 4 (~31B parâmetros), multimodal texto+imagem, 140+ idiomas, operações de segurança on-premises
`gemma-4-26b-a4b-it`	✅	256K	Gratuito/Gratuito/Gratuito	Arquitetura MoE (~26B total / ~3.8B parâmetros ativos), inferência altamente eficiente em GPUs de consumo para varredura local de alto rendimento

Variável	Padrão	Descrição
`BEDROCK_REGION`	`us-east-1`	Região AWS para o serviço Bedrock
`BEDROCK_DEFAULT_AUTH`	`false`	Usar cadeia de credenciais padrão do AWS SDK (ambiente, função EC2, ~/.aws/credentials) - prioridade máxima
`BEDROCK_BEARER_TOKEN`		Autenticação via token Bearer - prioridade sobre credenciais estáticas
`BEDROCK_ACCESS_KEY_ID`		ID da chave de acesso AWS para credenciais estáticas
`BEDROCK_SECRET_ACCESS_KEY`		Chave de acesso secreta AWS para credenciais estáticas
`BEDROCK_SESSION_TOKEN`		Token de sessão AWS para credenciais temporárias (opcional, usado com credenciais estáticas)
`BEDROCK_SERVER_URL`		Endpoint Bedrock personalizado (endpoints VPC, testes locais)

Model ID	Pensamento	Saída Máxima	Contexto	Preço (Entrada/Saída/Cache)	Caso de Uso
`deepseek-v4-flash`*	✅ híbrido	384K	1M	$0.14/$0.28/$0.0028	Agentes utilitários, diálogo geral, chamada rápida de ferramentas
`deepseek-v4-pro`*	✅ híbrido	384K	1M	$1.74/$3.48/$0.0145	Raciocínio avançado, lógica complexa, análise de segurança

Função do Agente	Modelo Padrão	Pensamento	Esforço de Raciocínio	Saída Máxima	Temperatura	Top P
Gerador / Refinador	`deepseek-v4-pro`	Ativado	Alto	32768	(auto)	(auto)
Codificador	`deepseek-v4-pro`	Ativado	Alto	20480	(auto)	(auto)
Agente Principal / Assistente / Pentester	`deepseek-v4-pro`	Ativado	Alto	16384	(auto)	(auto)
Conselheiro (mentor/planejador)	`deepseek-v4-pro`	Ativado	Alto	8192	(auto)	(auto)
Instalador	`deepseek-v4-flash`	Ativado	Alto	12288	(auto)	(auto)
Refletor / Pesquisador / Enriquecedor	`deepseek-v4-flash`	Desativado	—	4096	0.5	0.9
Simples / JSON Simples	`deepseek-v4-flash`	Desativado	—	2048	0.3	0.9

Variável	Valor Padrão	Descrição
`GLM_API_KEY`		Chave da API GLM para autenticação
`GLM_SERVER_URL`	`https://api.z.ai/api/paas/v4`	URL do endpoint da API GLM (internacional)
`GLM_PROVIDER`		Prefixo do provedor para integração LiteLLM (opcional)

pentagi

Mais Populares

PentAGI

Índice

Visão Geral

Recursos

Limites Atuais de Capacidade

Arquitetura

Contexto do Sistema```mermaid

Opções de Configuração do Sumarizador Global

Opções de Configuração do Sumarizador de Assistente

Configuração de Ambiente do Sumarizador```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)

Cobertura Atual das Configurações Web

Ainda Gerenciado pelo Servidor

Instalação Manual

Configurações Principais de Segurança

Acesso ao Scraper

Credenciais de Acesso

Contas da Interface Web

Acessando o PentAGI a partir de Redes Externas

Passos de Configuração

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. Use modelos para fluxos de trabalho repetíveis

3. Monitore a execução e revise a saída

4. Use a visualização do Assistente para direcionar um fluxo ativo

5. Gerencie arquivos com escopo de fluxo

Acesso à API

Gerando Tokens de API

Usando Tokens de API

GraphQL API example

REST API example

Swagger UI

Gerando Clientes de API

Clientes GraphQL

Clientes da API REST

Exemplos de Uso da API

Usage

Create a new flow

List all flows

Melhores Práticas de Segurança

Gerenciamento de Tokens

Configuração Personalizada do Provedor de LLM

Configuração do Provedor Ollama

Variáveis de Configuração

Configuração do 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)

Configuração Local do Ollama

Basic local Ollama setup

Production setup with auto-pull and model discovery

Using pre-built configurations from Docker image

or

or

Modelos Suportados

Configuração do Provedor Anthropic

Variáveis de Configuração

Exemplos de Configuração```bash

Basic Anthropic setup

Using with proxy for secure environments

Modelos Suportados

Configuração do Provedor AWS Bedrock

Variáveis de Configuração

Exemplos de Configuração```bash

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

Bearer token authentication (AWS STS, custom auth)

Static credentials (development, testing)