OpenGraph Intel (OGI)

Framework open-source d'analyse visuelle de liens et d'OSINT. Gratuit, auto-hébergeable et piloté par la communauté.

Version

Fonctionnalités • Captures d'écran • Démarrage rapide • Docker • Hub de transforms • Architecture • Contribuer

Attention : Ce projet est en évolution active. Il possède des capacités de base solides et une couverture de tests, et nous continuons d'améliorer la documentation, le durcissement et la profondeur des fonctionnalités à chaque version. Les contributions, signalements de bugs et retours sont les bienvenus.

Fonctionnalités

Investigation graphique visuelle — glisser-déposer des entités, explorer les connexions de manière interactive
Plus de 20 transforms intégrés — DNS, WHOIS, certificats SSL, géolocalisation, enrichissement web/email/hash/social, et plus encore
Hub de transforms — parcourir et installer les transforms de la communauté depuis le registre
Investigateur IA — enquêtes agentiques pilotées par requête qui planifient les exécutions de transforms, diffusent la progression en direct et résument les résultats avec traçabilité
Import / Export — import aux formats JSON, CSV, GraphML et MTGX
Analyse de graphes — centralité, détection de communautés, chemins les plus courts
Collaboration en temps réel — projets, partage et synchronisation en direct via Supabase Realtime
Tâches de transform asynchrones — file d'attente Redis/RQ avec mises à jour de progression WebSocket
Système de plugins — découverte de plugins basée sur des répertoires avec des manifestes YAML
Outil en ligne de commande — rechercher, installer et gérer les transforms depuis le terminal
Fonctionne partout — mode SQLite local (zéro configuration) ou PostgreSQL + Supabase pour les configurations en équipe/cloud
Prêt pour Docker — déploiement en une commande avec docker compose up

Captures d'écran

Investigation graphique	Enrichissement d'entités

Hub de transforms	Export / Import

Démarrage rapide

Prérequis

Outil	Version
Python	3.14+
uv	latest
Node.js	20+
pnpm	latest

Backend```bash

cd backend uv sync uv run uvicorn ogi.main:app --reload

L'API sera disponible à l'adresse `http://localhost:8000`.

Pour l'exécution locale des transformations, Redis et le worker de transformation doivent également être en cours d'exécution. Redis seul ne suffit pas.

Démarrer Redis :```bash
docker run -d --name ogi-redis -p 6379:6379 redis:7-alpine

Démarrez le worker de transformation dans un second terminal :```bash cd backend uv run python -m ogi.worker.run_worker

Si vous voyez `Job queue not available` ou `Redis not available`, vérifiez que :

- `OGI_REDIS_URL` pointe vers `redis://localhost:6379/0` pour les exécutions locales basées sur l'hôte
- le backend a été redémarré après le démarrage de Redis
- le processus worker séparé est en cours d'exécution
- vous n'utilisez pas le nom d'hôte `redis` propre à Docker en dehors de Docker Compose

Si vous exécutez le backend avec PostgreSQL (`OGI_USE_SQLITE=false`), le démarrage appliquera automatiquement les migrations Alembic avant de servir les requêtes. Les déploiements Docker font de même dans le point d'entrée du conteneur backend.

Les exécutions de l'IA Investigator sont traitées par un autre worker séparé :```bash
cd backend
uv run python -m ogi.agent.run_worker

Frontend```bash

cd frontend pnpm install pnpm dev

Open http://localhost:5173. C'est tout.

### AI Investigator

AI Investigator est un workflow optionnel adossé à un fournisseur qui peut planifier des séquences de transformation, demander des approbations et résumer l'avancement des investigations dans l'espace de travail.

- Ouvrez l'onglet `AI Investigator` dans un projet
- Configurez un fournisseur et un modèle dans la boîte de dialogue des paramètres de l'investigateur
- Stockez les clés API du fournisseur dans `API Keys`
- Exécutez le processus séparé `agent-worker` en parallèle du backend

L'implémentation actuelle prend en charge la configuration par utilisateur du fournisseur et un worker dédié qui exécute les étapes d'investigation indépendamment du serveur API principal.

### CLI

Deux méthodes prises en charge pour exécuter la CLI :

**Recommandé** (aucune activation requise) :```bash
cd backend
uv sync
uv run ogi --help

