Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
Herramientas/GitHubGitHub/gs-ai/amber-ici
OSINT (Inteligencia de Fuentes Abiertas)Scripting y AutomatizaciónAnálisis ForenseRecopilación de InformaciónForensia DigitalPrivacidadUtilidades y FrameworksInteligencia de AmenazasAprendizaje AutomáticoAprendizaje y EducaciónSeguridad de IALabs y Práctica
19848hace 2 mesesAún no revisado
Compartir
GitHubgs-ai/amber-ici

AMBER-ICI

AMBER ICI v5: centro de mando de investigación Ollama con enfoque local-first, con evidencia delimitada por caso, cadenas de agentes, recuperación híbrida, análisis en streaming, vistas de grafo y línea de tiempo, OCR, investigación web controlada y telemetría de GPU.

Ver Repositorio
<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12061/b3526255ef1a43950d559d01043863d61c0ef36cfbf4e3270caef742cde07d9e.png" alt="AMBER ICI interface banner" width="1200" />
</p>

# AMBER ICI v5

AMBER ICI (AMBER Investigative Command Interface) es una interfaz de navegador local-first para flujos de trabajo de investigación y análisis impulsada por un servidor local de [Ollama](https://ollama.com/).

Incluye:

- Una Analyst Console de un solo modelo y ejecución en paralelo multimodelo
- Una cadena de agentes definida por el usuario, impulsada desde el botón `SEND` del terminal principal
- Control del usuario sobre qué agentes se ejecutan, cuántos, cuántos bucles y qué modelo local usa cada uno
- Generación mediante modelo local de configuraciones de agentes a partir de un objetivo en lenguaje natural
- Un Archive semántico persistente respaldado por embeddings de Ollama
- Recuperación fractal de Fibonacci para el contexto de archivos activos
- Cargas de archivos, acceso de solo lectura a directorios vinculados, extracción de texto y OCR
- Obtención web opcional respaldada por Playwright y búsqueda en registros públicos, tras un único interruptor maestro
- Vistas independientes de grafo de entidades, línea de tiempo y almacén vectorial
- Telemetría local de tasa de tokens, sesión, GPU/VRAM y temperatura cuando esté disponible

La inferencia de Ollama está restringida por la interfaz a endpoints de loopback (`127.0.0.1`, `localhost` o `::1`). AMBER no incluye inferencia en la nube ni telemetría de la aplicación, y ninguna función requiere inicio de sesión, clave de API ni cuenta. La píldora `WEB` es el interruptor maestro para todo el acceso a internet: con ella en `OFF`, AMBER no realiza ninguna solicitud saliente de ningún tipo.

## Novedades de v5

- Espacios de trabajo de casos locales con evidencia acotada al caso y recuperación desde el Archive
- Identidad de artefactos mediante SHA-256 en streaming, procedencia de la ingesta, detección de duplicados y citas de fuentes
- Recuperación determinista por palabras clave fusionada con los resultados existentes del Archive semántico
- Memoria explícita y acotada, delimitada a sesiones, investigadores, casos, agentes o tareas de razonamiento
- Plantillas de rol de investigación seleccionadas por el operador usando los modelos locales de Ollama instalados
- Ejecución de agentes desde el terminal principal con modelos por agente, límites, formatos, traspasos y controles de bucle
- Preflight WEB de Playwright, diagnósticos de ejecución visibles, fallback de obtención directa y caché local de una hora
- Detección de hardware en caché con informes de Metal, CUDA, ROCm, memoria unificada, utilización y temperatura
- Actualizaciones de streaming fusionadas para una salida extensa con capacidad de respuesta
- Metadatos persistidos acotados, contenido de interfaz generado escapado, dependencias de Node reproducibles y exclusiones ampliadas de runtime sensible

## Conjunto de funciones actual

### Analyst Console

- Transmite en streaming una conversación con un modelo de Ollama seleccionado
- Admite un prompt de sistema, modo de salida JSON, seed, temperatura y tamaño de CTX
- Inyecta el archivo activo, contexto web opcional y el contexto de conversación retenido
- Detiene el trabajo activo con `STOP` o `Esc`

La barra de píldoras de la consola contiene los controles de ejecución:

| Píldora | Valores | Propósito |
|---|---|---|
| `TEMP` / `CTX` / `MEM` / `FMT` / `STREAM` / `SEED` / `SYS` | — | Ajustes de inferencia del modo Analyst |
| `WEB` | `OFF` (predeterminado) / `ON` | Interruptor maestro para todo el acceso a internet |
| `EXEC` | `ANALYST` (predeterminado) / `AGENTS` | Qué ejecuta `SEND`: el modelo activo único o la cadena de agentes |
| `AGN` | `0` = todos | Cuántos agentes ejecuta la cadena, tomados en el orden de las tarjetas |
| `LOOPS` | `1`+ | Cuántas veces se repite la cadena; sincronizado con el campo `LOOPS` del panel Agents |

### Parallel

- Ejecuta el mismo prompt contra todos los modelos marcados
- Transmite y rastrea cada respuesta de forma independiente
- Aplica los mismos controles de CTX y archivo activo que usa la Analyst Console

### Agents — la cadena de ejecución

Los agentes son definidos por el usuario y constituyen la ruta de ejecución principal. No existe una lista de agentes integrada ni fija; el panel Agents comienza vacío y se rellena de dos maneras:

- `+ CREATE AGENT` — define uno manualmente
- `GENERATE FROM PROMPT` — describe un objetivo y un modelo planificador local seleccionado escribe el conjunto de agentes por ti

Cada agente almacena su propia configuración de runtime:

| Campo | Predeterminado | Notas |
|---|---|---|
| Nombre del agente | — | Obligatorio |
| Propósito del agente | — | Se inyecta como `[AGENT PURPOSE]` |
| Prompt de sistema del agente | — | La instrucción de rol del agente |
| Modelo local preferido | — | Obligatorio; debe estar instalado en Ollama |
| Temperatura | `0.35` | Por agente, independiente de la píldora `TEMP` de la consola |
| Tokens máximos de salida | `0` (auto) | `0` usa la heurística de longitud de AMBER |
| Bucles | `1` | Pasadas que realiza este agente por cada bucle de la cadena, cada una refinando su propia salida anterior |
| Formato de salida | texto plano | `JSON` activa el modo JSON de Ollama y omite la expansión de longitud |
| Instrucciones de traspaso | — | Se pasan al siguiente agente secuencial como `[HANDOFF FROM PREVIOUS AGENT]` |
| Modo de ejecución | `sequential` | `sequential`, `parallel` o `gated` |
| Destino de salida, ámbito de memoria, rol, acceso a herramientas, habilitado, notas | — | Bajo `ADVANCED` |

**Ejecutar la cadena.** Establece `EXEC` en `AGENTS`, escribe un prompt en la terminal principal y pulsa `SEND`. AMBER lee el modo seleccionado, los agentes habilitados, el modelo local de cada agente, el recuento de `AGN` y el recuento de `LOOPS`, y luego ejecuta: los agentes `parallel` de forma concurrente, seguidos de los agentes `sequential` en el orden de las tarjetas, una vez por bucle. Cada agente secuencial recibe la salida del agente anterior como `[UPSTREAM OUTPUT]` más la nota de traspaso de ese agente. El progreso y la salida en streaming de cada agente se imprimen en la terminal principal, y la respuesta final se conserva en el historial de conversación. El botón `RUN` del panel de Agentes hace lo mismo usando el campo `LOOPS` propio del panel.

En el modo `AGENTS`, `SEND` no requiere un modelo activo en el panel de Modelos, porque cada agente lleva el suyo propio. Los agentes `gated` quedan excluidos de la cadena: ejecútalos individualmente con el botón `RUN` de su tarjeta.

**Los modelos ausentes nunca se sustituyen.** Guardar un agente o iniciar una cadena con un modelo que Ollama no tiene imprime un bloque accionable en la terminal indicando el modelo solicitado, los modelos realmente instalados y el comando `ollama pull <model>` necesario, y la ejecución no se inicia.

Los conjuntos de agentes guardados se pueden almacenar y restaurar por nombre desde el panel de Agentes.

> El antiguo modo de secuencia de pasos `PIPELINE` / `CHAIN` se retiró de la interfaz. Su motor y `state/pipeline_state.json` permanecen en su sitio por compatibilidad con versiones anteriores, pero ya no es un modo seleccionable; los agentes son la cadena de ejecución.

### Archivo y Memoria

- Fragmenta y genera embeddings de archivos en cola con `embeddinggemma:latest`
- Busca en el archivo local por similitud de coseno
- Importa y exporta JSON del archivo
- Añade la salida más reciente del asistente directamente al archivo
- Construye un índice fractal de Fibonacci en el navegador para la recuperación de fuentes de archivos
- Ofrece los perfiles de recuperación `FAST`, `HYBRID` y `DEEP`

### Inteligencia de Casos

El Archivo ahora incluye un límite de caso opcional sin reemplazar su flujo de trabajo existente de archivo completo:

- `NEW CASE` crea metadatos de caso locales.
- `ADD ACTIVE TO CASE` registra los archivos seleccionados como evidencia, conserva la carga sin procesar existente, calcula una identidad SHA-256 en streaming y registra la procedencia de la ingesta.
- Los vectores del archivo indexados mientras hay un caso seleccionado llevan ese ID de caso. Las búsquedas de casos fusionan esos resultados semánticos con un respaldo determinista por palabras clave cuando ambos están disponibles.
- `REMEMBER LAST` guarda explícitamente la salida más reciente del asistente como memoria de caso etiquetada. La salida del modelo nunca se promueve silenciosamente a evidencia o memoria.
- `ADD INVESTIGATION ROLES` añade plantillas opcionales de Director, Researcher, Investigator, Analyst, Documenter y Critic al registro de agentes definido por el usuario existente. Usan el modelo local seleccionado por el operador y no se ejecutan automáticamente.

La inteligencia de casos se almacena de forma atómica en un único almacén JSON versionado de la biblioteca estándar y utiliza el cliente Ollama existente de AMBER.

### Vistas Independientes

El encabezado abre estas herramientas en pestañas separadas:

- Entity Provenance Graph: `http://127.0.0.1:8765/amber_graph.html`
- Timeline: `http://127.0.0.1:8765/amber_timeline.html`
- Vector Store manager: `http://127.0.0.1:8765/amber_vectorstore.html`

## Requisitos

Entorno de ejecución principal:

- Python 3.10 o superior; el lanzador y el backend principal usan solo la biblioteca estándar, por lo que no se requiere `pip install` para ejecutar AMBER
- Ollama instalado y en ejecución localmente
- Al menos un modelo de generación de Ollama
- `embeddinggemma:latest` para la indexación de Archive y la búsqueda semántica

Capacidades opcionales:

- Node.js 18+ y npm, además de las dependencias del proyecto, para obtenciones web renderizadas con JavaScript y búsqueda de registros
- Un navegador Chromium de Playwright para esas funciones respaldadas por navegador
- `ocrmypdf` y Tesseract para OCR de PDF
- Tesseract para OCR de imágenes
- Pillow para convertir imágenes WebP antes del OCR cuando Tesseract no puede leerlas directamente
- `psutil`, `nvidia-smi` u `osx-cpu-temp` para métricas adicionales del sistema; las lecturas no disponibles simplemente permanecen en blanco

Todo lo anterior es local. Ningún componente requiere una cuenta, una clave de API ni un servicio en la nube.

## Instalación y ejecución

### 1. Clonar el repositorio

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

### 2. Iniciar Ollama

En una terminal separada:

```bash
ollama serve
```

Descargue el modelo de embeddings requerido y al menos un modelo de generación:

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

El modelo de generación es solo un ejemplo; AMBER descubre los modelos instalados localmente desde Ollama.

### 3. Crear el entorno de Python

El backend principal solo importa la biblioteca estándar de Python, por lo que un entorno virtual es opcional para un lanzamiento directo. Créalo de todos modos si deseas los scripts de npm (que llaman a `venv/bin/python3`) o el soporte opcional de Pillow:

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

No hay `requirements.txt` porque no se requiere nada. Instala los extras opcionales en ese entorno solo si los deseas:

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

Desactívelo con `deactivate`. Si una versión anterior de AMBER dejó paquetes sin usar en `venv/` (por ejemplo, `camoufox`), el código actual no los importa y se pueden ignorar o eliminar.

### 4. Iniciar la aplicación principal

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

AMBER abre el navegador automáticamente. Para iniciarlo sin abrir una pestaña:

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

Luego abra `http://127.0.0.1:8765/amber_ui.html`.

### 5. Instalar las funciones web opcionales respaldadas por el navegador

Requerido solo si tiene la intención de activar la píldora `WEB`:

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

Verifica que los helpers sean ejecutables — con AMBER en ejecución, esto informa las rutas de los helpers, el binario `node` resuelto y cualquier paquete faltante:

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

AMBER utiliza el asistente de Node/Chromium para páginas renderizadas con JavaScript, con una obtención HTTP simple de Python como alternativa para URL directas. El asistente de búsqueda de registros requiere Node.js, las dependencias de npm y Chromium; no tiene una alternativa HTTP simple.

### 6. Instalar soporte OCR opcional

macOS con 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 solo es necesario para los formatos de imagen que requieren conversión antes de que Tesseract pueda procesarlos. AMBER sigue ejecutándose cuando falta cualquier dependencia opcional de OCR.

### Scripts de conveniencia de npm

Los scripts de npm proporcionados inician AMBER con `venv/bin/python3`, así que crea primero ese entorno (paso 3):

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

La ejecución directa con `python3` es la opción más portátil.

### Configuración completa, de principio a 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
```

## Opciones del lanzador

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

| Flag | Predeterminado | Propósito |
|---|---:|---|
| `--host HOST` | `127.0.0.1` | Dirección en la que escucha el servidor HTTP de AMBER |
| `--port PORT` | `8765` | Puerto del servidor HTTP de AMBER |
| `--no-browser` | desactivado | No abrir el navegador predeterminado |
| `--gui PATH` | autodetectado | Servir un archivo HTML de GUI específico |
| `--version` | — | Imprimir la versión de lanzamiento de AMBER ICI y salir |

La interfaz del navegador acepta intencionalmente solo URLs de Ollama en loopback, incluso si el servidor de AMBER está vinculado a otra interfaz.

## Flujo de trabajo en el primer inicio

1. Confirme que el endpoint de Ollama en la esquina superior derecha sea `http://127.0.0.1:11434`.
2. Haga clic en `PING` para cargar los modelos instalados localmente.
3. Seleccione un modelo en el panel Models.
4. Introduzca un prompt en la Analyst Console y haga clic en `SEND`.
5. Opcionalmente, suba archivos o vincule un directorio, luego active los archivos para incluirlos en el contexto.
6. Descargue `embeddinggemma:latest` antes de indexar archivos en Archive.

Para ejecutar la cadena de agentes en su lugar:

1. Abra la pestaña `AGENTS` en el panel izquierdo.
2. Cree un agente con `+ CREATE AGENT`, o describa un objetivo en `GENERATE FROM PROMPT`.
3. Establezca `EXEC` en `AGENTS` en la barra de píldoras de la consola.
4. Establezca `AGN` (cuántos agentes; `0` = todos) y `LOOPS` (cuántas pasadas).
5. Escriba el prompt en la terminal principal y presione `SEND`.

Para permitir que AMBER lea internet, primero establezca la píldora `WEB` en `ON`; está en `OFF` de forma predeterminada.

## Ingesta de archivos

Las cargas están limitadas a 100 MiB por archivo. El selector de archivos y la ruta de arrastrar y soltar actualmente aceptan:

- Documentos: `.txt`, `.md`, `.pdf`, `.docx`, `.rtf`
- Datos/configuración: `.csv`, `.xlsx`, `.json`, `.yaml`, `.yml`, `.toml`, `.ini`, `.cfg`, `.conf`, `.xml`
- Código fuente/registros: `.py`, `.js`, `.ts`, `.tsx`, `.jsx`, `.html`, `.sql`, `.sh`, `.bash`, `.zsh`, `.log`
- Imágenes: `.png`, `.jpg`, `.jpeg`, `.bmp`, `.webp`, `.tif`, `.tiff`, `.svg`

Comportamiento de extracción:

- Los archivos de texto plano, código fuente, configuración, CSV y RTF se decodifican como texto.
- Las hojas de cálculo XLSX se extraen con la biblioteca estándar de Python; las fórmulas y el formato complejo no se conservan.
- El texto DOCX se extrae del XML del documento; el diseño complejo no se conserva.
- La extracción de PDF primero intenta el texto incrustado y también intenta OCR cuando `ocrmypdf` está instalado, conservando el resultado más útil.
- Las imágenes rasterizadas usan Tesseract OCR cuando está instalado. La extracción de SVG lee el contenido incrustado de `<text>` y `<tspan>`.

Los bytes sin procesar cargados se almacenan en `uploads/blobs/`, el texto extraído en `uploads/texts/` y los metadatos en `uploads/manifest.json`.

### Directorios vinculados

`LINK DIRECTORY` expone a AMBER los archivos compatibles y no ocultos de un directorio local. El panel Files trata las entradas vinculadas como de solo lectura, y el listado de directorios no es recursivo. La ruta seleccionada se almacena en `state/linked_dir_state.json`; el contenido de los archivos permanece en su ubicación original y solo se lee cuando se solicita para contexto o extracción.

El selector de carpetas nativo usa Tkinter de Python. Si no está disponible, la interfaz solicita una ruta manualmente. Desvincular el directorio elimina el enlace guardado pero no borra los archivos de origen.

El backend reconoce algunos formatos adicionales de archivos vinculados (`.xls`, `.ods`, `.gif`, `.heic`, `.ico`, `.ppt`, `.pptx` y `.zip`). Los formatos sin un extractor de texto aportan una etiqueta de metadatos en lugar de contenido decodificado. La extracción de `.xls` y `.ods` heredados es de mejor esfuerzo y puede informar que la extracción no está disponible.

## Comportamiento del contexto y la memoria

Las opciones de CTX en la interfaz son `2K`, `4K`, `8K`, `16K` y `32K` y se aplican en las llamadas de Analyst, Parallel y Agent.

- Antes de la inferencia, `trimMsgsToCtx()` elimina los mensajes más antiguos que no son del sistema hasta que la solicitud se ajusta a aproximadamente el 90% del presupuesto de contexto seleccionado, estimado en cuatro caracteres por token.
- La recuperación de archivos activos consulta primero el almacén fractal de Fibonacci, cuando está poblado, y recurre a la ensambladura plana de contexto de archivos.
- La recuperación utiliza hasta una profundidad de 4, un ancho de haz de 2–4 y límites de resultados dependientes del perfil.
- El contexto de archivos activos está limitado según el perfil de memoria: aproximadamente `CTX × 2.6` caracteres en Fast, `CTX × 3.2` en Hybrid y `CTX × 4.0` en Deep.
- El contexto plano sobredimensionado se clasifica con puntuación de superposición de palabras clave antes de la inyección.
- La inyección del scratchpad conserva una cola de aproximadamente 8.000–20.000 caracteres y además está limitada por el presupuesto de contexto de archivos del perfil activo.
- Los agentes con memoria completa reciben los últimos seis mensajes de la conversación. La memoria local utiliza una cola del scratchpad; `none` desactiva ese recuerdo.

Estas son barreras de protección basadas en caracteres, no recuentos exactos del tokenizador.

El Archivo vectorial es duradero, pero el árbol de Fibonacci separado es memoria de sesión. Se construye para un archivo cuando ese archivo se indexa durante la sesión de página actual y no se reconstruye automáticamente a partir de `state/vector_store.json` tras una recarga; hasta que se reconstruya, el contexto de archivos activos utiliza el respaldo plano.

## Persistencia

El lanzador almacena los datos duraderos de la aplicación como JSON bajo `state/` mediante reemplazo atómico de archivos temporales. No hay migración activa a SQLite ni dependencia de base de datos.

| Ruta | Contenido |
|---|---|
| `state/agents_state.json` | Agentes actuales, incluidos el modelo, la temperatura, el límite de tokens, los bucles, el formato y el traspaso de cada agente |
| `state/agent_sets.json` | Presets de agentes guardados |
| `state/agent_run_log.json` | Últimas 100 ejecuciones de agentes: agente, modelo, duración, éxito y contexto |
| `state/pipeline_state.json` | Pasos de pipeline retirados, conservados por compatibilidad hacia atrás |
| `state/chain_sets.json` | Presets de cadenas guardados |
| `state/step_run_log.json`, `state/tool_call_log.json`, `state/tool_registry_state.json` | Registros de pasos, llamadas a herramientas y registro de herramientas |
| `state/chat_history.json` | Últimos 100 mensajes de la conversación; la interfaz reproduce los 30 más recientes |
| `state/scratch.json` | Últimos 20.000 caracteres del scratchpad |
| `state/memory_profile.json` | Selección de recuperación Fast, Hybrid o Deep |
| `state/vector_store.json` | Fragmentos y embeddings del Archivo |
| `state/case_intelligence.json` | Metadatos de casos, contratos de evidencia y procedencia, memoria explícita acotada y recibos de trazas de agentes; se crea en la primera escritura |
| `state/graph_state.json`, `state/timeline_state.json` | Datos de grafo y línea de tiempo |
| `state/web_cache.json` | Resultados de obtención web directa con un TTL de una hora |
| `state/linked_dir_state.json` | Ruta actual del directorio vinculado |
| `uploads/manifest.json` | Metadatos de archivos subidos |

El diseño del panel se almacena en el `localStorage` del navegador, por lo que es específico del perfil del navegador. Las selecciones, estadísticas y el árbol fractal en memoria solo de tiempo de ejecución se restablecen al cargar la página.

Si un archivo JSON de estado no se puede decodificar, el lanzador lo pone en cuarentena con el sufijo `.corrupt-<timestamp>.json` y devuelve un valor vacío para que el panel afectado pueda recuperarse.

## Acceso Web y Límites de Red

La píldora `WEB` es el interruptor maestro y por defecto está en `OFF`.

**Con `WEB` desactivado, AMBER no realiza ninguna solicitud saliente de ningún tipo.** La puerta se aplica dentro de las propias funciones de obtención, por lo que la redacción del prompt, el contexto de archivos inyectado y las llamadas a herramientas de los agentes (`web_fetch`, `online_records_search`) se bloquean por igual. Si un prompt solicita una obtención mientras el interruptor está desactivado, la terminal lo indica y la solicitud no se envía en lugar de fallar silenciosamente.

Con `WEB` activado, AMBER comprueba primero el entorno del helper, imprime la ruta del helper que utilizará y luego resuelve la solicitud en este orden:

1. Una instrucción explícita del sitio como "busca en foxnews.com X" — obtiene ese sitio, usando una URL de búsqueda conocida cuando el tema es específico.
2. Una solicitud específicamente formulada como "búsqueda de registros de/sobre [persona] en [ubicación]" — invoca el asistente de registros.
3. Una URL explícita `http://`/`https://` o un dominio reconocido en el prompt o en el contexto del archivo inyectado.
4. De lo contrario, el texto del prompt se envía al endpoint HTML de DuckDuckGo y se obtiene la página de resultados.

El paso 4 significa que con `WEB` activado, el texto del prompt puede llegar a un motor de búsqueda general. Desactive `WEB` para los prompts cuyo texto no deba salir de la máquina.

Cada resultado se informa en la terminal principal: el modo seleccionado, la ruta del asistente utilizada, la solicitud enviada, el motor que la sirvió (`playwright`, `urllib` o `cache`), el tamaño del contenido y dónde se inyectó, o un bloque de fallo que nombra la dependencia faltante y el comando que la soluciona. Las obtenciones directas se almacenan en caché durante una hora en `state/web_cache.json`.

La búsqueda de registros consulta estas fuentes y devuelve solo las coincidencias cuyo texto de página corrobora tanto el sujeto como la ubicación solicitada: `casesearch.kscourts.gov`, `doc.ks.gov/offender-search`, `kbi.ks.gov/registeredoffender`, DuckDuckGo y Brave Search.

El comportamiento de red es:

- El descubrimiento de modelos, la inferencia, los embeddings y el estado del modelo se conectan únicamente a un endpoint de Ollama en loopback.
- El backend de AMBER sirve archivos locales y rutas de API desde el host/puerto de AMBER configurado.
- Con `WEB` activado, la obtención web de Playwright, su alternativa HTTP de Python y la búsqueda de registros realizan solicitudes salientes a sitios seleccionados por el usuario, proveedores de búsqueda y registros públicos. Con `WEB` desactivado, ninguna de estas se ejecuta.
- `GET /api/web/status` es una verificación previa solo local; inspecciona el sistema de archivos y el `PATH` y no realiza ninguna solicitud de red.
- No existe un endpoint de telemetría de AMBER, y ninguna función transmite credenciales, claves ni datos de uso.

Las páginas obtenidas se inyectan en el prompt como `[WEB CONTEXT]` y, por lo tanto, pasan a formar parte del historial de conversación persistido en `state/chat_history.json`; los agentes cuyo destino de salida es el scratchpad también añaden contenido a `state/scratch.json`. El contenido web en vivo llega al estado local del caso.

El lanzador envía una Política de Seguridad de Contenido restrictiva, desactiva el framing, establece `no-referrer`, bloquea permisos sensibles del navegador y desactiva el almacenamiento en caché HTTP. El contrato `/api/task/execute` del backend puede listar, leer, escribir, añadir o crear archivos dentro de la raíz vinculada cuando se invoca explícitamente. Rechaza rutas que escapan de esa raíz, rutas ocultas, herramientas desconocidas y sobrescrituras que no fueron autorizadas explícitamente. Vincule solo un directorio cuyos contenidos visibles la aplicación local pueda acceder y modificar.

## Panel de Telemetría

Los contadores de sesión se actualizan durante la ejecución de Analyst, Parallel y Agent e incluyen turnos, tokens de prompt/salida, tasa máxima de tokens, tasa promedio de tokens y un sparkline en vivo de la tasa de tokens.

La residencia de VRAM/modelo proviene del endpoint local `/api/ps` de Ollama. Las lecturas de temperatura/utilización son de mejor esfuerzo: NVIDIA usa `nvidia-smi`, Apple Silicon intenta lecturas directas de SMC, Linux verifica las zonas térmicas y herramientas opcionales proporcionan alternativas.

## Limpieza de Datos

Detenga AMBER antes de la limpieza.

Restablezca el estado persistido conservando los archivos cargados:

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

Eliminar los blobs subidos, el texto extraído y su manifiesto:

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

Los archivos de origen vinculados nunca son eliminados por estos comandos. Los directorios de estado y de carga se recrean según sea necesario.

## Solución de problemas

### PING falla o no aparecen modelos

- Confirme que `ollama serve` se está ejecutando.
- Confirme que el endpoint de la UI es `http://127.0.0.1:11434`.
- Ejecute `ollama list` para verificar que al menos un modelo de generación esté instalado.

### La indexación de archivos falla

- Ejecute `ollama pull embeddinggemma:latest`.
- Confirme que Ollama es accesible en el endpoint mostrado en la UI.
- Inspeccione el registro de eventos de AMBER para identificar el endpoint de embeddings o el fragmento de entrada que falla.

### La obtención web respaldada por navegador o la búsqueda de registros falla

La terminal indica el problema exacto. Verifique el entorno directamente con AMBER en ejecución:

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

Luego instala lo que indique que falta:

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

La obtención web directa aún puede funcionar mediante su mecanismo de respaldo HTTP simple. La búsqueda de registros requiere Playwright y puede fallar cuando una fuente cambia el marcado, requiere autenticación/CAPTCHA, bloquea la automatización o no está disponible.

### No se obtiene nada y la terminal muestra `WEB IS OFF`

La píldora `WEB` está en `OFF`, lo que bloquea toda solicitud saliente por diseño. Cámbiala a `ON`.

### Un agente no se ejecuta: `LOCAL MODEL NOT AVAILABLE`

El modelo seleccionado del agente no está instalado en Ollama. La terminal muestra el modelo solicitado, los modelos que sí tienes y la solución:

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

AMBER nunca sustituye silenciosamente por un modelo diferente.

### `SEND` está atenuado

En el modo `ANALYST`, selecciona exactamente un modelo en el panel Models. En el modo `AGENTS`, crea al menos un agente — ahí no se necesita ningún modelo activo.

### Falta el texto de un PDF o una imagen

- Instala `ocrmypdf` y Tesseract.
- Instala Pillow para la conversión de WebP si es necesario.
- Vuelve a subir el archivo para que la extracción se ejecute de nuevo.
- Inspecciona el archivo correspondiente en `uploads/texts/`.

### `npm start` no encuentra Python

Los scripts de npm esperan `venv/bin/python3`. Ejecuta `python3 -m venv venv`, o inicia directamente con `python3 files/launch_amber_ici_gui.py`.

### El puerto 8765 ya está en uso

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

## Estructura del proyecto

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

## Licencia

MIT. Consulte [LICENSE](https://github.com/gs-ai/amber-ici/blob/main/LICENSE).
Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    930
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    554
  • 3

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    354
  • 4

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    349
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    326
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    289

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →