ogi v0.8.0
Framework de Análise de Links Open Source e OSINT
OpenGraph Intel (OGI)
Framework de análise de links visuais e OSINT de código aberto. Gratuito, auto-hospedável e orientado pela comunidade.
Recursos • Capturas de Tela • Início Rápido • Docker • Transform Hub • Arquitetura • Contribuição
Aviso: Este projeto está em evolução ativa. Possui capacidades centrais sólidas e cobertura de testes, e continuamos a melhorar a documentação, o fortalecimento e a profundidade dos recursos a cada versão. Contribuições, relatórios de bugs e feedbacks são muito bem-vindos.
Recursos
- Investigação visual em grafo — arraste e solte entidades, explore conexões interativamente
- Mais de 20 transformações integradas — DNS, WHOIS, certificados SSL, geolocalização, enriquecimento web/e-mail/hash/social e mais
- Transform Hub — navegue e instale transformações da comunidade a partir do registro
- Investigador IA — investigações agênticas orientadas por prompts que planejam execuções de transformações, transmitem progresso ao vivo e resumem descobertas com auditabilidade
- Importar / Exportar — importação nos formatos JSON, CSV, GraphML e MTGX
- Análise de grafos — centralidade, detecção de comunidades, caminhos mais curtos
- Colaboração em tempo real — projetos, compartilhamento e sincronização ao vivo via Supabase Realtime
- Trabalhos assíncronos de transformação — fila Redis/RQ com atualizações de progresso via WebSocket
- Sistema de plugins — descoberta de plugins baseada em diretórios com manifestos YAML
- Ferramenta CLI — pesquise, instale e gerencie transformações a partir do terminal
- Executa em qualquer lugar — modo SQLite local (zero configuração) ou PostgreSQL + Supabase para configurações em equipe/nuvem
- Pronto para Docker — implantação com um comando com
docker compose up
Capturas de Tela
| Investigação em Grafo | Enriquecimento de Entidade |
|---|---|
 |  |
| Transform Hub | Exportar/Importar |
|---|---|
 |  |
