Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
AMBER-ICI — AMBER ICI v5 : centre de commandement d'investigation Ollama local-first avec preuves limitées au dossier, chaînes d'agents, récupération hybride, analyse en streaming, vues graphique et chronologique, OCR, recherche web contrôlée et télémétrie GPU. | Kitploit
Outils/GitHubGitHub/gs-ai/amber-ici
OSINT (Renseignement de Sources Ouvertes)Scripting et AutomatisationAnalyse ForensiqueCollecte d'InformationsCriminalistique NumériqueProtection de la Vie PrivéeUtilitaires et FrameworksRenseignement sur les MenacesApprentissage AutomatiqueApprentissage et ÉducationSécurité de l'IA
19848il y a 2 moisPas encore vérifié
Partager
Labs et Pratique
GitHubgs-ai/amber-ici

AMBER-ICI

AMBER ICI v5 : centre de commandement d'investigation Ollama local-first avec preuves limitées au dossier, chaînes d'agents, récupération hybride, analyse en streaming, vues graphique et chronologique, OCR, recherche web contrôlée et télémétrie GPU.

Voir le dépôt
<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12061/b3526255ef1a43950d559d01043863d61c0ef36cfbf4e3270caef742cde07d9e.png" alt="Bannière de l'interface AMBER ICI" width="1200" />
</p>

# AMBER ICI v5