Virtualenv activé (commande ogi simple) :```bash cd backend uv venv

PowerShell:

..venv\Scripts\Activate.ps1 uv pip install -e . ogi --help

## Docker

### Développement```bash
cp .env.example .env
docker compose up

Production

Utilisez les images GHCR préconstruites.

Important : docker-compose.prod.yml nécessite une base de données PostgreSQL externe. Il n'inclut pas de service db.

Si vous souhaitez la pile Docker locale tout-en-un avec Postgres et Redis intégrés, utilisez :```bash docker compose up -d

Utilisez le fichier compose de production uniquement lorsque vous avez déjà une instance PostgreSQL accessible et que vous avez défini `OGI_DATABASE_URL` en conséquence :```bash
docker compose -f docker-compose.prod.yml pull
docker compose -f docker-compose.prod.yml up -d

Définissez OGI_IMAGE_TAG dans .env pour épingler une balise d'image de version spécifique (par ex. v0.2.6). Par défaut, latest.

Hetzner Cloud

Les nouveaux utilisateurs de Hetzner peuvent utiliser le premier lien pour s'inscrire avec des crédits Hetzner Cloud. Il s'agit d'un lien de parrainage, donc le mainteneur d'OGI peut également recevoir des crédits Hetzner Cloud si le parrainage est qualifié. Après avoir créé un serveur, utilisez les commandes de déploiement Docker ci-dessus pour exécuter OGI.

Limites de transformation configurables

OGI est livré avec des valeurs maximales raisonnables par transformation pour des choses comme max_results, max_links, max_urls et max_content_chars, mais ces limites sont désormais remplaçables de manière centralisée afin que les déploiements cloud puissent les appliquer sans coder en dur les limites locales.

Utilisez OGI_TRANSFORM_SETTING_MAX_OVERRIDES dans .env :```env OGI_TRANSFORM_SETTING_MAX_OVERRIDES=max_results=50,max_urls=25,max_links=40,max_content_chars=20000

Pour supprimer des limites spécifiques dans un déploiement local-first :```env
OGI_TRANSFORM_SETTING_MAX_OVERRIDES=max_results=none,max_urls=none,max_links=none,max_content_chars=none

La substitution est indexée par le nom du paramètre de transformation et s'applique aux transformations intégrées et aux plugins de la communauté qui utilisent la base d'exécution partagée d'OGI.

Instance cloud hébergée et plan Supporter

La version cloud hébergée sur ogi.khas.app a d'abord été créée pour permettre aux utilisateurs d'essayer OGI rapidement avant de décider de l'auto-héberger. Elle est depuis devenue la manière la plus populaire d'utiliser le projet, avec plus de 350 utilisateurs cloud actifs.

Cette utilisation a également augmenté les coûts d'infrastructure de ce projet annexe. Le dépôt inclut donc un abonnement Supporter réservé au cloud et un système de temps d'attente entre les exécutions de transformations. Sur l'instance cloud publique, les utilisateurs gratuits peuvent être limités par un délai entre les exécutions de transformations, tandis que les utilisateurs Supporter peuvent s'abonner pour un montant symbolique de 3 USD/mois pour aider à couvrir les coûts Supabase et VPS.

Les abonnements Supporter peuvent être annulés depuis les contrôles de facturation du profil ou le portail de facturation Stripe. L'annulation stoppe les futures facturations, mais les périodes d'abonnement payées ne sont ni remboursées ni au prorata.

Ce code de facturation est intentionnellement protégé par la configuration : il n'a d'effet que lorsque OGI_DEPLOYMENT_MODE=cloud et OGI_CLOUD_BILLING_ENABLED=true. Les déploiements auto-hébergés doivent laisser la facturation désactivée et ne doivent voir aucun comportement de facturation ou de paywall.

Télémétrie

OGI inclut une télémétrie de produit au niveau de l'installation destinée à nous aider à comprendre l'utilisation réelle, en particulier sur les déploiements auto-hébergés.

OGI_TELEMETRY_ENABLED=true active la collecte de télémétrie
OGI_TELEMETRY_LEVEL=full est le niveau de collecte par défaut
définir OGI_TELEMETRY_ENABLED=false pour désactiver complètement la télémétrie
définir OGI_TELEMETRY_LEVEL=basic pour réduire ce qui est envoyé

basic envoie :

la version d'OGI
un ping quotidien d'installation active

full envoie en plus :

la date de création de l'instance
des comptes agrégés pour les projets, entités, arêtes, exécutions de transformations, exécutions d'enquêteur et utilisateurs actifs pour la période
les transformations installées avec leurs versions

La télémétrie est conçue pour éviter d'envoyer le contenu des graphes, les valeurs des entités, les clés API, les invites ou autres données d'enquête. Les détails de la politique actuelle sont également publiés dans la Politique de confidentialité.

Services de développement avec Compose

Service	Description	Port
`backend`	Serveur d'application FastAPI	8000
`worker`	Travailleur de tâches asynchrones RQ	-
`agent-worker`	Travailleur AI Investigator	-
`frontend`	Application React servie via nginx	80
`db`	PostgreSQL 16	5432
`redis`	Redis 7 (file d'attente de tâches)	6379

Services de production avec Compose

Service	Description	Port
`backend`	Serveur d'application FastAPI	8000
`worker`	Travailleur de tâches asynchrones RQ	-
`agent-worker`	Travailleur AI Investigator	-
`frontend`	Application React servie via nginx	80
`redis`	Redis 7 (file d'attente de tâches)	6379

docker-compose.prod.yml attend une base de données PostgreSQL externe via OGI_DATABASE_URL.

Dépendances des plugins au démarrage

Si vous utilisez des images préconstruites et qu'un plugin a besoin de bibliothèques Python supplémentaires, OGI installe les dépendances des plugins au démarrage du conteneur à partir de :

plugins/requirements.txt (recommandé), ou
des exigences générées automatiquement à partir de plugins/ogi-lock.json lorsque requirements.txt est absent.

Variables d’environnement :

Variable	Default	Description
`OGI_BOOT_REQUIREMENTS_ENABLE`	`true`	Activer/désactiver l'installation au démarrage
`OGI_BOOT_REQUIREMENTS_FILE`	`/app/plugins/requirements.txt`	Chemin vers le fichier requirements
`OGI_BOOT_LOCK_FILE`	`/app/plugins/ogi-lock.json`	Chemin vers le fichier de verrouillage
`OGI_BOOT_REQUIREMENTS_STRICT`	`false`	Échouer au démarrage si les exigences sont absentes
`OGI_BOOT_REQUIREMENTS_CACHE_DIR`	`/tmp/ogi-boot`	Répertoire temporaire/cache pour les exigences générées

Hub de transformations

OpenGraph Intel dispose d'un marché de transformations intégré. Parcourez, installez et gérez les transformations depuis le registre communautaire.

Note de sécurité : Les plugins qui nécessitent des clés API doivent être traités comme du code privilégié. Si un plugin peut accéder à vos secrets et effectuer des requêtes réseau sortantes, il peut abuser ou exfiltrer ces secrets. Examinez le niveau de confiance, les autorisations et les services requis avant d'installer ou d'exécuter des plugins tiers.```bash

Search for transforms

uv run ogi transform search dns

Install a transform

uv run ogi transform install shodan-host-lookup

### Catégories de transformations intégrées

| Catégorie  | Exemples                                |
| ---------- | --------------------------------------- |
| DNS        | Enregistrements A, AAAA, MX, NS, CNAME  |
| IP & ASN   | GeoIP, IP inverse, info ASN             |
| SSL/TLS    | Transparence des certificats, labs SSL  |
| Email      | Validation de serveur de messagerie, vérifications de fuites |
| Web        | WHOIS, info domaine, extraction web     |
| Réseaux sociaux | Énumération d'identifiants, profils sociaux |
| Hash       | Recherches MD5, SHA1, SHA256            |
| Localisation | Géocodage, météo, données ASN proches |

### Types d'entités pris en charge

`Person` &bull; `Username` &bull; `Domain` &bull; `IPAddress` &bull; `EmailAddress` &bull; `PhoneNumber` &bull; `Organization` &bull; `URL` &bull; `SocialMedia` &bull; `Hash` &bull; `Document` &bull; `Location` &bull; `ASNumber` &bull; `Network` &bull; `MXRecord` &bull; `NSRecord` &bull; `Nameserver` &bull; `SSLCertificate` &bull; `Subdomain` &bull; `HTTPHeader`

### Créer vos propres transformations

Vous voulez créer les vôtres ? Consultez le [guide de contribution](https://github.com/opengraphintel/ogi-transforms/blob/main/CONTRIBUTING.md).

Si votre transformation nécessite des identifiants de service externes, déclarez-les dans `api_keys_required`. Ne stockez pas de secrets dans les paramètres de transformation. OGI les gère sous `API Keys`, et les plugins utilisant des secrets sont considérés comme du code privilégié.

Si votre transformation expose des paramètres limités tels que `max_results` ou `max_content_chars`, privilégiez autant que possible des noms de paramètres stables plutôt que des noms spécifiques. OGI peut outrepasser les valeurs maximales centralement avec `OGI_TRANSFORM_SETTING_MAX_OVERRIDES`, ce qui aide les déploiements cloud à appliquer des limites tandis que les utilisateurs locaux peuvent les supprimer.

Chaque plugin est un répertoire contenant un manifeste `plugin.yaml` :```yaml
name: my-transform
version: "1.0.0"
display_name: My Transform
description: What it does
author: Your Name
license: MIT
category: dns
input_types: [Domain]
output_types: [IPAddress]
permissions:
  network: true
  filesystem: false
  subprocess: false

Architecture

Stack technique

Couche	Technologie
Backend	Python 3.14+, FastAPI, SQLModel, asyncpg / aiosqlite
Frontend	React 19, TypeScript 5.9, Sigma.js (graphology), Zustand, Tailwind CSS 4
Base de données	PostgreSQL 16 (principal) / SQLite (solution de repli locale)
Auth & Temps réel	Supabase Auth + JWT + Realtime (optionnel en mode local)
File d'attente	Redis 7 + RQ (transformations asynchrones)
Runtime IA	Worker AI Investigator soutenu par un fournisseur avec orchestration audité
Gestionnaires de paquets	uv (backend), pnpm (frontend)
Déploiement	Docker, nginx, GHCR

Structure du projet```

ogi/ ├── backend/ │ └── ogi/ │ ├── api/ # REST API routes │ ├── cli/ # CLI tool (Typer) │ ├── db/ # Database layer (asyncpg + aiosqlite) │ ├── engine/ # Graph engine & transform engine │ ├── models/ # SQLModel definitions │ ├── store/ # Data stores │ ├── transforms/ # Built-in transforms │ │ ├── dns/ # DNS resolution transforms │ │ ├── cert/ # SSL certificate transforms │ │ ├── email/ # Email enrichment │ │ ├── hash/ # Hash lookups │ │ ├── ip/ # IP/ASN/geolocation │ │ ├── org/ # Organization info │ │ ├── social/ # Social media │ │ └── web/ # Web scraping/extraction │ ├── worker/ # Async job queue (RQ) │ ├── config.py # Pydantic settings │ └── main.py # FastAPI entry point ├── frontend/ │ └── src/ │ ├── api/ # API client │ ├── components/ # React components │ ├── hooks/ # Custom hooks (realtime sync, etc.) │ ├── stores/ # Zustand state management │ ├── types/ # TypeScript types │ └── App.tsx # Main application ├── plugins/ # Community plugins directory ├── docs/ # Documentation & images ├── docker-compose.yml # Development deployment ├── docker-compose.prod.yml # Production deployment └── .env.example # Environment template

### Configuration

OGI utilise [pydantic-settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) avec le support des fichiers `.env`. Les variables d'exécution/backend sont préfixées par `OGI_`.

Les paramètres de type liste acceptent soit :

- des tableaux JSON, par exemple `["plugins","../plugins"]`
- des chaînes séparées par des virgules, par exemple `plugins,../plugins`

<details>
<summary><strong>Variables d'environnement clés</strong></summary>

| Variable                                        | Description                                                                                                      | Valeur par défaut                                   |
| ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
| `OGI_APP_NAME`                                  | Nom de l'application                                                                                             | `OGI`                                               |
| `OGI_HOST`                                      | Hôte de liaison du backend                                                                                       | `0.0.0.0`                                           |
| `OGI_PORT`                                      | Port du backend                                                                                                  | `8000`                                              |
| `OGI_CORS_ORIGINS`                              | Origines frontend autorisées                                                                                     | `http://localhost:5173,http://localhost:3000`       |
| `OGI_USE_SQLITE`                                | Utiliser SQLite au lieu de PostgreSQL                                                                            | `true`                                              |
| `OGI_DB_PATH`                                   | Chemin du fichier de base de données SQLite                                                                      | `ogi.db`                                            |
| `OGI_DATABASE_URL`                              | Chaîne de connexion PostgreSQL                                                                                   | `postgresql://postgres:postgres@localhost:5432/ogi` |
| `OGI_REDIS_URL`                                 | Chaîne de connexion Redis pour RQ/tâches                                                                         | `redis://localhost:6379/0`                          |
| `OGI_RQ_QUEUE_NAME`                             | Nom de la file d'attente pour les tâches de transformation                                                       | `transforms`                                        |
| `OGI_TRANSFORM_TIMEOUT`                         | Délai d'expiration par tâche de transformation en secondes                                                       | `300`                                               |
| `OGI_AGENT_WORKER_POLL_INTERVAL_SEC`            | Intervalle d'interrogation pour le travailleur de l'Investigateur IA                                             | `2.0`                                               |
| `OGI_AGENT_CLAIM_TIMEOUT_SEC`                   | Délai d'expiration des revendications obsolètes pour la reprise d'étape de l'Investigateur IA                    | `120`                                               |
| `OGI_AUTO_RUN_MIGRATIONS`                       | Exécuter automatiquement Alembic au démarrage local sans SQLite                                                  | `true`                                              |
| `OGI_RUN_DB_MIGRATIONS`                         | Exécuter les migrations de la base de données dans le point d'entrée du conteneur                                | `false`                                             |
| `OGI_DB_MIGRATION_RETRIES`                      | Nombre de tentatives de migration du point d'entrée                                                               | `30`                                                |
| `OGI_DB_MIGRATION_DELAY_SECONDS`                | Délai entre les tentatives de migration du point d'entrée                                                        | `2`                                                 |
| `OGI_PLUGIN_DIRS`                               | Répertoires de recherche de plugins                                                                              | `plugins,../plugins`                                |
| `OGI_DEPLOYMENT_MODE`                           | Mode de déploiement (`self-hosted` ou `cloud`)                                                                   | `self-hosted`                                       |
| `OGI_CLOUD_BILLING_ENABLED`                     | Activer la facturation cloud uniquement pour les supporters et l'application du délai de refroidissement         | `false`                                             |
| `OGI_FREE_TRANSFORM_COOLDOWN_SECONDS`           | Délai de refroidissement entre les exécutions des transformations cloud gratuites                                | `1800`                                              |
| `OGI_PAID_TRANSFORM_COOLDOWN_SECONDS`           | Délai de refroidissement entre les exécutions des transformations cloud payantes                                 | `0`                                                 |
| `OGI_STRIPE_SECRET_KEY`                         | Clé secrète côté serveur Stripe pour les sessions Checkout et portail                                           | non défini                                          |
| `OGI_STRIPE_WEBHOOK_SECRET`                     | Secret de signature du webhook Stripe                                                                            | non défini                                          |
| `OGI_STRIPE_SUPPORTER_PRICE_ID`                 | ID de prix récurrent Stripe pour le plan Supporter                                                               | non défini                                          |
| `OGI_STRIPE_SUPPORTER_AMOUNT_CENTS`             | Montant affiché pour le plan Supporter                                                                           | `300`                                               |
| `OGI_STRIPE_SUPPORTER_CURRENCY`                 | Devise affichée pour le plan Supporter                                                                           | `usd`                                               |
| `OGI_BILLING_SUCCESS_URL`                       | Redirection de succès optionnelle Stripe Checkout                                                                | dérivé de la requête                                |
| `OGI_BILLING_CANCEL_URL`                        | Redirection d'annulation optionnelle Stripe Checkout                                                             | dérivé de la requête                                |
| `OGI_BILLING_PORTAL_RETURN_URL`                 | URL de retour optionnelle du portail de facturation Stripe                                                       | dérivé de la requête                                |
| `OGI_REGISTRY_REPO`                             | Dépôt GitHub du registre des transformations                                                                     | `opengraphintel/ogi-transforms`                     |
| `OGI_REGISTRY_CACHE_TTL`                        | Durée de vie du cache du registre en secondes                                                                    | `3600`                                              |
| `OGI_TRANSFORM_SETTING_MAX_OVERRIDES`           | Nombre maximal global optionnel de remplacements pour les paramètres de transformation                           | vide                                                |
| `OGI_GITHUB_TOKEN`                              | Jeton GitHub optionnel pour les limites de débit du registre/API                                                 | non défini                                          |
| `OGI_SUPABASE_URL`                              | URL du projet Supabase                                                                                           | non défini                                          |
| `OGI_SUPABASE_ANON_KEY`                         | Clé publique/anonyme Supabase                                                                                    | non défini                                          |
| `OGI_SUPABASE_SERVICE_ROLE_KEY`                 | Clé de rôle de service Supabase                                                                                  | non défini                                          |
| `OGI_SUPABASE_JWT_SECRET`                       | Secret JWT Supabase                                                                                              | non défini                                          |
| `OGI_SUPABASE_REDIRECT_URL`                     | URL de redirection utilisée par les flux d'authentification frontend                                             | non défini                                          |
| `OGI_ADMIN_EMAILS`                              | Utilisateurs administrateurs pour la gestion du registre/plugins                                                 | non défini                                          |
| `OGI_TELEMETRY_ENABLED`                         | Activer ou désactiver la télémétrie au niveau de l'installation                                                  | `true`                                              |
| `OGI_TELEMETRY_LEVEL`                           | Niveau de télémétrie (`basic` ou `full`)                                                                         | `full`                                              |
| `OGI_API_KEY_ENCRYPTION_KEY`                    | Clé Fernet pour le stockage chiffré des clés API                                                                 | non défini mais fortement recommandé                |
| `OGI_API_KEY_INJECTION_ALLOW_COMMUNITY_PLUGINS` | Autoriser les plugins communautaires à recevoir les clés API stockées                                            | `true`                                              |
| `OGI_API_KEY_INJECTION_TRUSTED_TIERS_ONLY`      | Restreindre l'injection de clés stockées aux niveaux de confiance uniquement                                     | `false`                                             |
| `OGI_API_KEY_INJECTION_ALLOWED_TIERS`           | Niveaux autorisés lorsque le mode confiance uniquement est activé                                                | `official,verified`                                 |
| `OGI_API_KEY_SERVICE_ALLOWLIST`                 | Liste blanche optionnelle des services pour l'injection de clés stockées                                         | vide                                                |
| `OGI_API_KEY_SERVICE_BLOCKLIST`                 | Liste noire optionnelle des services pour l'injection de clés stockées                                           | vide                                                |
| `OGI_LLM_PROVIDER`                              | Fournisseur par défaut de l'Investigateur IA (solution de repli)                                                 | `openai`                                            |
| `OGI_LLM_MODEL`                                 | Modèle par défaut de l'Investigateur IA (solution de repli)                                                      | `gpt-4.1-mini`                                      |
| `OGI_EXPOSE_ERROR_DETAILS`                      | Inclure les détails internes dans les réponses 500                                                               | `false`                                             |
| `OGI_SANDBOX_ENABLED`                           | Activer le mode d'exécution en bac à sable                                                                       | `false`                                             |
| `OGI_SANDBOX_TIMEOUT`                           | Délai d'expiration du bac à sable en secondes                                                                    | `30`                                                |
| `OGI_SANDBOX_MEMORY_MB`                         | Limite de mémoire du bac à sable en Mo                                                                           | `256`                                               |
| `OGI_SANDBOX_ALLOWED_TIERS`                     | Niveaux autorisés en mode bac à sable cloud                                                                      | `official,verified`                                 |
| `OGI_BOOT_REQUIREMENTS_ENABLE`                  | Activer l'installation des dépendances des plugins au démarrage                                                  | `true`                                              |
| `OGI_BOOT_REQUIREMENTS_FILE`                    | Chemin du fichier des prérequis de démarrage                                                                     | `/app/plugins/requirements.txt`                     |
| `OGI_BOOT_LOCK_FILE`                            | Chemin du fichier de verrouillage de démarrage                                                                   | `/app/plugins/ogi-lock.json`                        |
| `OGI_BOOT_REQUIREMENTS_STRICT`                  | Échouer au démarrage si les prérequis des plugins sont manquants                                                 | `false`                                             |
| `OGI_BOOT_REQUIREMENTS_CACHE_DIR`               | Répertoire temporaire/cache pour la génération des prérequis de démarrage                                        | `/tmp/ogi-boot`                                     |
| `OGI_FRONTEND_PORT`                             | Mappage de port local Docker pour le frontend                                                                    | `3000`                                              |
| `OGI_IMAGE_TAG`                                 | Étiquette d'image pour les déploiements de type compose/Coolify                                                  | `latest`                                            |
| `OGI_BACKEND_IMAGE`                             | Remplacement optionnel de l'image du backend                                                                     | `ghcr.io/khashashin/ogi-backend`                    |
| `OGI_WORKER_IMAGE`                              | Remplacement optionnel de l'image du travailleur. Par défaut, l'image du backend car travailleur et backend partagent la même construction d'image. | `ghcr.io/khashashin/ogi-backend`                    |
| `OGI_FRONTEND_IMAGE`                            | Remplacement optionnel de l'image du frontend                                                                    | `ghcr.io/khashashin/ogi-frontend`                   |
| `OGI_CLI_BEARER_TOKEN`                          | Jeton Bearer optionnel pour l'interface CLI sur les backends avec authentification                               | non défini                                          |

Voir [`.env.example`](https://github.com/khashashin/ogi/blob/HEAD/.env.example) pour la liste complète.

</details>

## Développement

### Exécuter les Tests```bash
# Backend
cd backend
OGI_DB_PATH=":memory:" OGI_USE_SQLITE=true uv run pytest

# Frontend
cd frontend
pnpm test

Linting & Vérification de type```bash

Backend

cd backend uv run ruff check # Linting uv run mypy # Type checking

Frontend

cd frontend pnpm lint # ESLint

### CI Pipeline

Le [workflow CI](https://github.com/khashashin/ogi/blob/HEAD/.github/workflows/ci.yml) s'exécute à chaque pull request :

- **Backend :** ruff lint, mypy type check, pytest
- **Frontend :** vitest, eslint, vite build

## Contribuer

Les PRs sont les bienvenus ! Si vous trouvez un bug ou avez une idée, [ouvrez un ticket](https://github.com/khashashin/ogi/issues).

Pour de nouvelles transformations, contribuez à [ogi-transforms](https://github.com/opengraphintel/ogi-transforms).

### Pour commencer

1. Forkez le dépôt
2. Créez une branche de fonctionnalité (`git checkout -b feature/my-feature`)
3. Effectuez vos modifications
4. Exécutez les tests et le linting
5. Soumettez une pull request

## Utilisation légale et responsable

OGI est un outil d'OSINT et d'analyse de graphes à usage général. **Vous êtes seul responsable de la manière dont vous l'utilisez.** Voir [LEGAL.md](https://github.com/khashashin/ogi/blob/HEAD/LEGAL.md) pour l'avis juridique complet.

- **Respectez les conditions d'utilisation des services tiers.** Les transformations qui interrogent des services externes (DNS, WHOIS, web scraping, recherche de noms d'utilisateur, etc.) doivent être utilisées conformément aux CGU de ces services. Les requêtes automatisées ou en masse sur des sites qui les interdisent peuvent violer leurs conditions.
- **Respectez la législation sur la protection des données.** Si vous êtes dans l'UE ou traitez des données concernant des résidents de l'UE, le RGPD s'applique à vous en tant que responsable du traitement. La collecte, le stockage ou le traitement de données personnelles (noms, adresses e-mail, adresses IP, etc.) nécessite une base légale. OGI lui-même ne stocke pas de données au-delà de votre instance locale — vous êtes responsable de ce que vous collectez et conservez.
- **Utilisation à des fins légales uniquement.** OGI est destiné à la recherche légitime en sécurité, aux enquêtes, au renseignement sur les menaces et à un usage éducatif. Ne l'utilisez pas pour harceler des individus, effectuer des accès non autorisés ou violer la loi applicable.
- **Compatibilité des formats de fichiers.** OGI prend en charge l'import du format d'échange de graphes MTGX. Ceci est fourni uniquement pour l'interopérabilité des données et n'implique aucune affiliation avec ou approbation par les créateurs d'outils utilisant ce format.

> **Avertissement :** OGI est fourni « en l'état » sans garantie d'aucune sorte. Les auteurs ne sont pas responsables de toute utilisation abusive ou des dommages découlant de l'utilisation de ce logiciel.

## Licence

Ce projet est sous licence [GNU Affero General Public License v3.0](https://github.com/khashashin/ogi/blob/HEAD/LICENSE).

---

<div align="center">

**[Signaler un bug](https://github.com/khashashin/ogi/issues) &bull; [Demander une fonctionnalité](https://github.com/khashashin/ogi/issues) &bull; [Discussions](https://github.com/opengraphintel/ogi-transforms/discussions)**

Réalisé avec 💜 par la communauté OGI

</div>

Lire plus