OpenQDA plug-in ideas and demand

[kadewe]

A very important part of the OpenQDA architecture is our plug-in system. These are server-side plug-ins which allow the community to extend the functionality of OpenQDA by writing smaller extensions ("plug-ins"). Therefore everyone can concentrate on implementing just a smaller part of the whole system. In our architecture we have identified 8 different phases of functionality within the system.

For further development we brainstormed and wrote down ideas for possible plug-ins, then extended this with rounds of brainstorming, selection, editing and improvement with Claude Opus 4.8 and Gemini). Feel free to add ideas to this! Also give feedback, which plug-in ideas are your most favorite ("killer feature" to switch to OpenQDA).

Import

• REFI Project Importer (in development): Full-scale import support for REFI projects.
• Social Media Channel Importer: A tool to import a channel from YouTube, Instagram, or TikTok (titles and descriptions of posts, transcripts of posts, comments).
• Digital Ethnography Web Scraper: A tool for network-based platforms (Reddit, Discord). It imports not just the raw text but transforms the nested discourse structures into a machine-readable yet visually traceable format, including the preservation of emojis and meme references, which are critical for sociolinguistic analyses.
• Messenger & Chat Export Importer: A parser for WhatsApp/Signal/Telegram exports (.txt/.zip) that preserves the conversation structure: speaker, timestamp, and media references are mapped as metadata, and every message becomes a codable unit.
• Survey Open-Response Importer: Import of open-ended responses from SoSci Survey, LimeSurvey, or Qualtrics/CSV, where each answer becomes a document (or a row) and closed-question variables travel along as attributes. This makes mixed-methods analyses (qualitative data grouped by quantitative characteristics) genuinely possible.

Export

• REFI Project Exporter (in development): Full-scale export support for REFI projects.
• FAIR Data Research Compendium Exporter: Packages the entire project (anonymized primary data, the codebook with definitions, selected memos, and the code tree) into a standardized RO-Crate (Research Object Crate). This format is machine-readable and can be published with all its metadata to repositories such as Zenodo or OSF with a single click, enabling true Open Science.
• Interactive Jupyter / HTML Codebook: Exports the analysis results not as a static PDF but as an interactive HTML report or an executable notebook. Reviewers or readers of a publication can dynamically filter code overlaps and read the quotes in context, which drastically increases methodological transparency.
• LLM Fine-Tuning Set Generator: Exports rigorously coded text segments in JSONL format (instruction-response pairs). This allows research groups to use their high-quality manual codings to train local, privacy-compliant language models (SLMs) on their specific category system.
• Publication-Ready Quote/Appendix Export: Selected coded segments are turned into a citable, pseudonymized appendix with stable segment IDs and code labels (LaTeX/DOCX/PDF), directly suitable as supplementary material for a journal.
• Codebook-as-Document: The codebook as a living document with definitions, inclusion/exclusion criteria, anchor examples, author, and version.
• FAIR Archival Package Export: Bundling into an archive-ready package (README, codebook, REFI-QDA, license, DOI-ready metadata) for deposit with Zenodo or Qualiservice.

Transformation

• Context-Aware Semantic Anonymization (LLM-based): A plugin that goes far beyond replacing proper names (Named Entity Recognition). It identifies relational and contextual identifiers (e.g., "the teacher who always brings his dog" or specific rare medical conditions combined with the place of residence) and proposes semantically equivalent but de-identifying substitutes.
• Multilingual Audio Alignment (Audio-to-Text Sync): When transcribing and translating non-native-language interviews, the plugin keeps the translated text exactly synchronized with the waveform of the original audio. This ensures that access to the original sociolinguistic nuance (prosody, hesitation) is not lost during text analysis.
• Automated Modality Translation (Voice-to-Emotion): Analyzes the audio track based on acoustic features (pitch, speaking rate, pauses) and automatically adds heuristic tags to the transcript for emotional states or phases of high cognitive load, which then serve as anchor points for deeper hermeneutic interpretation.
• LLM Pseudonymization with a Consistent Mapping Table: Names/places/organizations are detected and replaced, with the same person receiving the same pseudonym across documents. A secure, inspectable mapping table plus a human-in-the-loop review to increase consistency.
• Transcription Convention Converter: Conversion between notations (e.g., GAT2/cGAT into a smoothed reading version), normalization of speaker labels and timestamps, optional filler-word cleanup — switchable as a "verbatim" vs. "readable" layer.
• Parallel Translation Layer: LLM-/DeepL-assisted translation that keeps the original and the translation aligned side by side, so that coding can be done on both layers.
• OCR / Handwriting Transformation: Scannable field notes, historical sources, or handwritten documents are converted into codable text in a verifiable way.

