ogi v0.8.0
Open-Source-Link-Analyse- & OSINT-Framework
OpenGraph Intel (OGI)
Open-Source-Framework für visuelle Linkanalyse und OSINT. Kostenlos, selbst hostbar und gemeinschaftsgetrieben.
Funktionen • Bildschirmfotos • Schnellstart • Docker • Transform-Hub • Architektur • Mitwirken
Hinweis: Dieses Projekt entwickelt sich aktiv weiter. Es verfügt über solide Kernfunktionen und Testabdeckung, und wir verbessern mit jedem Release kontinuierlich die Dokumentation, Härtung und Funktionstiefe. Beiträge, Fehlermeldungen und Rückmeldungen sind sehr willkommen.
Funktionen
- Visuelle Graphenuntersuchung — Entitäten per Drag-and-Drop verschieben, Verbindungen interaktiv erkunden
- 20+ integrierte Transforms — DNS, WHOIS, SSL-Zertifikate, Geolokalisierung, Web-/E-Mail-/Hash-/Social-Anreicherung und mehr
- Transform-Hub — Community-Transforms aus der Registry durchsuchen und installieren
- KI-Ermittler — promptgesteuerte agentische Untersuchungen, die Transform-Abläufe planen, Fortschritte live streamen und Ergebnisse mit Nachvollziehbarkeit zusammenfassen
- Import / Export — Import im JSON-, CSV-, GraphML- und MTGX-Format
- Graphenanalyse — Zentralität, Gemeinschaftserkennung, kürzeste Pfade
- Echtzeit-Zusammenarbeit — Projekte, Teilen und Live-Synchronisation über Supabase Realtime
- Asynchrone Transform-Jobs — Redis/RQ-Warteschlange mit WebSocket-Fortschrittsaktualisierungen
- Plugin-System — verzeichnisbasierte Plugin-Erkennung mit YAML-Manifesten
- CLI-Werkzeug — Transforms über das Terminal suchen, installieren und verwalten
- Läuft überall — lokaler SQLite-Modus (null Konfiguration) oder PostgreSQL + Supabase für Team-/Cloud-Setups
- Docker-bereit — Ein-Kommando-Bereitstellung mit
docker compose up
Bildschirmfotos
| Graphenuntersuchung | Entitätenanreicherung |
|---|---|
 |  |
| Transform-Hub | Export / Import |
|---|---|
 |  |
