How jerlendds/osintbuddy works
Key Components
• Frontend:
– Built with React/TypeScript (located in the “frontend” directory).
– Contains multiple UI routes, React components, and uses Tailwind, module federation, and other modern web technologies.
– Connects to the backend API via HTTP requests.
• Backend:
– Located in “backend/app/app”. It is a Python-based API (likely using FastAPI) serving versioned REST endpoints (api_v1) for operations such as account management, entity processing, graphs, login, scans, and more.
– Contains modules for dependencies, configuration, and CRUD operations.
– Uses Alembic migrations to handle the database schema changes.
– Integrates asynchronous processing through Celery workers (files like “celeryworker_pre_start.py”, “worker.py”).
– Handles business logic, email template processing, locales, and session management.
• Database & Graph Storage:
– The backend uses Alembic for migrations which implies a relational database. Also, based on the README, there is an ongoing refactor from JanusGraph (and its dependent services such as Solr and ScyllaDB) toward using Apache Age on PostgreSQL.
• Authentication & External Services:
– Casdoor is integrated for authentication (files like “casdoor.py” in core indicate this).
– External services such as the authentication portal, as well as potential data-fetching and monitoring endpoints, should be noted.
• Orchestration & Deployment:
– The “launcher” script provides Docker compose commands to bootstrap and manage the entire stack.
– Several Dockerfiles (backend/backend.Dockerfile, worker.Dockerfile) indicate containerized deployment.
– The “ob” directory contains environment configurations, integration scripts (for JanusGraph, SeaweedFS), and other orchestration artifacts.
– Represent Docker containers (or services) such as the API backend container, frontend container, worker container, and supporting data services.
• Plugin System:
– OSINTBuddy is designed to allow Python developers to make plugins (see references to “osintbuddy-plugins”).
Relationships and Interactions
• A connection between the Backend and the Casdoor authentication service for token validation and user login functionality.
• Optionally, show connections to external monitoring or email services if applicable.
Architectural Patterns and Technologies
• Separation of concerns:
– Frontend (UI and routing)
– Backend API logic (versioned endpoints)
– Data persistence (relational/graph storage via PostgreSQL/Apache Age suite)
– Asynchronous processing (via Celery workers).
• Mention that the microservices or modular approach (such as plugin extensibility, API versioning, and potential container orchestration) is central to the architecture.
• Dependencies such as FastAPI, Alembic, Celery in the backend and React with module federation on the frontend.
– Plugin System: a component labeled “Plugin Integrations” linking to the backend.
– Frontend → Backend API (show “HTTP Requests / REST API”)
– Backend → Database (show “CRUD, Graph Queries”)
– Backend → Celery Worker (for async tasks)
– Backend ↔ Casdoor (for authentication flows)
• Adding notes or annotations next to components that highlight future architectural changes – such as the transition from JanusGraph to Apache Age.
Final Reminder
• As many details as possible without overcomplicating—the goal is to clearly represent all essential architectural elements.
• Every component and its interactions are represented with clarity so that any new contributor or stakeholder can understand how the system is organized and how data flows throughout.