Doccano

Enables creation of annotation projects supporting text classification, sequence labeling (NER), and sequence-to-sequence tasks through a unified project management interface. Each project defines its own label taxonomy and annotation type, with the backend Django REST API enforcing schema validation and persisting annotations to SQLite or PostgreSQL. The Vue.js frontend renders task-specific annotation interfaces dynamically based on project configuration, allowing teams to switch between annotation paradigms within the same deployment.

Implements multi-user annotation workflows through Django's authentication system with role-based access control (RBAC) at the project level. Users are assigned roles (admin, annotator, viewer) with granular permissions enforced in the REST API layer before data access. The backend tracks annotation ownership, supports concurrent editing without locking, and maintains audit trails of who annotated what. The Vue.js frontend respects role permissions in the UI, hiding actions unavailable to the current user's role.

Provides Docker Compose configuration for single-command deployment of Doccano with all dependencies (Django backend, Vue.js frontend, PostgreSQL, Redis). Environment variables control database connection, secret keys, allowed hosts, and feature flags. The Dockerfile uses multi-stage builds to minimize image size. Supports both development (with hot-reload) and production (with gunicorn) configurations. Pre-built images are published to Docker Hub, eliminating build time.

Allows administrators to clone existing projects (including label schema, annotation guidelines, and UI configuration) to create new projects without manual reconfiguration. Cloning copies project metadata but not annotations, enabling rapid setup of similar projects. Supports exporting project configuration as a template file and importing it into other Doccano instances. Templates are JSON files containing label definitions, UI settings, and guidelines.

Supports annotation in multiple languages including right-to-left (RTL) languages (Arabic, Hebrew, Persian) with proper Unicode text handling and bidirectional text rendering. The frontend uses CSS flexbox with direction properties to render RTL text correctly, while the backend stores all text as UTF-8 without language-specific processing. Language selection is per-project, affecting UI language and text rendering direction.

Processes bulk data imports through a Celery task queue that handles CSV, JSON, JSONL, and other formats without blocking the web interface. The backend detects file format, validates against project schema (ensuring required text fields exist), and creates Example records in batches. Large imports are chunked to avoid memory exhaustion, with progress tracking via Celery task IDs. Failed rows are logged separately, allowing users to retry or inspect errors without re-importing successful records.

Exports annotated datasets in multiple formats (JSON, JSONL, CSV, CoNLL for sequence labeling) through a Django REST endpoint that queries the database, applies user-specified filters (by label, annotator, status), and serializes annotations with metadata. Export jobs can be async for large datasets, returning a download URL. The serialization layer handles format-specific transformations: CoNLL format converts span annotations to BIO tags, CSV flattens nested structures, JSONL preserves full annotation objects.

Integrates with external ML services (OpenAI, Hugging Face, custom REST APIs) to pre-label examples before human annotation. Users configure auto-labeling via a template system that specifies request format, response parsing, and label mapping. The backend sends text to the external service, parses the response, and creates annotations programmatically. Supports both batch pre-labeling (all examples at once) and on-demand labeling (per-example). Failed requests are retried with exponential backoff; results are cached to avoid duplicate API calls.

Distributes examples to annotators using configurable sampling strategies (sequential, random, stratified by label) to ensure balanced workload and coverage. The backend tracks assignment state (unassigned, assigned, completed) per annotator and prevents double-assignment. Supports batch assignment (assign N examples to annotator) and dynamic assignment (assign next unassigned example on-demand). The Vue.js frontend shows annotators their assigned examples in a queue, with progress tracking.

Exposes full Doccano functionality through a Django REST Framework API with endpoints for creating projects, uploading data, retrieving annotations, and managing users. All operations that can be done in the UI are available via HTTP endpoints with JSON request/response bodies. The API uses token-based authentication (JWT or session tokens) and enforces the same RBAC as the UI. Supports pagination for large result sets and filtering by query parameters. API documentation is auto-generated via drf-spectacular (OpenAPI/Swagger).

Provides a Vue.js frontend that supports annotation in 20+ languages with proper right-to-left (RTL) text rendering for Arabic, Hebrew, and Persian. The UI dynamically switches text direction and font rendering based on detected language. Character-set support includes CJK (Chinese, Japanese, Korean), Devanagari, and other non-Latin scripts. Language is set per-project and enforced in the annotation interface, with translations for UI elements (labels, buttons, help text) provided via i18n framework.

Allows project administrators to customize the annotation interface without code by configuring display options (show/hide fields, reorder labels, set keyboard shortcuts) through the Django admin or API. Configuration is stored per-project and applied dynamically in the Vue.js frontend. Supports task-specific customizations: text classification can show labels as buttons or dropdown, sequence labeling can show span highlighting or tag list, etc. Changes apply immediately to all annotators without redeployment.

Provides built-in metrics for measuring annotation quality through inter-annotator agreement (IAA) calculations. Supports Cohen's Kappa for binary classification, Fleiss' Kappa for multi-class, and Krippendorff's Alpha for sequence labeling. Metrics are computed on overlapping annotations (examples assigned to multiple annotators) and displayed in the admin dashboard. The backend computes metrics on-demand via a Celery task, caching results for performance. Supports filtering by label, date range, and annotator pair.