Início Rápido
Pré-requisitos
Backend```bash
cd backend uv sync uv run uvicorn ogi.main:app --reload
A API estará disponível em `http://localhost:8000`.
Para execução local de transformação, o Redis e o worker de transformação também devem estar em execução. Apenas o Redis não é suficiente.
Iniciar Redis:```bash
docker run -d --name ogi-redis -p 6379:6379 redis:7-alpine
Inicie o worker de transformação em um segundo terminal:```bash cd backend uv run python -m ogi.worker.run_worker
Se vir `Job queue not available` ou `Redis not available`, verifique que:
- `OGI_REDIS_URL` aponta para `redis://localhost:6379/0` para execuções locais baseadas no host
- o backend foi reiniciado após o Redis estar disponível
- o processo worker separado está em execução
- não está a usar o nome de host exclusivo do Docker `redis` fora do Docker Compose
Se executar o backend contra PostgreSQL (`OGI_USE_SQLITE=false`), a inicialização aplicará automaticamente as migrações do Alembic antes de servir pedidos. As implantações Docker fazem o mesmo no ponto de entrada do container do backend.
As execuções do AI Investigator são processadas por outro worker separado:```bash
cd backend
uv run python -m ogi.agent.run_worker
Front-end```bash
cd frontend pnpm install pnpm dev
Abra http://localhost:5173. Só isso.
### Investigador de IA
O Investigador de IA é um fluxo de trabalho opcional apoiado por provedor que pode planejar sequências de transformação, solicitar aprovações e resumir o progresso da investigação dentro do espaço de trabalho.
- Abra a aba `Investigador de IA` dentro de um projeto
- Configure um provedor e modelo no diálogo de configurações do investigador
- Armazene chaves de API do provedor em `API Keys`
- Execute o processo separado `agent-worker` junto com o backend
A implementação atual suporta configuração de provedor por usuário e um worker dedicado que executa etapas de investigação independentemente do servidor principal da API.
### CLI
Duas formas suportadas de executar a CLI:
**Recomendado** (sem necessidade de ativação):```bash
cd backend
uv sync
uv run ogi --help
Ambiente virtual ativado (comando ogi simples):```bash
cd backend
uv venv
PowerShell:
..venv\Scripts\Activate.ps1 uv pip install -e . ogi --help
## Docker
### Desenvolvimento```bash
cp .env.example .env
docker compose up
Produção
Utilize as imagens GHCR pré-construídas.
Importante: docker-compose.prod.yml requer um banco de dados PostgreSQL externo. Ele não inclui um serviço db.
Se você quiser a stack Docker local all-in-one com Postgres e Redis integrados, use:```bash docker compose up -d
Use o arquivo compose de produção apenas quando você já tiver uma instância PostgreSQL acessível e tiver definido `OGI_DATABASE_URL` de acordo:```bash
docker compose -f docker-compose.prod.yml pull
docker compose -f docker-compose.prod.yml up -d
Defina OGI_IMAGE_TAG no .env para fixar uma tag de imagem de lançamento específica (ex.: v0.2.6). O padrão é latest.
Hetzner Cloud
Novos utilizadores Hetzner podem usar o primeiro link para se inscrever com créditos Hetzner Cloud. É um link de referência, então o mantenedor do OGI também pode receber créditos Hetzner Cloud se a referência se qualificar. Depois de criar um servidor, use os comandos de implantação Docker acima para executar o OGI.
Limites de transformação configuráveis
OGI vem com valores máximos sensíveis por transformação para coisas como max_results, max_links, max_urls e max_content_chars, mas esses limites agora são centralmente substituíveis para que implantações em nuvem possam impô-los sem codificar limites locais.
Use OGI_TRANSFORM_SETTING_MAX_OVERRIDES no .env:```env
OGI_TRANSFORM_SETTING_MAX_OVERRIDES=max_results=50,max_urls=25,max_links=40,max_content_chars=20000
Para remover limites específicos em uma implantação local-first:```env
OGI_TRANSFORM_SETTING_MAX_OVERRIDES=max_results=none,max_urls=none,max_links=none,max_content_chars=none
A substituição é indexada pelo nome da configuração de transformação e aplica-se a transformações integradas e plugins da comunidade que usam a base/runtime compartilhada de transformação do OGI.
Instância hospedada na nuvem e plano Supporter
A versão hospedada na nuvem em ogi.khas.app foi inicialmente construída para que os usuários pudessem experimentar o OGI rapidamente antes de decidir se auto-hospedá-lo. Desde então, tornou-se a forma mais popular de usar o projeto, com mais de 350 usuários ativos na nuvem.
Esse uso também aumentou os custos de infraestrutura para este projeto paralelo. O repositório, portanto, inclui uma assinatura Supporter exclusiva da nuvem e um sistema de resfriamento de execução de transformação. Na instância pública da nuvem, usuários gratuitos podem ser limitados por um tempo limite entre execuções de transformação, enquanto usuários Supporter podem assinar por um simbólico USD 3/mês para ajudar a cobrir os custos do Supabase e VPS.
As assinaturas Supporter podem ser canceladas a partir dos controles de faturamento do perfil ou do portal de faturamento do Stripe. O cancelamento interrompe o faturamento futuro, mas os períodos de assinatura pagos não são reembolsados ou rateados.
Este código de faturamento é intencionalmente protegido por configuração: só tem efeito quando OGI_DEPLOYMENT_MODE=cloud e OGI_CLOUD_BILLING_ENABLED=true. Implantações auto-hospedadas devem manter o faturamento desativado e não devem ver nenhum comportamento de faturamento ou paywall.
Telemetria
OGI inclui telemetria de produto a nível de instalação destinada a nos ajudar a entender o uso real, especialmente em implantações auto-hospedadas.
OGI_TELEMETRY_ENABLED=trueativa a coleta de telemetriaOGI_TELEMETRY_LEVEL=fullé o nível de coleta padrão- defina
OGI_TELEMETRY_ENABLED=falsepara desativar completamente a telemetria - defina
OGI_TELEMETRY_LEVEL=basicpara reduzir o que é enviado
basic envia:
- versão do OGI
- um ping diário de instalação ativa
full adicionalmente envia:
- data de criação da instância
- contagens agregadas de projetos, entidades, arestas, execuções de transformação, execuções de investigador e usuários ativos para o período
- transformações instaladas com suas versões
A telemetria foi projetada para evitar o envio de conteúdos de grafo, valores de entidade, chaves de API, prompts ou outros dados de investigação. Os detalhes da política atual também são publicados na Política de Privacidade.
Serviços de Compose de Desenvolvimento
| Serviço | Descrição | Porta |
|---|---|---|
backend | Servidor de aplicação FastAPI | 8000 |
worker | Trabalhador de tarefas assíncrono RQ | - |
agent-worker | Trabalhador do Investigador de IA | - |
frontend | Aplicação React servida via nginx | 80 |
db | PostgreSQL 16 | 5432 |
redis | Redis 7 (fila de tarefas) | 6379 |
Serviços de Compose de Produção
| Serviço | Descrição | Porta |
|---|---|---|
backend | Servidor de aplicação FastAPI | 8000 |
worker | Trabalhador de tarefas assíncrono RQ | - |
agent-worker | Trabalhador do Investigador de IA | - |
frontend | Aplicação React servida via nginx | 80 |
redis | Redis 7 (fila de tarefas) | 6379 |
docker-compose.prod.yml espera um banco de dados PostgreSQL externo via OGI_DATABASE_URL.
Dependências de plugins no momento da inicialização
Se você usa imagens pré-construídas e um plugin precisa de bibliotecas Python extras, o OGI instala as dependências do plugin na inicialização do contêiner a partir de:
plugins/requirements.txt(preferido), ou- requisitos gerados automaticamente derivados de
plugins/ogi-lock.jsonquandorequirements.txtestá ausente.
Variáveis de ambiente:
| Variável | Padrão | Descrição |
|---|---|---|
OGI_BOOT_REQUIREMENTS_ENABLE | true | Ativar/desativar instalação na inicialização |
OGI_BOOT_REQUIREMENTS_FILE | /app/plugins/requirements.txt | Caminho para o arquivo de requisitos |
OGI_BOOT_LOCK_FILE | /app/plugins/ogi-lock.json | Caminho para o arquivo de bloqueio |
OGI_BOOT_REQUIREMENTS_STRICT | false | Falhar na inicialização se requisitos ausentes |
OGI_BOOT_REQUIREMENTS_CACHE_DIR | /tmp/ogi-boot | Diretório temporário/cache para requisitos gerados |
Hub de Transformações
OpenGraph Intel possui um mercado de transformações integrado. Navegue, instale e gerencie transformações a partir do registro da comunidade.
Nota de segurança: Plugins que exigem chaves de API devem ser tratados como código privilegiado. Se um plugin pode acessar seus segredos e fazer requisições de rede de saída, ele pode usar indevidamente ou exfiltrar esses segredos. Revise o nível de confiança, permissões e serviços necessários antes de instalar ou executar plugins de terceiros.```bash
Search for transforms
uv run ogi transform search dns
Install a transform
uv run ogi transform install shodan-host-lookup
### Categorias de Transformação Integradas
| Categoria | Exemplos |
| ---------- | ------------------------------------- |
| DNS | Registos A, AAAA, MX, NS, CNAME |
| IP & ASN | GeoIP, IP reverso, info ASN |
| SSL/TLS | Transparência de certificados, SSL labs|
| Email | Validação de servidor de correio, verificações de violações |
| Web | WHOIS, informações de domínio, extração web |
| Social | Enumeração de nomes de utilizador, perfis sociais |
| Hash | Consultas MD5, SHA1, SHA256 |
| Localização| Geocodificação, clima, dados ASN próximos |
### Tipos de Entidade Suportados
`Person` • `Username` • `Domain` • `IPAddress` • `EmailAddress` • `PhoneNumber` • `Organization` • `URL` • `SocialMedia` • `Hash` • `Document` • `Location` • `ASNumber` • `Network` • `MXRecord` • `NSRecord` • `Nameserver` • `SSLCertificate` • `Subdomain` • `HTTPHeader`
### Construindo as Suas Próprias Transformações
Quer construir as suas próprias? Veja o [guia de contribuição](https://github.com/opengraphintel/ogi-transforms/blob/main/CONTRIBUTING.md).
Se a sua transformação necessitar de credenciais de serviço externas, declare-as em `api_keys_required`. Não armazene segredos nas definições da transformação. A OGI gere essas credenciais em `API Keys`, e os plugins que utilizam segredos são considerados código privilegiado.
Se a sua transformação expuser definições limitadas como `max_results` ou `max_content_chars`, prefira nomes de definições estáveis em vez de nomes personalizados únicos, sempre que possível. A OGI pode substituir centralmente os valores máximos com `OGI_TRANSFORM_SETTING_MAX_OVERRIDES`, o que ajuda implementações em nuvem a impor limites, enquanto utilizadores locais podem removê-los.
Cada plugin é um diretório com um manifesto `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
Arquitetura
Pilha de Tecnologias
| Camada | Tecnologia |
|---|---|
| Backend | Python 3.14+, FastAPI, SQLModel, asyncpg / aiosqlite |
| Frontend | React 19, TypeScript 5.9, Sigma.js (graphology), Zustand, Tailwind CSS 4 |
| Banco de Dados | PostgreSQL 16 (principal) / SQLite (fallback local) |
| Autenticação & Tempo Real | Supabase Auth + JWT + Realtime (opcional em modo local) |
| Fila de Tarefas | Redis 7 + RQ (transformações assíncronas) |
| Runtime de IA | Worker de Investigação de IA apoiado por provedor com orquestração de transformação auditada |
| Gerenciadores de Pacotes | uv (backend), pnpm (frontend) |
| Implantação | Docker, nginx, GHCR |
Estrutura do Projeto```
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
### Configuração
OGI usa [pydantic-settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) com suporte a arquivos `.env`. As variáveis de runtime/backend são prefixadas com `OGI_`.
Configurações no estilo de lista aceitam:
- Arrays JSON, por exemplo `["plugins","../plugins"]`
- strings separadas por vírgulas, por exemplo `plugins,../plugins`
<details>
<summary><strong>Variáveis de ambiente principais</strong></summary>
| Variável | Descrição | Padrão |
| ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
| `OGI_APP_NAME` | Nome da aplicação | `OGI` |
| `OGI_HOST` | Host de bind do backend | `0.0.0.0` |
| `OGI_PORT` | Porta do backend | `8000` |
| `OGI_CORS_ORIGINS` | Origens frontend permitidas | `http://localhost:5173,http://localhost:3000` |
| `OGI_USE_SQLITE` | Usar SQLite em vez de PostgreSQL | `true` |
| `OGI_DB_PATH` | Caminho do arquivo do banco de dados SQLite | `ogi.db` |
| `OGI_DATABASE_URL` | String de conexão do PostgreSQL | `postgresql://postgres:postgres@localhost:5432/ogi` |
| `OGI_REDIS_URL` | String de conexão Redis para RQ/jobs | `redis://localhost:6379/0` |
| `OGI_RQ_QUEUE_NAME` | Nome da fila para transform jobs | `transforms` |
| `OGI_TRANSFORM_TIMEOUT` | Timeout por transform job em segundos | `300` |
| `OGI_AGENT_WORKER_POLL_INTERVAL_SEC` | Intervalo de poll para o worker do AI Investigator | `2.0` |
| `OGI_AGENT_CLAIM_TIMEOUT_SEC` | Timeout de claim para recuperação de etapa do AI Investigator | `120` |
| `OGI_AUTO_RUN_MIGRATIONS` | Executar migrações Alembic automaticamente na inicialização local não-SQLite | `true` |
| `OGI_RUN_DB_MIGRATIONS` | Executar migrações de banco de dados no entrypoint do contêiner | `false` |
| `OGI_DB_MIGRATION_RETRIES` | Número de tentativas de migração no entrypoint | `30` |
| `OGI_DB_MIGRATION_DELAY_SECONDS` | Atraso entre tentativas de migração no entrypoint | `2` |
| `OGI_PLUGIN_DIRS` | Diretórios de busca de plugins | `plugins,../plugins` |
| `OGI_DEPLOYMENT_MODE` | Modo de implantação (`self-hosted` ou `cloud`) | `self-hosted` |
| `OGI_CLOUD_BILLING_ENABLED` | Habilitar cobrança e cooldown de transform para usuários cloud | `false` |
| `OGI_FREE_TRANSFORM_COOLDOWN_SECONDS` | Cooldown entre execuções de transform para usuários gratuitos na nuvem | `1800` |
| `OGI_PAID_TRANSFORM_COOLDOWN_SECONDS` | Cooldown entre execuções de transform para usuários pagos na nuvem | `0` |
| `OGI_STRIPE_SECRET_KEY` | Chave secreta do lado do servidor Stripe para sessões de Checkout e portal | não definido |
| `OGI_STRIPE_WEBHOOK_SECRET` | Segredo de assinatura do webhook Stripe | não definido |
| `OGI_STRIPE_SUPPORTER_PRICE_ID` | ID de preço recorrente Stripe para o plano Supporter | não definido |
| `OGI_STRIPE_SUPPORTER_AMOUNT_CENTS` | Valor exibido para o plano Supporter | `300` |
| `OGI_STRIPE_SUPPORTER_CURRENCY` | Moeda exibida para o plano Supporter | `usd` |
| `OGI_BILLING_SUCCESS_URL` | Redirecionamento opcional de sucesso do Stripe Checkout | derivado da solicitação |
| `OGI_BILLING_CANCEL_URL` | Redirecionamento opcional de cancelamento do Stripe Checkout | derivado da solicitação |
| `OGI_BILLING_PORTAL_RETURN_URL` | URL de retorno opcional do portal de cobrança Stripe | derivado da solicitação |
| `OGI_REGISTRY_REPO` | Repositório GitHub do registry de transforms | `opengraphintel/ogi-transforms` |
| `OGI_REGISTRY_CACHE_TTL` | TTL do cache do registry em segundos | `3600` |
| `OGI_TRANSFORM_SETTING_MAX_OVERRIDES` | Mapa opcional de substituição global máxima para configurações de transform | vazio |
| `OGI_GITHUB_TOKEN` | Token GitHub opcional para limites de taxa do registry/API | não definido |
| `OGI_SUPABASE_URL` | URL do projeto Supabase | não definido |
| `OGI_SUPABASE_ANON_KEY` | Chave anônima/pública do Supabase | não definido |
| `OGI_SUPABASE_SERVICE_ROLE_KEY` | Chave de função de serviço do Supabase | não definido |
| `OGI_SUPABASE_JWT_SECRET` | Segredo JWT do Supabase | não definido |
| `OGI_SUPABASE_REDIRECT_URL` | URL de redirecionamento usada por fluxos de autenticação do frontend | não definido |
| `OGI_ADMIN_EMAILS` | Usuários admin para gerenciamento de registry/plugins | não definido |
| `OGI_TELEMETRY_ENABLED` | Habilitar ou desabilitar telemetria no nível de instalação | `true` |
| `OGI_TELEMETRY_LEVEL` | Nível de telemetria (`basic` ou `full`) | `full` |
| `OGI_API_KEY_ENCRYPTION_KEY` | Chave Fernet para armazenamento criptografado de chaves de API | não definido mas fortemente recomendado |
| `OGI_API_KEY_INJECTION_ALLOW_COMMUNITY_PLUGINS` | Permitir que plugins da comunidade recebam chaves de API armazenadas | `true` |
| `OGI_API_KEY_INJECTION_TRUSTED_TIERS_ONLY` | Restringir injeção de chave armazenada apenas a tiers confiáveis | `false` |
| `OGI_API_KEY_INJECTION_ALLOWED_TIERS` | Tiers permitidos quando o modo restrito a confiáveis está ativado | `official,verified` |
| `OGI_API_KEY_SERVICE_ALLOWLIST` | Lista de permissão opcional de serviços para injeção de chave armazenada | vazio |
| `OGI_API_KEY_SERVICE_BLOCKLIST` | Lista de bloqueio opcional de serviços para injeção de chave armazenada | vazio |
| `OGI_LLM_PROVIDER` | Fallback de provedor padrão do AI Investigator | `openai` |
| `OGI_LLM_MODEL` | Fallback de modelo padrão do AI Investigator | `gpt-4.1-mini` |
| `OGI_EXPOSE_ERROR_DETAILS` | Incluir detalhes internos em respostas 500 | `false` |
| `OGI_SANDBOX_ENABLED` | Habilitar modo de execução em sandbox | `false` |
| `OGI_SANDBOX_TIMEOUT` | Timeout do sandbox em segundos | `30` |
| `OGI_SANDBOX_MEMORY_MB` | Limite de memória do sandbox em MB | `256` |
| `OGI_SANDBOX_ALLOWED_TIERS` | Tiers permitidos no modo sandbox cloud | `official,verified` |
| `OGI_BOOT_REQUIREMENTS_ENABLE` | Habilitar instalação de dependências de plugins na inicialização | `true` |
| `OGI_BOOT_REQUIREMENTS_FILE` | Caminho do arquivo de requisitos de inicialização | `/app/plugins/requirements.txt` |
| `OGI_BOOT_LOCK_FILE` | Caminho do arquivo de lock de inicialização | `/app/plugins/ogi-lock.json` |
| `OGI_BOOT_REQUIREMENTS_STRICT` | Falhar na inicialização se dependências de plugins estiverem ausentes | `false` |
| `OGI_BOOT_REQUIREMENTS_CACHE_DIR` | Diretório temporário/cache para geração de requisitos de inicialização | `/tmp/ogi-boot` |
| `OGI_FRONTEND_PORT` | Mapeamento de porta do frontend Docker local | `3000` |
| `OGI_IMAGE_TAG` | Tag de imagem de produção para deploys com compose/Coolify | `latest` |
| `OGI_BACKEND_IMAGE` | Substituição opcional de imagem do backend | `ghcr.io/khashashin/ogi-backend` |
| `OGI_WORKER_IMAGE` | Substituição opcional de imagem do worker. Padrão para imagem do backend porque worker e backend compartilham a mesma build de imagem. | `ghcr.io/khashashin/ogi-backend` |
| `OGI_FRONTEND_IMAGE` | Substituição opcional de imagem do frontend | `ghcr.io/khashashin/ogi-frontend` |
| `OGI_CLI_BEARER_TOKEN` | Token bearer CLI opcional para backends com autenticação | não definido |
Veja [`.env.example`](https://github.com/khashashin/ogi/blob/HEAD/.env.example) para a lista completa.
</details>
## Desenvolvimento
### Executando Testes```bash
# Backend
cd backend
OGI_DB_PATH=":memory:" OGI_USE_SQLITE=true uv run pytest
# Frontend
cd frontend
pnpm test
Linting e Verificação de Tipos```bash
Backend
cd backend uv run ruff check # Linting uv run mypy # Type checking
Frontend
cd frontend pnpm lint # ESLint
### CI Pipeline
O [fluxo de CI](https://github.com/khashashin/ogi/blob/HEAD/.github/workflows/ci.yml) é executado em cada pull request:
- **Backend:** ruff lint, mypy type check, pytest
- **Frontend:** vitest, eslint, vite build
## Contribuindo
PRs são bem-vindos! Se encontrar um bug ou tiver uma ideia, [abra uma issue](https://github.com/khashashin/ogi/issues).
Para novas transformações, contribua com [ogi-transforms](https://github.com/opengraphintel/ogi-transforms).
### Primeiros Passos
1. Faça um fork do repositório
2. Crie um branch de funcionalidade (`git checkout -b feature/my-feature`)
3. Faça suas alterações
4. Execute testes e linting
5. Submeta um pull request
## Uso Legal e Responsável
OGI é uma ferramenta de análise de grafos e OSINT de uso geral. **Você é o único responsável por como a utiliza.** Consulte [LEGAL.md](https://github.com/khashashin/ogi/blob/HEAD/LEGAL.md) para o aviso legal completo.
- **Cumpra os Termos de Serviço de terceiros.** Transformações que consultam serviços externos (DNS, WHOIS, raspagem web, buscas de nomes de usuário, etc.) devem ser usadas de acordo com os Termos de Serviço desses serviços. Consultas automatizadas ou em massa de sites que as proíbem podem violar seus termos.
- **Respeite a lei de proteção de dados.** Se você está na UE ou processa dados sobre residentes da UE, o GDPR se aplica a você como controlador de dados. Coletar, armazenar ou processar dados pessoais (nomes, endereços de e-mail, endereços IP, etc.) requer uma base legal. OGI em si não armazena dados além da sua instância local — você é responsável pelo que coleta e retém.
- **Use apenas para fins lícitos.** OGI destina-se a pesquisa legítima de segurança, investigações, inteligência de ameaças e uso educacional. Não o utilize para assediar indivíduos, realizar acesso não autorizado ou violar a lei aplicável.
- **Compatibilidade de formato de arquivo.** OGI suporta importação do formato de intercâmbio de grafos MTGX. Isso é fornecido puramente para interoperabilidade de dados e não implica qualquer afiliação ou endosso pelos fabricantes de ferramentas que usam este formato.
> **Aviso:** OGI é fornecido "como está", sem garantia de qualquer tipo. Os autores não são responsáveis por qualquer uso indevido ou danos decorrentes do uso deste software.
## Licença
Este projeto está licenciado sob a [GNU Affero General Public License v3.0](https://github.com/khashashin/ogi/blob/HEAD/LICENSE).
---
<div align="center">
**[Report Bug](https://github.com/khashashin/ogi/issues) • [Request Feature](https://github.com/khashashin/ogi/issues) • [Discussions](https://github.com/opengraphintel/ogi-transforms/discussions)**
Feito com 💜 pela comunidade OGI
</div>