Storage

• S3/MinIO Backend: Self-hosted object storage; the institution keeps the data on its own infrastructure.
• Nextcloud / Sciebo / WebDAV Backend: A plugin for deep integration into institutional cloud infrastructures. It enables fine-grained file locking at the segment level, so that several researchers can work on the same document simultaneously while the data demonstrably (GDPR-compliant) never leaves the university data center.
• WORM / Versioned Retention Layer: Write-once-read-many for audit-proof retention in line with ethics approval and retention periods, including a snapshot history.
• Git-Based Epistemic Version Control: Stores the QDA project as a local Git repository. This allows genuine branching for researchers. For example, Coder A can create a "branch" to try out an experimental category system. If it proves viable, it is merged into the main project via a "merge request" that is discussed within the team.
• End-to-End Encrypted Storage (Zero-Knowledge): For research with extremely vulnerable groups (e.g., whistleblowers, highly sensitive clinical data). The data is encrypted and decrypted locally in the client; only ciphertext reaches the server (and, optionally, decentralized storage such as IPFS). The key exists only in the client or is derived from a passphrase. Even server administrators cannot read the contents. Trade-off: server-side functions such as full-text/semantic search, aTrain transcription, and the LLM plugins are no longer available or must be moved into the client; collaborative team coding requires a key-sharing procedure (a project key encrypted with the members' public keys).
• Server-Side Encryption with an Institutional Key (Envelope Encryption/KMS): For especially sensitive data (health, vulnerable groups) with full data sovereignty for the institution. The data is stored encrypted; the master key remains in the institution's key management system/HSM and never leaves it. For processing, the data is transiently decrypted server-side. This reliably protects against stolen storage media or a compromised external storage provider, but not against the trusted server itself. Advantage: all server-side convenience and AI features remain usable.

Preparation (Exploration & Heuristics)

• Epistemic Network Extraction (LLM): Scans the document before coding and creates an initial, inductive graph of the actors and concepts that appear. This serves not as a finished codebook but as a "cognitive map" to help the researcher with theoretical sampling (Which concepts dominate? Which are missing?).
• Methodological Bias & Quality Checker: Analyzes the transcript with respect to interview conduct. For example, the tool calculates speaking shares (interviewer vs. interviewee) and flags passages with strongly suggestive questions (leading questions).
• Narrative Structure Segmentation: Uses NLP to automatically pre-structure long biographical interviews by narrative phases (e.g., following Labov & Waletzky: orientation, complication, evaluation, resolution) using color coding. This could facilitate a later sequence-analytic evaluation.
• LLM Re-Identification Scanner: Assesses the re-identification risk per document (rare combinations of characteristics, indirect identifiers, proper names missed by the anonymization) and assigns a risk score. Conceived as a QA gate that works together with the pseudonymizer from "Transformation": transform first, then check.
• Interview Structure Detector: Detects and labels speaker changes and the question-answer structure (interviewer vs. interviewee), so that one can later selectively code only the answers.
• Corpus Navigator with Auto Document Profiles: Generates a short abstract and core metadata for each document, so that teams can get an overview of a large corpus before coding and divide it up sensibly.

Coding

• AI-Assisted Peer Debriefing ("Devil's Advocate"): When a researcher assigns a segment to a code, a local LLM steps in and asks (on request): "Could this segment alternatively be interpreted as an expression of concept X?" This enforces the methodologically required constant comparative analysis (Grounded Theory) and prevents tunnel vision.
• (Semi-)Automatic Codebook Documentation: While coding, borderline cases can be marked (still belongs / no longer belongs), which can then be used for documentation in the codebook.
• Spatio-Temporal Video/VR Coding: Instead of merely marking timestamps in videos, this plugin allows drawing bounding boxes directly onto the moving image (or even 3D coordinates in VR recordings). This is central to analyzing nonverbal interactions or behavior in space (e.g., a teacher's movements in the classroom).
• Auto-Ethnographic Workflow Tracker: (Extends your idea of event-based memos): This plugin tracks in the background how coding is done. It registers long hesitation before assigning a code, frequent renaming of codes, or repeated rereading of a passage. From this metadata it automatically generates a memo about the researcher's analytical process, which drastically improves traceability.
• Event-Based Reflexive Memos: Triggerable via configurable events: code removed, codes merged, segment recoded by a colleague, disagreement detected → triggers a contextual memo dialog with an appropriate tag. Semi-automatic creation of a reflexivity journal as a complement to the audit trail.
• LLM Co-Coder with Provenance Logging: Suggests codes from the existing codebook for a segment (or new ones), which the person accepts/edits. Each code is marked as "AI-suggested" vs. "human-set" in order to document the use of AI tools (in contrast to black-box tools).
• Semantic/Dictionary Autocoding with Review Queue: Applies a code to all segments that match a query, word list, or semantic search, and places the hits in a review queue. Ideal for deductive passes and for catching "what was overlooked."
• Negotiated-Coding Disagreement Resolver: When two people code the same segment differently, a side-by-side comparison opens and the rationale for the agreement is saved.

Analysis

• Mixed-Methods Triangulation Matrix: Allows qualitative codes to be directly overlaid with metric variables (e.g., test scores, age cohorts). The plugin generates dynamic cross-tabulations: "Does the code frustration occur significantly more often in the cohort with low prior-knowledge scores?"
• Dynamic Concept Drift Analysis: Analyzes the semantic drift of a code over time. The plugin compares text passages coded with code A in week 1 with those from week 10. Methodologically, this helps answer the question: "Have we reached theoretical saturation, or is our definition of the code still changing?"
• Semantic Network Pathfinding (Latent Variables): A network analysis that shows not only direct code overlaps (co-occurrences) but also finds indirect paths: "Code A and code C almost never overlap, but both occur extremely often in the context of code B." This is a powerful tool for uncovering latent (hidden) phenomena.
• Intercoder Reliability Suite: Cohen's/Fleiss' kappa, Krippendorff's alpha, and percentage agreement, per code and per segment, with drill-down into the points of disagreement and an exportable report for the methods section.
• Query/Retrieval Engine: Boolean search plus proximity operators plus semantic search over coded data ("segments with code X near Y but not Z"), with savable queries.
• LLM-Assisted Thematic Synthesis: Clusters codes into candidate themes, summarizes all segments of a code, and proposes representative quotes as a curatable draft with full traceability back to the source segments.
• Saturation Tracker: Visualizes the point from which no new codes emerge across the corpus, as a decision aid for theoretical sampling in Grounded Theory.
• CAQDAS Standard Analyses: Based on a comparative systematic analysis, we have identified the 33 most common forms of analysis in CAQDAS, which can already be used as Python scripts with the export data from OpenQDA. These can be integrated.

Visualization

• Interactive Argumentation Map (Toulmin Model): Transfers coded segments not into a list but into a network-like structure of argumentation (claim, data, warrant). Researchers can visually reconstruct discourses from interviews and check them for contradictions via drag and drop.
• Code Evolution Time-Lapse (Sankey Diagram): (Builds on your idea of the timeline): An animated Sankey diagram showing how the codebook developed over the course of the project. You can see fluidly how 50 "open codes" were merged into 5 "axial codes." This is an invaluable visualization for the methods section of a publication to document the abstraction process.
• Immersive Topical Landscape (WebXR): Generates a three-dimensional topological map from the code frequencies and co-occurrences (mountains for dense concepts, valleys for rare ones). With WebXR support, researchers (e.g., in a team meeting with VR headsets or on screen) can literally "navigate through their data landscape" and explore spatial clusters.
• CAQDAS Standard Visualizations: Based on a comparative systematic analysis, we have identified the 33 most common forms of visualization in CAQDAS, which can already be used as Python scripts with the export data from OpenQDA. These can be integrated.

[Tobi-Adesoye]

Hardware-Accelerated Local SLM Execution Engine (Phase: Storage & Coding)

This is an incredible list of plug-in specifications, @kadewe! As an AI engineering and hardware acceleration specialist, my clear favorite for a "killer feature" is the LLM Fine-Tuning Set Generator combined with the AI-Assisted Peer Debriefing ("Devil's Advocate").

However, there is a fundamental infrastructure constraint that qualitative research teams face: Absolute Data Privacy (GDPR Compliance). Most institutional review boards (IRBs) strictly prohibit streaming raw, un-anonymized interview transcripts to commercial cloud APIs (OpenAI, Anthropic, etc.).

To make these advanced AI plug-ins viable for real-world research, OpenQDA needs a dedicated Hardware-Accelerated Local Compute Backend plug-in.

    Proposed Extension: `openqda-local-acceleration` (Storage/Coding Phase)

We can implement an ultra-efficient, local compute backend utilizing fused GPU kernels (via custom Triton/CUDA architectures). This allows universities to host small, highly specialized language models (like Llama-3-8B or Mistral-7B) on local hardware (even consumer-grade workstations or shared university clusters) without losing performance.

Key Structural Impact:

1. Zero-Leakage Execution Context: Full-text semantic search, context-aware pseudonymization, and the "Devil's Advocate" peer debriefing happen entirely on-premise.
2. SRAM-Resident Matrix Fusion: Standard transformer architectures often bottle memory (VRAM) during long transcript generation passes due to intermediate tensor allocation overhead. By deploying custom fused normalization and linear activation layers, we can safely prevent out-of-memory (OOM) errors during massive multi-document analyses.
3. Automated Hardware Autotuning: The plug-in can dynamically profile the host system's GPU architecture (from enterprise A100/H100 setups down to local developer setups), auto-selecting optimal warp dimensions and block sizes to guarantee high-throughput processing.

This would make OpenQDA the only open-source QDA software that natively scales specialized, secure local AI pipelines without violating strict institutional ethics criteria. I'd love to help scaffold the compilation wrappers for this if there's interest from the core team!

[kadewe]

Hi Tobi, this sounds very interesting for further investigations, as we already plan to use on-premise for planned LLM functionalities at university data centers. Right now we want to collect ideas such as yours as well as feedback/discussion from the community and in our co-creation workshops to find out which plug-ins to work on first. What frameworks would be used in such a potential plug-in?

[Tobi-Adesoye]

Hi Karsten, That sounds like a brilliant alignment. University on-premises infrastructure is exactly where memory-bandwidth bottlenecks and VRAM constraints hit hardest, making localized optimization incredibly impactful. To answer your question regarding the architectural stack, a potential hardware-accelerated plug-in would leverage the following framework layers: 1. *PyTorch Ecosystem Core:* The wrapper interface integrates directly as standard torch.nn.Module layer wrappers. This allows the plugin to drop seamlessly into existing open-source LLM runtimes (such as Hugging Face Transformers, vLLM, or Ollama workflows) without rewriting high-level application logic. 2. *OpenAI Triton Core:* For the accelerated compute paths, we utilize Triton to write custom, hardware-native fused GPU kernels. This allows us to fuse operation streams (like intermediate normalization and linear projections) directly inside SRAM registers, entirely eliminating the massive High Bandwidth Memory (HBM) read/write bottlenecks typical of traditional python execution passes. 3. *PyTorch SDPA (Scaled Dot-Product Attention):* By hooking directly into PyTorch's native attention dispatchers, the plug-in automatically scales to utilize FlashAttention-2 or Memory-Efficient Attention kernels under the hood depending on what hardware slices (e.g., NVIDIA Ampere/Hopper architectures) are active in the university cluster. 4. *Dynamic Hardware Fallbacks:* For development instances or data nodes lacking specialized GPU drivers, the plug-in automatically handles runtime detection, degrading gracefully to standard PyTorch CPU tensor emulation loops so that execution matrices never throw unhandled runtime faults. The baseline compilation wrappers are entirely open-source to maximize portability. For heavy, highly-scaled academic clusters requiring extreme multi-node throughput, specialized binary acceleration backends can also be mapped in. I would love to participate in or contribute data points to your upcoming co-creation workshops to see how we can best tailor these self-stabilizing layers for OpenQDA’s target profiles. Best regards, Tobi Adesoye

…

On Tue, Jun 9, 2026 at 9:46 AM Karsten D. Wolf ***@***.***> wrote: Hi Tobi, this sounds very interesting for further investigations, as we already plan to use on-premise for planned LLM functionalities at university data centers. Right now we want to collect ideas such as yours as well as feedback/discussion from the community and in our co-creation workshops to find out which plug-ins to work on first. What frameworks would be used in such a potential plug-in? — Reply to this email directly, view it on GitHub <#366?email_source=notifications&email_token=AQSPCWAVDO4ICAW2OPJOMNL467FHNA5CNFSNUABIM5UWIORPF5TWS5BNNB2WEL2ENFZWG5LTONUW63SDN5WW2ZLOOQXTCNZSGMZTSMJYUZZGKYLTN5XKOY3PNVWWK3TUUVSXMZLOOSWGM33PORSXEX3DNRUWG2Y#discussioncomment-17233918>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AQSPCWDAUOBSW7LMB2MCUWL467FHNAVCNFSM6AAAAACZ7JJIQWVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTOMRTGM4TCOA> . Triage notifications, keep track of coding agent tasks and review pull requests on the go with GitHub Mobile for iOS <https://github.com/notifications/mobile/ios/AQSPCWG2AXEMTF5DQKJULAD467FHNA5CNFSNUABIM5UWIORPF5TWS5BNNB2WEL2ENFZWG5LTONUW63SDN5WW2ZLOOQXTCNZSGMZTSMJYUZZGKYLTN5XKOY3PNVWWK3TUUVSXMZLOOSVGM33PORSXEX3JN5ZQ> and Android <https://github.com/notifications/mobile/android/AQSPCWF4MM2XBAB6AFRV2AL467FHNA5CNFSNUABIM5UWIORPF5TWS5BNNB2WEL2ENFZWG5LTONUW63SDN5WW2ZLOOQXTCNZSGMZTSMJYUZZGKYLTN5XKOY3PNVWWK3TUUVSXMZLOOSXGM33PORSXEX3BNZSHE33JMQ>. Download it today! You are receiving this because you commented.Message ID: ***@***.***>

[skremilija]

Hi Karsten and the team, thank you for this incredible list 👯 From my perspective as qual. researcher and as someone who teaches qualitative methods, the following functions would be superb.

The OCR / Handwriting Transformation plugin would probably be one of the most useful features for my own work. I still take a lot of ethnographic field notes by hand, and at the moment I spend far too much time converting them into a format that can actually be analyzed, which is very annoying. :D Being able to turn handwritten notes into codable text directly within OpenQDA would remove a major bottleneck!

From a teaching perspective, the Negotiated-Coding Disagreement Resolver would be fantastic. When students code the same material differently, the discussion about why they arrived at different interpretations is often where a lot of the learning happens. Having a structured way to compare coding decisions and document the rationale for agreement would make collaborative coding exercises much easier and more systematic.

I would also be very interested in the Codebook-as-Document plugin. A well-structured codebook is important both for teaching and for publications. At the moment, getting a clean, publication-ready version of a codebook often requires a fair amount of manual work. Having definitions, inclusion/exclusion criteria, examples, authorship, and versioning in a usable document format would be extremely helpful. Also for teaching! Right now, we use labor-intense workarounds with students, so this would be a major improvement.

Finally, the AI-Assisted Peer Debriefing ("Devil's Advocate") idea sounds very promising. One of the biggest challenges in qualitative analysis is avoiding premature closure and repeatedly questioning one's own interpretations, especisally when you are coding alone. A tool that occasionally prompts alternative readings of a segment could be a genuinely useful support for reflexive analysis, and I like this way of integrating AI into an interpretive workflow.

So if I had to pick a few priorities, these would probably be the ones.