Schnellstart
Voraussetzungen
Backend```bash
cd backend uv sync uv run uvicorn ogi.main:app --reload
Die API wird unter `http://localhost:8000` verfügbar sein.
Für die lokale Transform-Ausführung müssen Redis und der transform worker ebenfalls laufen. Redis allein reicht nicht.```bash
docker run -d --name ogi-redis -p 6379:6379 redis:7-alpine
Starten Sie den Transform-Worker in einem zweiten Terminal:```bash cd backend uv run python -m ogi.worker.run_worker
Falls Sie `Job queue not available` oder `Redis not available` sehen, überprüfen Sie Folgendes:
- `OGI_REDIS_URL` zeigt auf `redis://localhost:6379/0` für lokale host-basierte Ausführungen
- das Backend wurde neu gestartet, nachdem Redis hochgefahren war
- der separate Worker-Prozess läuft
- Sie verwenden nicht den Docker-exklusiven Hostnamen `redis` außerhalb von Docker Compose
Wenn Sie das Backend gegen PostgreSQL betreiben (`OGI_USE_SQLITE=false`), wendet der Start automatisch Alembic-Migrationen an, bevor Anfragen bedient werden. Docker-Bereitstellungen machen dasselbe im Backend-Container-Entrypoint.
AI Investigator-Läufe werden von einem weiteren separaten Worker verarbeitet:```bash
cd backend
uv run python -m ogi.agent.run_worker
Frontend```bash
cd frontend pnpm install pnpm dev
Öffne http://localhost:5173. Das war's.
### KI-Ermittler
Der KI-Ermittler ist ein optionaler, anbieterunterstützter Workflow, der Transformationssequenzen planen, Genehmigungen anfordern und den Untersuchungsfortschritt im Arbeitsbereich zusammenfassen kann.
- Öffnen Sie den Reiter `AI Investigator` in einem Projekt
- Konfigurieren Sie einen Anbieter und ein Modell im Ermittlereinstellungsdialog
- Speichern Sie Anbieter-API-Schlüssel unter `API Keys`
- Führen Sie den separaten `agent-worker`-Prozess zusammen mit dem Backend aus
Die aktuelle Implementierung unterstützt pro Benutzer konfigurierbare Anbieter und einen dedizierten Worker, der Untersuchungsschritte unabhängig vom Haupt-API-Server ausführt.
### CLI
Zwei unterstützte Möglichkeiten zur Ausführung der CLI:
**Empfohlen** (keine Aktivierung erforderlich):```bash
cd backend
uv sync
uv run ogi --help
Aktiviertes virtualenv (einfacher ogi-Befehl):```bash
cd backend
uv venv
PowerShell:
..venv\Scripts\Activate.ps1 uv pip install -e . ogi --help
## Docker
### Entwicklung```bash
cp .env.example .env
docker compose up
Produktion
Verwenden Sie die vorgefertigten GHCR-Images.
Wichtig: docker-compose.prod.yml erfordert eine externe PostgreSQL-Datenbank. Es enthält keinen db-Dienst.
Wenn Sie den All-in-One lokalen Docker-Stapel mit integriertem Postgres und Redis verwenden möchten, verwenden Sie:```bash docker compose up -d
Verwenden Sie die Produktions-Compose-Datei nur, wenn Sie bereits eine erreichbare PostgreSQL-Instanz haben und `OGI_DATABASE_URL` entsprechend gesetzt haben:```bash
docker compose -f docker-compose.prod.yml pull
docker compose -f docker-compose.prod.yml up -d
Setzen Sie OGI_IMAGE_TAG in .env, um einen bestimmten Release-Image-Tag festzulegen (z.B. v0.2.6). Standardmäßig wird latest verwendet.
Hetzner Cloud
Neue Hetzner-Benutzer können den ersten Link verwenden, um sich mit Hetzner Cloud Credits anzumelden. Es handelt sich um einen Empfehlungslink, sodass der OGI-Maintainer möglicherweise ebenfalls Hetzner Cloud Credits erhält, wenn die Empfehlung qualifiziert ist. Nach dem Erstellen eines Servers verwenden Sie die obigen Docker-Bereitstellungsbefehle, um OGI auszuführen.
Konfigurierbare Transformationsgrenzen
OGI wird mit sinnvollen transformationsspezifischen Maximalwerten für Dinge wie max_results, max_links, max_urls und max_content_chars ausgeliefert, aber diese Grenzen sind jetzt zentral überschreibbar, sodass Cloud-Bereitstellungen sie durchsetzen können, ohne lokale Limits fest codieren zu müssen.
Verwenden Sie OGI_TRANSFORM_SETTING_MAX_OVERRIDES in .env:```env
OGI_TRANSFORM_SETTING_MAX_OVERRIDES=max_results=50,max_urls=25,max_links=40,max_content_chars=20000
Um bestimmte Einschränkungen in einer lokalen Bereitstellung zu entfernen:```env
OGI_TRANSFORM_SETTING_MAX_OVERRIDES=max_results=none,max_urls=none,max_links=none,max_content_chars=none
Die Überschreibung erfolgt über den Namen der Transform-Einstellung und gilt sowohl für eingebaute Transforms als auch für Community-Plugins, die die gemeinsame Transform-Basis/-Laufzeitumgebung von OGI nutzen.
Gehostete Cloud-Instanz und Supporter-Plan
Die gehostete Cloud-Version unter ogi.khas.app wurde ursprünglich entwickelt, damit Nutzer OGI schnell ausprobieren können, bevor sie sich für eine Selbsthosting-Lösung entscheiden. Sie ist inzwischen die beliebteste Nutzungsform des Projekts mit über 350 aktiven Cloud-Nutzern.
Diese Nutzung hat auch die Infrastrukturkosten für dieses Nebenprojekt erhöht. Das Repository enthält daher ein Cloud-exklusives Supporter-Abonnement und ein Abkühlungssystem für Transformer-Aufrufe. In der öffentlichen Cloud-Instanz können kostenlose Nutzer durch ein Timeout zwischen Transformer-Aufrufen eingeschränkt sein, während Supporter-Nutzer für symbolische 3 USD/Monat abonnieren können, um bei der Deckung der Supabase- und VPS-Kosten zu helfen.
Supporter-Abonnements können über die Profil-Abrechnungssteuerung oder das Stripe-Abrechnungsportal gekündigt werden. Die Kündigung beendet zukünftige Zahlungen, aber bereits bezahlte Abonnementzeiträume werden nicht erstattet oder anteilig zurückgezahlt.
Dieser Abrechnungscode ist absichtlich durch die Konfiguration geschützt: Er wirkt sich nur aus, wenn OGI_DEPLOYMENT_MODE=cloud und OGI_CLOUD_BILLING_ENABLED=true gesetzt sind. Selbstgehostete Bereitstellungen sollten die Abrechnung deaktiviert lassen und keinerlei Abrechnungs- oder Paywall-Verhalten zeigen.
Telemetrie
OGI enthält installationsbezogene Produkttelemetrie, die uns helfen soll, die tatsächliche Nutzung zu verstehen, insbesondere bei selbstgehosteten Bereitstellungen.
OGI_TELEMETRY_ENABLED=trueaktiviert die TelemetrieerfassungOGI_TELEMETRY_LEVEL=fullist die Standard-Erfassungsstufe- setze
OGI_TELEMETRY_ENABLED=false, um die Telemetrie vollständig zu deaktivieren - setze
OGI_TELEMETRY_LEVEL=basic, um die gesendeten Daten zu reduzieren
basic sendet:
- OGI-Version
- einen täglichen Ping zur aktiven Installation
full sendet zusätzlich:
- Erstellungsdatum der Instanz
- aggregierte Zählungen für Projekte, Entitäten, Kanten, Transform-Ausführungen, Investigator-Ausführungen und aktive Nutzer für den Zeitraum
- installierte Transforms mit ihren Versionen
Telemetrie ist so konzipiert, dass sie das Senden von Grapheninhalten, Entitätswerten, API-Schlüsseln, Prompts oder anderen Untersuchungsdaten vermeidet. Die aktuellen Richtliniendetails sind auch in der Datenschutzerklärung veröffentlicht.
Entwicklungs-Compose-Dienste
| Dienst | Beschreibung | Port |
|---|---|---|
backend | FastAPI-Anwendungsserver | 8000 |
worker | RQ-Async-Job-Worker | - |
agent-worker | AI-Investigator-Worker | - |
frontend | React-App bereitgestellt via nginx | 80 |
db | PostgreSQL 16 | 5432 |
redis | Redis 7 (Job-Warteschlange) | 6379 |
Produktions-Compose-Dienste
| Dienst | Beschreibung | Port |
|---|---|---|
backend | FastAPI-Anwendungsserver | 8000 |
worker | RQ-Async-Job-Worker | - |
agent-worker | AI-Investigator-Worker | - |
frontend | React-App bereitgestellt via nginx | 80 |
redis | Redis 7 (Job-Warteschlange) | 6379 |
docker-compose.prod.yml erwartet eine externe PostgreSQL-Datenbank über OGI_DATABASE_URL.
Plugin-Abhängigkeiten zur Startzeit
Wenn du vorgefertigte Images verwendest und ein Plugin zusätzliche Python-Bibliotheken benötigt, installiert OGI die Plugin-Abhängigkeiten beim Container-Start aus:
plugins/requirements.txt(bevorzugt) oder- automatisch generierte Anforderungen aus
plugins/ogi-lock.json, wennrequirements.txtfehlt.
Umgebungsvariablen:
| Variable | Standard | Beschreibung |
|---|---|---|
OGI_BOOT_REQUIREMENTS_ENABLE | true | Aktivieren/Deaktivieren der Installation zur Startzeit |
OGI_BOOT_REQUIREMENTS_FILE | /app/plugins/requirements.txt | Pfad zur Requirements-Datei |
OGI_BOOT_LOCK_FILE | /app/plugins/ogi-lock.json | Pfad zur Lock-Datei |
OGI_BOOT_REQUIREMENTS_STRICT | false | Start abbrechen, wenn Requirements fehlen |
OGI_BOOT_REQUIREMENTS_CACHE_DIR | /tmp/ogi-boot | Temporär-/Cache-Verzeichnis für generierte Requirements |
Transform Hub
OpenGraph Intel verfügt über einen integrierten Transform-Marktplatz. Durchstöbere, installiere und verwalte Transforms aus der Community-Registry.
Sicherheitshinweis: Plugins, die API-Schlüssel benötigen, sollten als privilegierter Code behandelt werden. Wenn ein Plugin auf deine Geheimnisse zugreifen und ausgehende Netzwerkanfragen stellen kann, kann es diese Geheimnisse missbrauchen oder exfiltrieren. Überprüfe die Vertrauensstufe, Berechtigungen und erforderlichen Dienste, bevor du Plugins von Drittanbietern installierst oder ausführst.```bash
Search for transforms
uv run ogi transform search dns
Install a transform
uv run ogi transform install shodan-host-lookup
### Integrierte Transformationskategorien
| Kategorie | Beispiele |
| --------- | -------------------------------------- |
| DNS | A, AAAA, MX, NS, CNAME-Einträge |
| IP & ASN | GeoIP, Reverse-IP, ASN-Info |
| SSL/TLS | Zertifikatstransparenz, SSL-Labs |
| E-Mail | Mailserver-Validierung, Leak-Prüfungen |
| Web | WHOIS, Domain-Info, Web-Extraktion |
| Sozial | Benutzername-Enumeration, soziale Profile |
| Hash | MD5-, SHA1-, SHA256-Abfragen |
| Standort | Geokodierung, Wetter, nahegelegene ASN-Daten |
### Unterstützte Entitätstypen
`Person` • `Username` • `Domain` • `IPAddress` • `EmailAddress` • `PhoneNumber` • `Organization` • `URL` • `SocialMedia` • `Hash` • `Document` • `Location` • `ASNumber` • `Network` • `MXRecord` • `NSRecord` • `Nameserver` • `SSLCertificate` • `Subdomain` • `HTTPHeader`
### Eigene Transformationen erstellen
Möchten Sie eigene erstellen? Siehe den [Beitragsleitfaden](https://github.com/opengraphintel/ogi-transforms/blob/main/CONTRIBUTING.md).
Wenn Ihre Transformation externe Dienst-Anmeldedaten benötigt, deklarieren Sie diese in `api_keys_required`. Speichern Sie keine Geheimnisse in den Transformationseinstellungen. OGI verwaltet diese unter `API Keys`, und Plugins, die Geheimnisse verwenden, gelten als privilegierter Code.
Wenn Ihre Transformation begrenzte Einstellungen wie `max_results` oder `max_content_chars` bereitstellt, bevorzugen Sie stabile Einstellungsnamen gegenüber maßgeschneiderten Einmalnamen, wo möglich. OGI kann zentral Maximalwerte mit `OGI_TRANSFORM_SETTING_MAX_OVERRIDES` überschreiben, was Cloud-Bereitstellungen hilft, Grenzwerte durchzusetzen, während lokale Benutzer sie entfernen können.
Jedes Plugin ist ein Verzeichnis mit einem `plugin.yaml`-Manifest:```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
Architektur
Technologie-Stack
| Schicht | Technologie |
|---|---|
| Backend | Python 3.14+, FastAPI, SQLModel, asyncpg / aiosqlite |
| Frontend | React 19, TypeScript 5.9, Sigma.js (graphology), Zustand, Tailwind CSS 4 |
| Datenbank | PostgreSQL 16 (primary) / SQLite (lokaler Fallback) |
| Auth & Echtzeit | Supabase Auth + JWT + Realtime (optional im lokalen Modus) |
| Job-Warteschlange | Redis 7 + RQ (asynchrone Transformationen) |
| KI-Laufzeitumgebung | Anbieter-gestützter AI Investigator worker mit auditierter Transform-Orchestrierung |
| Paketmanager | uv (backend), pnpm (frontend) |
| Bereitstellung | Docker, nginx, GHCR |
Projektstruktur```
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
### Konfiguration
OGI nutzt [pydantic-settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) mit `.env`-Dateiunterstützung. Laufzeit-/Backend-Variablen sind mit `OGI_` präfixiert.
Listeneinstellungen akzeptieren entweder:
- JSON-Arrays, z. B. `["plugins","../plugins"]`
- Komma-getrennte Zeichenketten, z. B. `plugins,../plugins`
<details>
<summary><strong>Wichtige Umgebungsvariablen</strong></summary>
| Variable | Beschreibung | Standard |
| ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
| `OGI_APP_NAME` | Anwendungsname | `OGI` |
| `OGI_HOST` | Backend-Bind-Host | `0.0.0.0` |
| `OGI_PORT` | Backend-Port | `8000` |
| `OGI_CORS_ORIGINS` | Erlaubte Frontend-Ursprünge | `http://localhost:5173,http://localhost:3000` |
| `OGI_USE_SQLITE` | SQLite statt PostgreSQL verwenden | `true` |
| `OGI_DB_PATH` | SQLite-Datenbankdateipfad | `ogi.db` |
| `OGI_DATABASE_URL` | PostgreSQL-Verbindungszeichenfolge | `postgresql://postgres:postgres@localhost:5432/ogi`|
| `OGI_REDIS_URL` | Redis-Verbindungszeichenfolge für RQ/Jobs | `redis://localhost:6379/0` |
| `OGI_RQ_QUEUE_NAME` | Warteschlangenname für Transform-Jobs | `transforms` |
| `OGI_TRANSFORM_TIMEOUT` | Zeitüberschreitung pro Transform-Job in Sekunden | `300` |
| `OGI_AGENT_WORKER_POLL_INTERVAL_SEC` | Abfrageintervall für den AI Investigator Worker | `2.0` |
| `OGI_AGENT_CLAIM_TIMEOUT_SEC` | Zeitüberschreitung für veraltete Claims bei der Wiederherstellung von AI Investigator-Schritten | `120` |
| `OGI_AUTO_RUN_MIGRATIONS` | Automatisches Ausführen von Alembic beim lokalen Nicht-SQLite-App-Start | `true` |
| `OGI_RUN_DB_MIGRATIONS` | Datenbankmigrationen im Container-Entrypoint ausführen | `false` |
| `OGI_DB_MIGRATION_RETRIES` | Anzahl der Wiederholungsversuche bei Migrationen im Entrypoint | `30` |
| `OGI_DB_MIGRATION_DELAY_SECONDS` | Verzögerung zwischen den Wiederholungsversuchen der Migrationen im Entrypoint | `2` |
| `OGI_PLUGIN_DIRS` | Plugin-Suchverzeichnisse | `plugins,../plugins` |
| `OGI_DEPLOYMENT_MODE` | Bereitstellungsmodus (`self-hosted` oder `cloud`) | `self-hosted` |
| `OGI_CLOUD_BILLING_ENABLED` | Cloud-exklusive Abrechnung für Supporter und Abklingzeit-Erzwingung für Transform-Vorgänge aktivieren | `false` |
| `OGI_FREE_TRANSFORM_COOLDOWN_SECONDS` | Abklingzeit zwischen kostenlosen Cloud-Benutzer-Transformator-Läufen | `1800` |
| `OGI_PAID_TRANSFORM_COOLDOWN_SECONDS` | Abklingzeit zwischen kostenpflichtigen Cloud-Benutzer-Transformator-Läufen | `0` |
| `OGI_STRIPE_SECRET_KEY` | Serverseitiger Stripe-Geheimschlüssel für Checkout- und Portal-Sitzungen | nicht gesetzt |
| `OGI_STRIPE_WEBHOOK_SECRET` | Stripe-Webhook-Signaturgeheimnis | nicht gesetzt |
| `OGI_STRIPE_SUPPORTER_PRICE_ID` | Wiederkehrende Stripe-Preis-ID für den Supporter-Tarif | nicht gesetzt |
| `OGI_STRIPE_SUPPORTER_AMOUNT_CENTS` | Anzeigebetrag für den Supporter-Tarif | `300` |
| `OGI_STRIPE_SUPPORTER_CURRENCY` | Anzeigewährung für den Supporter-Tarif | `usd` |
| `OGI_BILLING_SUCCESS_URL` | Optionale Stripe-Checkout-Erfolgsweiterleitung | aus Anfrage abgeleitet |
| `OGI_BILLING_CANCEL_URL` | Optionale Stripe-Checkout-Abbruchweiterleitung | aus Anfrage abgeleitet |
| `OGI_BILLING_PORTAL_RETURN_URL` | Optionale Stripe-Abrechnungsportal-Rückgabe-URL | aus Anfrage abgeleitet |
| `OGI_REGISTRY_REPO` | Transform-Registry-GitHub-Repo | `opengraphintel/ogi-transforms` |
| `OGI_REGISTRY_CACHE_TTL` | Cache-TTL der Registry in Sekunden | `3600` |
| `OGI_TRANSFORM_SETTING_MAX_OVERRIDES` | Optionales globales Maximum an Überschreibungen für Transform-Einstellungen | leer |
| `OGI_GITHUB_TOKEN` | Optionales GitHub-Token für Registry/API-Ratenbegrenzungen | nicht gesetzt |
| `OGI_SUPABASE_URL` | Supabase-Projekt-URL | nicht gesetzt |
| `OGI_SUPABASE_ANON_KEY` | Supabase-anonymer/öffentlicher Schlüssel | nicht gesetzt |
| `OGI_SUPABASE_SERVICE_ROLE_KEY` | Supabase-Dienstrollenschlüssel | nicht gesetzt |
| `OGI_SUPABASE_JWT_SECRET` | Supabase-JWT-Geheimnis | nicht gesetzt |
| `OGI_SUPABASE_REDIRECT_URL` | Weiterleitungs-URL für Frontend-Authentifizierungsabläufe | nicht gesetzt |
| `OGI_ADMIN_EMAILS` | Admin-Benutzer für Registry-/Plugin-Verwaltung | nicht gesetzt |
| `OGI_TELEMETRY_ENABLED` | Installationsebene-Telemetrie aktivieren oder deaktivieren | `true` |
| `OGI_TELEMETRY_LEVEL` | Telemetrieebene (`basic` oder `full`) | `full` |
| `OGI_API_KEY_ENCRYPTION_KEY` | Fernet-Schlüssel für verschlüsselte API-Schlüsselspeicherung | nicht gesetzt, aber dringend empfohlen |
| `OGI_API_KEY_INJECTION_ALLOW_COMMUNITY_PLUGINS` | Community-Plugins erlauben, gespeicherte API-Schlüssel zu erhalten | `true` |
| `OGI_API_KEY_INJECTION_TRUSTED_TIERS_ONLY` | Injektion gespeicherter Schlüssel auf vertrauenswürdige Stufen beschränken | `false` |
| `OGI_API_KEY_INJECTION_ALLOWED_TIERS` | Zulässige Stufen, wenn der Modus „nur vertrauenswürdig“ aktiviert ist | `official,verified` |
| `OGI_API_KEY_SERVICE_ALLOWLIST` | Optionale zulässige Dienste für die Injektion gespeicherter Schlüssel | leer |
| `OGI_API_KEY_SERVICE_BLOCKLIST` | Optionale blockierte Dienste für die Injektion gespeicherter Schlüssel | leer |
| `OGI_LLM_PROVIDER` | Standard-Fallback des AI Investigator-Anbieters | `openai` |
| `OGI_LLM_MODEL` | Standard-Fallback des AI Investigator-Modells | `gpt-4.1-mini` |
| `OGI_EXPOSE_ERROR_DETAILS` | Interne Details in 500-Antworten einbeziehen | `false` |
| `OGI_SANDBOX_ENABLED` | Sandbox-Ausführungsmodus aktivieren | `false` |
| `OGI_SANDBOX_TIMEOUT` | Sandbox-Zeitüberschreitung in Sekunden | `30` |
| `OGI_SANDBOX_MEMORY_MB` | Sandbox-Speicherbegrenzung in MB | `256` |
| `OGI_SANDBOX_ALLOWED_TIERS` | Zulässige Stufen im Cloud-Sandbox-Modus | `official,verified` |
| `OGI_BOOT_REQUIREMENTS_ENABLE` | Installieren von Plugin-Abhängigkeiten beim Start aktivieren | `true` |
| `OGI_BOOT_REQUIREMENTS_FILE` | Pfad zur Datei mit den Startanforderungen | `/app/plugins/requirements.txt` |
| `OGI_BOOT_LOCK_FILE` | Pfad zur Start-Sperrdatei | `/app/plugins/ogi-lock.json` |
| `OGI_BOOT_REQUIREMENTS_STRICT` | Start fehlschlagen lassen, wenn Plugin-Anforderungen fehlen | `false` |
| `OGI_BOOT_REQUIREMENTS_CACHE_DIR` | Temporäres/Cache-Verzeichnis für die Generierung der Startanforderungen | `/tmp/ogi-boot` |
| `OGI_FRONTEND_PORT` | Lokales Docker-Frontend-Port-Mapping | `3000` |
| `OGI_IMAGE_TAG` | Produktions-Image-Tag für Compose/Coolify-ähnliche Bereitstellungen | `latest` |
| `OGI_BACKEND_IMAGE` | Optionale Überschreibung des Backend-Images | `ghcr.io/khashashin/ogi-backend` |
| `OGI_WORKER_IMAGE` | Optionale Überschreibung des Worker-Images. Standardmäßig Backend-Image, da Worker und Backend denselben Image-Build teilen. | `ghcr.io/khashashin/ogi-backend` |
| `OGI_FRONTEND_IMAGE` | Optionale Überschreibung des Frontend-Images | `ghcr.io/khashashin/ogi-frontend` |
| `OGI_CLI_BEARER_TOKEN` | Optionales CLI-Bearer-Token für authentifizierte Backends | nicht gesetzt |
Die vollständige Liste finden Sie in [`.env.example`](https://github.com/khashashin/ogi/blob/HEAD/.env.example).
</details>
## Entwicklung
### Ausführen von Tests```bash
# Backend
cd backend
OGI_DB_PATH=":memory:" OGI_USE_SQLITE=true uv run pytest
# Frontend
cd frontend
pnpm test
Linting & Typüberprüfung```bash
Backend
cd backend uv run ruff check # Linting uv run mypy # Type checking
Frontend
cd frontend pnpm lint # ESLint
### CI Pipeline
Der [CI-Workflow](https://github.com/khashashin/ogi/blob/HEAD/.github/workflows/ci.yml) läuft bei jedem Pull-Request:
- **Backend:** ruff lint, mypy type check, pytest
- **Frontend:** vitest, eslint, vite build
## Mitwirken
PRs willkommen! Wenn du einen Fehler findest oder eine Idee hast, [eröffne ein Issue](https://github.com/khashashin/ogi/issues).
Für neue Transforms trage zu [ogi-transforms](https://github.com/opengraphintel/ogi-transforms) bei.
### Erste Schritte
1. Forke das Repository
2. Erstelle einen Feature-Branch (`git checkout -b feature/my-feature`)
3. Nimm deine Änderungen vor
4. Führe Tests und Linting aus
5. Reiche einen Pull-Request ein
## Rechtmäßige und verantwortungsvolle Nutzung
OGI ist ein universelles OSINT- und Graphenanalyse-Tool. **Du bist allein dafür verantwortlich, wie du es verwendest.** Siehe [LEGAL.md](https://github.com/khashashin/ogi/blob/HEAD/LEGAL.md) für den vollständigen rechtlichen Hinweis.
- **Halte die Nutzungsbedingungen Dritter ein.** Transforms, die externe Dienste abfragen (DNS, WHOIS, Web Scraping, Benutzernamensuche usw.), müssen gemäß den AGB dieser Dienste verwendet werden. Automatisierte oder massenhafte Abfragen von Websites, die dies verbieten, können deren Bedingungen verletzen.
- **Respektiere Datenschutzgesetze.** Wenn du in der EU bist oder Daten über EU-Bürger verarbeitest, gilt die DSGVO für dich als Verantwortlicher. Das Erheben, Speichern oder Verarbeiten personenbezogener Daten (Namen, E-Mail-Adressen, IP-Adressen usw.) erfordert eine Rechtsgrundlage. OGI selbst speichert keine Daten über deine lokale Instanz hinaus – du bist verantwortlich für das, was du sammelst und aufbewahrst.
- **Nur für rechtmäßige Zwecke verwenden.** OGI ist für legitime Sicherheitsforschung, Untersuchungen, Bedrohungsanalyse und Bildungszwecke gedacht. Verwende es nicht, um Personen zu belästigen, unbefugten Zugriff durchzuführen oder geltendes Recht zu verletzen.
- **Dateiformat-Kompatibilität.** OGI unterstützt den Import des MTGX-Graphenaustauschformats. Dies dient ausschließlich der Dateninteroperabilität und impliziert keine Verbindung zu oder Billigung durch die Hersteller von Tools, die dieses Format verwenden.
> **Haftungsausschluss:** OGI wird "wie besehen" ohne jegliche Gewährleistung bereitgestellt. Die Autoren haften nicht für Missbrauch oder Schäden, die aus der Nutzung dieser Software entstehen.
## Lizenz
Dieses Projekt ist unter der [GNU Affero General Public License v3.0](https://github.com/khashashin/ogi/blob/HEAD/LICENSE) lizenziert.
---
<div align="center">
**[Fehler melden](https://github.com/khashashin/ogi/issues) • [Funktion anfragen](https://github.com/khashashin/ogi/issues) • [Diskussionen](https://github.com/opengraphintel/ogi-transforms/discussions)**
Mit 💜 gemacht von der OGI-Community
</div>