AMBER ICI (AMBER Investigative Command Interface) est une interface navigateur locale-first pour les workflows d'investigation et d'analyse, propulsée par un serveur [Ollama](https://ollama.com/) local.

Elle comprend :

- Une console Analyste mono-modèle et une exécution parallèle multi-modèles
- Une chaîne d'agents définie par l'utilisateur, déclenchée depuis le bouton `SEND` du terminal principal
- Un contrôle utilisateur sur les agents exécutés, leur nombre, le nombre de boucles et le modèle local utilisé par chacun
- La génération par modèle local de configurations d'agents à partir d'un objectif en langage naturel
- Une Archive sémantique persistante reposant sur les embeddings Ollama
- Une récupération fractale de Fibonacci pour le contexte des fichiers actifs
- Le téléversement de fichiers, l'accès en lecture seule à des répertoires liés, l'extraction de texte et l'OCR
- Une récupération web optionnelle via Playwright et une recherche dans les registres publics, derrière un unique interrupteur principal
- Des vues autonomes du graphe d'entités, de la chronologie et du magasin vectoriel
- Une télémétrie locale du débit de tokens, des sessions, du GPU/VRAM et de la température lorsque disponible

L'inférence Ollama est restreinte par l'interface aux points de terminaison de bouclage (`127.0.0.1`, `localhost` ou `::1`). AMBER n'inclut ni inférence cloud ni télémétrie applicative, et aucune fonctionnalité ne requiert de connexion, de clé API ou de compte. La pastille `WEB` est l'interrupteur principal de tout accès à Internet : lorsqu'elle est sur `OFF`, AMBER n'effectue aucune requête sortante, quelle qu'elle soit.

## Nouveautés de la v5

- Espaces de travail de cas locaux avec preuves et récupération Archive limitées au cas
- Identité d'artefact SHA-256 en streaming, provenance d'ingestion, détection des doublons et citations de sources
- Récupération déterministe par mots-clés fusionnée avec les résultats existants de l'Archive sémantique
- Mémoire explicite et bornée, limitée aux sessions, enquêteurs, cas, agents ou tâches de raisonnement
- Modèles de rôles d'investigation sélectionnés par l'opérateur, utilisant les modèles Ollama locaux installés
- Exécution d'agents depuis le terminal principal avec modèles, limites, formats, transferts et contrôles de boucle par agent
- Préflight WEB via Playwright, diagnostics d'exécution visibles, repli en récupération directe et mise en cache locale d'une heure
- Détection matérielle mise en cache avec rapports Metal, CUDA, ROCm, mémoire unifiée, utilisation et température
- Mises à jour de streaming coalescées pour une sortie longue et réactive
- Métadonnées persistées bornées, contenu d'interface généré échappé, dépendances Node reproductibles et exclusions étendues des environnements d'exécution sensibles

## Ensemble de fonctionnalités actuel

### Console Analyste

- Diffuse une conversation avec un modèle Ollama sélectionné
- Prend en charge un prompt système, le mode de sortie JSON, la graine, la température et la taille CTX
- Injecte le contexte du fichier actif, le contexte web optionnel et le contexte de conversation conservé
- Arrête le travail en cours avec `STOP` ou `Esc`

La barre de pastilles de la console regroupe les contrôles d'exécution :

| Pastille | Valeurs | Rôle |
|---|---|---|
| `TEMP` / `CTX` / `MEM` / `FMT` / `STREAM` / `SEED` / `SYS` | — | Paramètres d'inférence du mode Analyste |
| `WEB` | `OFF` (par défaut) / `ON` | Interrupteur principal de tout accès à Internet |
| `EXEC` | `ANALYST` (par défaut) / `AGENTS` | Ce que `SEND` exécute : le modèle actif unique, ou la chaîne d'agents |
| `AGN` | `0` = tous | Nombre d'agents exécutés par la chaîne, pris dans l'ordre des cartes |
| `LOOPS` | `1`+ | Nombre de répétitions de la chaîne ; synchronisé avec le champ `LOOPS` du panneau Agents |

### Parallèle

- Exécute le même prompt sur tous les modèles cochés
- Diffuse et suit chaque réponse indépendamment
- Applique les mêmes contrôles CTX et fichier actif que la console Analyste

### Agents — la chaîne d'exécution

Les agents sont définis par l'utilisateur et constituent le chemin d'exécution principal. Il n'existe aucune liste d'agents intégrée ou fixe ; le panneau Agents démarre vide et vous le remplissez de deux manières :

- `+ CREATE AGENT` — définir un agent manuellement
- `GENERATE FROM PROMPT` — décrire un objectif et un modèle planificateur local sélectionné rédige l'ensemble des agents pour vous

Chaque agent stocke sa propre configuration d'exécution :

| Champ | Valeur par défaut | Remarques |
|---|---|---|
| Nom de l'agent | — | Requis |
| Objectif de l'agent | — | Injecté en tant que `[AGENT PURPOSE]` |
| Prompt système de l'agent | — | L'instruction de rôle de l'agent |
| Modèle local préféré | — | Requis ; doit être installé dans Ollama |
| Température | `0.35` | Par agent, indépendante de la pastille `TEMP` de la console |
| Nombre maximal de tokens en sortie | `0` (auto) | `0` utilise l'heuristique de longueur d'AMBER |
| Boucles | `1` | Passages effectués par cet agent à chaque boucle de la chaîne, chacun affinant sa propre sortie précédente |
| Format de sortie | texte brut | `JSON` active le mode JSON d'Ollama et ignore l'expansion de longueur |
| Instructions de transfert | — | Transmises à l'agent séquentiel suivant en tant que `[HANDOFF FROM PREVIOUS AGENT]` |
| Mode d'exécution | `sequential` | `sequential`, `parallel` ou `gated` |
| Cible de sortie, portée mémoire, rôle, accès aux outils, activé, notes | — | Sous `ADVANCED` |

**Exécution de la chaîne.** Réglez `EXEC` sur `AGENTS`, saisissez un prompt dans le terminal principal et appuyez sur `SEND`. AMBER lit le mode sélectionné, les agents activés, le modèle local de chaque agent, le nombre `AGN` et le nombre `LOOPS`, puis exécute : les agents `parallel` simultanément, suivis des agents `sequential` dans l'ordre des cartes, une fois par boucle. Chaque agent séquentiel reçoit la sortie de l'agent précédent en tant que `[UPSTREAM OUTPUT]` ainsi que la note de transfert de cet agent. La progression et la sortie en flux de chaque agent s'affichent dans le terminal principal, et la réponse finale est conservée dans l'historique de conversation. Le bouton `RUN` du panneau Agents fait la même chose en utilisant le champ `LOOPS` propre au panneau.

En mode `AGENTS`, `SEND` ne nécessite pas de modèle actif dans le panneau Models, car chaque agent porte le sien. Les agents `gated` sont exclus de la chaîne — exécutez-les individuellement avec le bouton `RUN` de leur carte.

**Les modèles manquants ne sont jamais substitués.** Enregistrer un agent ou démarrer une chaîne avec un modèle qu'Ollama ne possède pas affiche dans le terminal un bloc actionnable indiquant le modèle demandé, les modèles réellement installés et la commande `ollama pull <model>` nécessaire, et l'exécution ne démarre pas.

Les ensembles d'agents enregistrés peuvent être stockés et restaurés par nom depuis le panneau Agents.

> L'ancien mode de séquence d'étapes `PIPELINE` / `CHAIN` a été retiré de l'interface. Son moteur et `state/pipeline_state.json` restent en place pour la compatibilité ascendante, mais il n'est plus un mode sélectionnable ; les agents constituent la chaîne d'exécution.

### Archive et mémoire

- Met en file d'attente les fichiers découpés en chunks et les embeddings avec `embeddinggemma:latest`
- Recherche dans l'archive locale par similarité cosinus
- Importe et exporte l'archive au format JSON
- Ajoute directement la sortie la plus récente de l'assistant à l'archive
- Construit un index fractal de Fibonacci dans le navigateur pour la récupération des sources de fichiers
- Propose les profils de récupération `FAST`, `HYBRID` et `DEEP`

### Renseignement de dossier

L'Archive inclut désormais une délimitation de dossier facultative sans remplacer son flux de travail existant sur l'ensemble de l'archive :

- `NEW CASE` crée des métadonnées de dossier locales.
- `ADD ACTIVE TO CASE` enregistre les fichiers sélectionnés comme preuves, conserve le téléversement brut existant, calcule une identité SHA-256 en flux et enregistre la provenance de l'ingestion.
- Les vecteurs d'archive indexés lorsqu'un dossier est sélectionné portent cet ID de dossier. Les recherches de dossier fusionnent ces résultats sémantiques avec un repli déterministe par mots-clés lorsque les deux sont disponibles.
- `REMEMBER LAST` enregistre explicitement la dernière sortie de l'assistant comme mémoire de dossier étiquetée. La sortie du modèle n'est jamais promue silencieusement en preuve ou en mémoire.
- `ADD INVESTIGATION ROLES` ajoute des modèles facultatifs Director, Researcher, Investigator, Analyst, Documenter et Critic au registre d'agents existant défini par l'utilisateur. Ils utilisent le modèle local sélectionné par l'opérateur et ne s'exécutent pas automatiquement.

Le renseignement de dossier est stocké de manière atomique dans un unique magasin JSON versionné de la bibliothèque standard et utilise le client Ollama existant d'AMBER.

### Vues autonomes

L'en-tête ouvre ces outils dans des onglets séparés :

- Graphe de provenance des entités : `http://127.0.0.1:8765/amber_graph.html`
- Chronologie : `http://127.0.0.1:8765/amber_timeline.html`
- Gestionnaire de magasin vectoriel : `http://127.0.0.1:8765/amber_vectorstore.html`

## Prérequis

Runtime principal :

- Python 3.10 ou plus récent ; le lanceur et le backend principal n'utilisent que la bibliothèque standard, donc aucun `pip install` n'est nécessaire pour exécuter AMBER
- Ollama installé et en cours d'exécution localement
- Au moins un modèle de génération Ollama
- `embeddinggemma:latest` pour l'indexation d'Archive et la recherche sémantique

Fonctionnalités optionnelles :

- Node.js 18+ et npm, ainsi que les dépendances du projet, pour les récupérations web rendues en JavaScript et la recherche d'enregistrements
- Un navigateur Chromium Playwright pour ces fonctionnalités basées sur navigateur
- `ocrmypdf` et Tesseract pour l'OCR des PDF
- Tesseract pour l'OCR des images
- Pillow pour convertir les images WebP avant l'OCR lorsque Tesseract ne peut pas les lire directement
- `psutil`, `nvidia-smi` ou `osx-cpu-temp` pour des métriques système supplémentaires ; les relevés indisponibles restent simplement vides

Tout ce qui précède est local. Aucun composant ne nécessite de compte, de clé API ou de service cloud.

## Installation et exécution

### 1. Cloner le dépôt

```bash
git clone https://github.com/gs-ai/AMBER-ICI.git
cd AMBER-ICI
```

### 2. Démarrer Ollama

Dans un terminal séparé :

```bash
ollama serve
```

Téléchargez le modèle d'embedding requis et au moins un modèle de génération :

```bash
ollama pull embeddinggemma:latest
ollama pull qwen2.5-coder:7b
```

Le modèle de génération n'est qu'un exemple ; AMBER découvre les modèles installés localement depuis Ollama.

### 3. Créer l'environnement Python

Le backend principal n'importe que la bibliothèque standard Python, donc un environnement virtuel est facultatif pour un lancement direct. Créez-en un quand même si vous souhaitez utiliser les scripts npm (qui appellent `venv/bin/python3`) ou le support optionnel de Pillow :

```bash
python3 -m venv venv
source venv/bin/activate          # Windows: venv\Scripts\activate
python3 -m pip install --upgrade pip
```

Il n'y a pas de `requirements.txt` car rien n'est requis. Installez les extras optionnels dans cet environnement uniquement si vous le souhaitez :

```bash
python3 -m pip install Pillow     # optional: WebP conversion before OCR
```

Désactivez avec `deactivate`. Si une version précédente d'AMBER a laissé des paquets inutilisés dans `venv/` (par exemple `camoufox`), ils ne sont pas importés par le code actuel et peuvent être ignorés ou supprimés.

### 4. Lancer l'application principale

```bash
python3 files/launch_amber_ici_gui.py
```

AMBER ouvre automatiquement le navigateur. Pour lancer sans ouvrir d'onglet :

```bash
python3 files/launch_amber_ici_gui.py --no-browser
```

Ouvrez ensuite `http://127.0.0.1:8765/amber_ui.html`.

### 5. Installer les fonctionnalités web optionnelles basées sur le navigateur

Nécessaire uniquement si vous avez l'intention d'activer la pastille `WEB` :

```bash
npm install                       # playwright, playwright-extra, stealth plugin
npx playwright install chromium   # the browser binary itself
```

Vérifiez que les helpers sont exécutables — avec AMBER en cours d'exécution, cela affiche les chemins des helpers, le binaire `node` résolu et tout paquet manquant :

```bash
curl -s http://127.0.0.1:8765/api/web/status
```

AMBER utilise l'assistant Node/Chromium pour les pages rendues en JavaScript, avec une récupération HTTP simple en Python comme solution de repli pour les URL directes. L'assistant de recherche d'enregistrements nécessite Node.js, les dépendances npm et Chromium ; il n'a pas de solution de repli en HTTP simple.

### 6. Installer la prise en charge OCR facultative

macOS avec Homebrew :

```bash
brew install ocrmypdf tesseract
python3 -m pip install Pillow
```

Ubuntu/Debian :

```bash
sudo apt-get update
sudo apt-get install -y ocrmypdf tesseract-ocr
python3 -m pip install Pillow
```

Pillow n'est nécessaire que pour les formats d'image qui requièrent une conversion avant que Tesseract puisse les traiter. AMBER continue de fonctionner lorsque l'une des dépendances OCR optionnelles est absente.

### scripts de commodité npm

Les scripts npm fournis lancent AMBER avec `venv/bin/python3`, il faut donc d'abord créer cet environnement (étape 3) :

```bash
npm start                 # 127.0.0.1:8765, no browser tab
npm run start:browser     # same, and opens the browser
```

Le lancement direct avec `python3` est l'option la plus portable.

### Configuration complète, du début à la fin

```bash
git clone https://github.com/gs-ai/AMBER-ICI.git
cd AMBER-ICI
python3 -m venv venv                       # for the npm scripts
npm install                                # optional: WEB features
npx playwright install chromium            # optional: WEB features
ollama serve &                             # in its own terminal
ollama pull embeddinggemma:latest          # required for Archive
ollama pull qwen2.5-coder:7b               # any generation model
npm start                                  # → http://127.0.0.1:8765/amber_ui.html
```

## Options du lanceur

```bash
python3 files/launch_amber_ici_gui.py --help
```

| Option | Valeur par défaut | Objectif |
|---|---:|---|
| `--host HOST` | `127.0.0.1` | Adresse sur laquelle le serveur HTTP AMBER écoute |
| `--port PORT` | `8765` | Port du serveur HTTP AMBER |
| `--no-browser` | désactivé | Ne pas ouvrir le navigateur par défaut |
| `--gui PATH` | détection automatique | Servir un fichier HTML GUI spécifique |
| `--version` | — | Afficher la version de la release AMBER ICI et quitter |

L'interface navigateur accepte intentionnellement uniquement les URL Ollama en boucle locale, même si le serveur AMBER est lié à une autre interface.

## Workflow de premier lancement

1. Confirmez que le point de terminaison Ollama en haut à droite est `http://127.0.0.1:11434`.
2. Cliquez sur `PING` pour charger les modèles installés localement.
3. Sélectionnez un modèle dans le panneau Models.
4. Saisissez une invite dans la console Analyst et cliquez sur `SEND`.
5. Vous pouvez éventuellement téléverser des fichiers ou lier un répertoire, puis activer des fichiers pour les inclure dans le contexte.
6. Récupérez `embeddinggemma:latest` avant d'indexer des fichiers dans Archive.

Pour exécuter la chaîne d'agents à la place :

1. Ouvrez l'onglet `AGENTS` dans le panneau de gauche.
2. Créez un agent avec `+ CREATE AGENT`, ou décrivez un objectif sous `GENERATE FROM PROMPT`.
3. Définissez `EXEC` sur `AGENTS` dans la barre de pilules de la console.
4. Définissez `AGN` (nombre d'agents ; `0` = tous) et `LOOPS` (nombre de passes).
5. Saisissez l'invite dans le terminal principal et appuyez sur `SEND`.

Pour permettre à AMBER de lire Internet, réglez d'abord la pilule `WEB` sur `ON` ; elle est sur `OFF` par défaut.

## Ingestion de fichiers

Les téléversements sont limités à 100 MiB par fichier. Le sélecteur de fichiers et le chemin par glisser-déposer acceptent actuellement :

- Documents : `.txt`, `.md`, `.pdf`, `.docx`, `.rtf`
- Données/configuration : `.csv`, `.xlsx`, `.json`, `.yaml`, `.yml`, `.toml`, `.ini`, `.cfg`, `.conf`, `.xml`
- Source/journaux : `.py`, `.js`, `.ts`, `.tsx`, `.jsx`, `.html`, `.sql`, `.sh`, `.bash`, `.zsh`, `.log`
- Images : `.png`, `.jpg`, `.jpeg`, `.bmp`, `.webp`, `.tif`, `.tiff`, `.svg`

Comportement d'extraction :

- Les fichiers en texte brut, source, configuration, CSV et RTF sont décodés comme du texte.
- Les feuilles de calcul XLSX sont extraites avec la bibliothèque standard Python ; les formules et le formatage complexe ne sont pas préservés.
- Le texte DOCX est extrait du XML du document ; la mise en page complexe n'est pas préservée.
- L'extraction PDF tente d'abord le texte intégré et tente également l'OCR lorsque `ocrmypdf` est installé, en conservant le résultat le plus utile.
- Les images raster utilisent Tesseract OCR lorsqu'il est installé. L'extraction SVG lit le contenu intégré des balises `<text>` et `<tspan>`.

Les octets bruts téléversés sont stockés dans `uploads/blobs/`, le texte extrait dans `uploads/texts/`, et les métadonnées dans `uploads/manifest.json`.

### Répertoires liés

`LINK DIRECTORY` expose à AMBER les fichiers pris en charge et non masqués d'un répertoire local. Le panneau Files traite les entrées liées comme en lecture seule, et le listage du répertoire n'est pas récursif. Le chemin sélectionné est stocké dans `state/linked_dir_state.json` ; le contenu des fichiers reste à son emplacement d'origine et n'est lu que lorsqu'il est demandé pour le contexte ou l'extraction.

Le sélecteur de dossier natif utilise Tkinter de Python. S'il n'est pas disponible, l'interface demande un chemin manuellement. Dissocier le répertoire supprime le lien enregistré mais ne supprime pas les fichiers source.

Le backend reconnaît quelques formats de fichiers liés supplémentaires (`.xls`, `.ods`, `.gif`, `.heic`, `.ico`, `.ppt`, `.pptx` et `.zip`). Les formats sans extracteur de texte contribuent une étiquette de métadonnées plutôt qu'un contenu décodé. L'extraction des anciens formats `.xls` et `.ods` est effectuée au mieux et peut signaler que l'extraction n'est pas disponible.

## Comportement du contexte et de la mémoire

Les options CTX dans l'interface sont `2K`, `4K`, `8K`, `16K` et `32K` et s'appliquent aux appels Analyst, Parallel et Agent.

- Avant l'inférence, `trimMsgsToCtx()` supprime les messages non-système les plus anciens jusqu'à ce que la requête tienne dans environ 90 % du budget de contexte sélectionné, estimé à quatre caractères par token.
- La récupération des fichiers actifs interroge d'abord le stockage fractal de Fibonacci, lorsqu'il est peuplé, et se rabat sur l'assemblage plat du contexte de fichiers.
- La récupération utilise une profondeur allant jusqu'à 4, une largeur de faisceau de 2 à 4 et des limites de résultats dépendant du profil.
- Le contexte des fichiers actifs est plafonné selon le profil de mémoire : environ `CTX × 2.6` caractères en Fast, `CTX × 3.2` en Hybrid et `CTX × 4.0` en Deep.
- Le contexte plat surdimensionné est classé par score de chevauchement de mots-clés avant injection.
- L'injection du scratchpad conserve une queue d'environ 8 000 à 20 000 caractères et est en outre bornée par le budget de contexte de fichiers du profil actif.
- Les agents disposant de la mémoire complète reçoivent les six derniers messages de la conversation. La mémoire locale utilise une queue de scratchpad ; `none` désactive ce rappel.

Ce sont des garde-fous basés sur les caractères, et non des décomptes exacts du tokenizer.

L'Archive vectorielle est durable, mais l'arbre de Fibonacci séparé constitue la mémoire de session. Il est construit pour un fichier lorsque celui-ci est indexé durant la session de page en cours et n'est pas automatiquement reconstruit à partir de `state/vector_store.json` après un rechargement ; jusqu'à sa reconstruction, le contexte des fichiers actifs utilise le repli plat.

## Persistance

Le lanceur stocke les données applicatives durables au format JSON sous `state/` en utilisant un remplacement atomique par fichier temporaire. Il n'existe aucune migration SQLite active ni dépendance à une base de données.

| Chemin | Contenu |
|---|---|
| `state/agents_state.json` | Agents actuels, y compris le modèle, la température, la limite de tokens, les boucles, le format et le transfert de chaque agent |
| `state/agent_sets.json` | Préréglages d'agents enregistrés |
| `state/agent_run_log.json` | Les 100 dernières exécutions d'agents : agent, modèle, durée, succès et contexte |
| `state/pipeline_state.json` | Étapes de pipeline retirées, conservées pour la compatibilité ascendante |
| `state/chain_sets.json` | Préréglages de chaînes enregistrés |
| `state/step_run_log.json`, `state/tool_call_log.json`, `state/tool_registry_state.json` | Enregistrements d'étapes, d'appels d'outils et de registre d'outils |
| `state/chat_history.json` | Les 100 derniers messages de la conversation ; l'interface rejoue les 30 plus récents |
| `state/scratch.json` | Les 20 000 derniers caractères du scratchpad |
| `state/memory_profile.json` | Sélection de récupération Fast, Hybrid ou Deep |
| `state/vector_store.json` | Chunks et embeddings de l'Archive |
| `state/case_intelligence.json` | Métadonnées de cas, contrats de preuve et provenance, mémoire explicite bornée et reçus de trace d'agent ; créé à la première écriture |
| `state/graph_state.json`, `state/timeline_state.json` | Données de graphe et de chronologie |
| `state/web_cache.json` | Résultats de récupération web directe avec un TTL d'une heure |
| `state/linked_dir_state.json` | Chemin du répertoire lié actuel |
| `uploads/manifest.json` | Métadonnées des fichiers téléversés |

La disposition des panneaux est stockée dans le `localStorage` du navigateur, elle est donc propre au profil du navigateur. Les sélections, statistiques et l'arbre fractal en mémoire, propres à l'exécution, sont réinitialisés au chargement de la page.

Si un fichier JSON d'état ne peut pas être décodé, le lanceur le met en quarantaine avec le suffixe `.corrupt-<timestamp>.json` et renvoie une valeur vide afin que le panneau concerné puisse se rétablir.

## Accès Web et frontières réseau

La pastille `WEB` est l'interrupteur principal, et elle est réglée par défaut sur `OFF`.

**Lorsque `WEB` est désactivé, AMBER n'effectue aucune requête sortante, quelle qu'elle soit.** Le verrou est appliqué au sein même des fonctions de récupération, de sorte que la formulation du prompt, le contexte de fichiers injecté et les appels d'outils des agents (`web_fetch`, `online_records_search`) sont tous bloqués de la même manière. Si un prompt demande une récupération alors que l'interrupteur est désactivé, le terminal l'indique et la requête n'est pas envoyée plutôt que d'échouer silencieusement.

Lorsque `WEB` est activé, AMBER vérifie d'abord l'environnement de l'helper, affiche le chemin de l'helper qu'il utilisera, puis résout la requête dans cet ordre :

1. Une instruction explicite du site telle que « rechercher X sur foxnews.com » — récupère ce site, en utilisant une URL de recherche connue lorsque le sujet est précis.
2. Une demande formulée spécifiquement « recherche de dossiers pour/sur [personne] dans [lieu] » — invoque l'assistant de recherche de dossiers.
3. Une URL explicite `http://`/`https://` ou un domaine nu reconnu dans le prompt ou dans le contexte de fichier injecté.
4. Sinon, le texte du prompt est soumis au point de terminaison HTML de DuckDuckGo et la page de résultats est récupérée.

L'étape 4 signifie qu'avec `WEB` activé, le texte du prompt peut atteindre un moteur de recherche général. Désactivez `WEB` pour les prompts dont le texte ne doit pas quitter la machine.

Chaque résultat est rapporté dans le terminal principal : le mode sélectionné, le chemin d'assistance utilisé, la requête envoyée, le moteur qui l'a servie (`playwright`, `urllib` ou `cache`), la taille du contenu et l'endroit où il a été injecté, ou un bloc d'échec nommant la dépendance manquante et la commande qui la corrige. Les récupérations directes sont mises en cache pendant une heure dans `state/web_cache.json`.

La recherche de dossiers interroge ces sources et ne renvoie que les correspondances dont le texte de la page corrobore à la fois le sujet et le lieu demandé : `casesearch.kscourts.gov`, `doc.ks.gov/offender-search`, `kbi.ks.gov/registeredoffender`, DuckDuckGo et Brave Search.

Le comportement réseau est le suivant :

- La découverte de modèles, l'inférence, les embeddings et l'état des modèles se connectent uniquement à un point de terminaison Ollama en boucle locale.
- Le backend AMBER sert les fichiers locaux et les routes API depuis l'hôte/port AMBER configuré.
- Avec `WEB` activé, la récupération web Playwright, son repli HTTP Python et la recherche de dossiers effectuent des requêtes sortantes vers des sites choisis par l'utilisateur, des fournisseurs de recherche et des sites de registres publics. Avec `WEB` désactivé, aucun de ceux-ci ne s'exécute.
- `GET /api/web/status` est un précontrôle local uniquement ; il inspecte le système de fichiers et le `PATH` et n'effectue aucune requête réseau.
- Il n'existe aucun point de terminaison de télémétrie AMBER, et aucune fonctionnalité ne transmet d'identifiants, de clés ou de données d'utilisation.

Les pages récupérées sont injectées dans le prompt sous la forme `[WEB CONTEXT]` et font donc partie de l'historique de conversation conservé dans `state/chat_history.json` ; les agents dont la cible de sortie est le scratchpad ajoutent également à `state/scratch.json`. Le contenu web en direct atterrit dans l'état local du dossier.

Le lanceur envoie une Content Security Policy restrictive, désactive le framing, définit `no-referrer`, bloque les permissions sensibles du navigateur et désactive la mise en cache HTTP. Le contrat `/api/task/execute` du backend peut lister, lire, écrire, ajouter ou créer des fichiers dans la racine liée lorsqu'il est explicitement appelé. Il rejette les chemins qui s'échappent de cette racine, les chemins cachés, les outils inconnus et les écrasements qui n'ont pas été explicitement autorisés. Ne liez qu'un répertoire dont le contenu visible peut être consulté et modifié par l'application locale.

## Panneau de télémétrie

Les compteurs de session se mettent à jour pendant l'exécution Analyst, Parallel et Agent et incluent les tours, les tokens de prompt/sortie, le débit de tokens maximal, le débit de tokens moyen et une sparkline de débit de tokens en direct.

La résidence VRAM/modèle provient du point de terminaison local `/api/ps` d'Ollama. Les relevés de température/utilisation sont fournis au mieux : NVIDIA utilise `nvidia-smi`, Apple Silicon tente des lectures SMC directes, Linux vérifie les zones thermiques, et des outils optionnels fournissent des solutions de repli.

## Nettoyage des données

Arrêtez AMBER avant le nettoyage.

Réinitialisez l'état conservé tout en préservant les fichiers téléversés :

```bash
rm -f state/*.json
```

Supprimer les blobs téléversés, le texte extrait et leur manifeste :

```bash
rm -rf uploads/blobs uploads/texts uploads/manifest.json
```

Les fichiers sources liés ne sont jamais supprimés par ces commandes. Les répertoires d'état et de téléversement sont recréés selon les besoins.

## Dépannage

### PING échoue ou aucun modèle n'apparaît

- Vérifiez que `ollama serve` est en cours d'exécution.
- Vérifiez que le point de terminaison de l'interface est `http://127.0.0.1:11434`.
- Exécutez `ollama list` pour vérifier qu'au moins un modèle de génération est installé.

### L'indexation des archives échoue

- Exécutez `ollama pull embeddinggemma:latest`.
- Vérifiez qu'Ollama est joignable au point de terminaison affiché dans l'interface.
- Consultez le journal d'événements AMBER pour identifier le point de terminaison d'embedding ou le bloc d'entrée en échec.

### La récupération web via navigateur ou la recherche d'enregistrements échoue

Le terminal indique le problème exact. Vérifiez l'environnement directement avec AMBER en cours d'exécution :

```bash
curl -s http://127.0.0.1:8765/api/web/status
```

Installez ensuite ce qu'il signale comme manquant :

```bash
npm install
npx playwright install chromium
```

La récupération web directe peut encore réussir via son mécanisme de repli en HTTP simple. La recherche d'enregistrements nécessite Playwright et peut échouer lorsqu'une source modifie son balisage, exige une authentification/CAPTCHA, bloque l'automatisation ou est indisponible.

### Rien n'est récupéré et le terminal affiche `WEB IS OFF`

La pastille `WEB` est sur `OFF`, ce qui bloque par conception toute requête sortante. Passez-la sur `ON`.

### Un agent refuse de s'exécuter : `LOCAL MODEL NOT AVAILABLE`

Le modèle sélectionné pour l'agent n'est pas installé dans Ollama. Le terminal affiche le modèle demandé, les modèles dont vous disposez et la solution :

```bash
ollama pull <model-name>
ollama list
```

AMBER ne substitue jamais silencieusement un autre modèle.

### `SEND` est grisé

En mode `ANALYST`, sélectionnez exactement un modèle dans le panneau Models. En mode `AGENTS`, créez au moins un agent — aucun modèle actif n'est nécessaire dans ce mode.

### Le texte d'un PDF ou d'une image est manquant

- Installez `ocrmypdf` et Tesseract.
- Installez Pillow pour la conversion WebP si nécessaire.
- Téléversez à nouveau le fichier afin que l'extraction soit relancée.
- Inspectez le fichier correspondant sous `uploads/texts/`.

### `npm start` ne trouve pas Python

Les scripts npm attendent `venv/bin/python3`. Exécutez `python3 -m venv venv`, ou lancez directement avec `python3 files/launch_amber_ici_gui.py`.

### Le port 8765 est déjà utilisé

```bash
python3 files/launch_amber_ici_gui.py --port 8877
```

## Structure du projet

```text
AMBER-ICI/
├── files/
│   ├── amber_graph.html
│   ├── amber_timeline.html
│   ├── amber_ui.html
│   ├── amber_vectorstore.html
│   ├── amber_intelligence/       # Standard-library case/evidence/memory service
│   ├── autogen_builder.py
│   ├── constrained_executor.py
│   ├── launch_amber_ici_gui.py
│   ├── records_search_playwright.mjs
│   └── web_fetch_playwright.mjs
├── image/README/
├── state/                  # created/populated at runtime
├── uploads/                # created/populated at runtime
├── tests/                  # Case-intelligence and ICI regression tests
├── package.json
├── spec.json
├── spec.schema.json
├── README.md
└── LICENSE
```

## Licence

MIT. Voir [LICENSE](https://github.com/gs-ai/amber-ici/blob/main/LICENSE).
Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    1.1k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    594
  • 3

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    387
  • 4

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    322
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    308
  • 6

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    275

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →