Eirini Mantzouni

Technical Highlights

Architecture Decisions

• Compress-then-merge chunking — each article chunk returns insights in the same structure as the final report (timeline entries, ambiguities, stakeholder impacts), limited to 5 items per category. The merge call receives ~3K chars instead of ~12K, producing higher-quality synthesis
• LLM as query expander, not search engine — the LLM generates EuroVoc terms, title keywords, and CELEX candidates from natural language; EUR-Lex SPARQL does the actual searching with verified structured queries. Every CELEX in results is real
• Embedding-assisted comparison — provisions from both documents are embedded, a similarity matrix identifies candidate matches, and gaps are detected structurally (unmatched provisions below threshold). The LLM then confirms and classifies pre-matched pairs instead of doing 15×8 mental comparisons
• Library as growing knowledge base — every analysed document feeds the library with embedded chunks and smart tags. Compare pulls saved findings instead of re-processing. RAG injects prior analysis into new queries. The system improves with use
• Swappable database layer — database.py abstracts SQLite vs MongoDB behind a common interface. Pipeline code never imports the implementation directly. Switching backends is one env var change
• Three EUR-Lex search strategies — EuroVoc subject classification (catches regulations whose titles don’t match keywords), citation graph (finds what cites or is cited by a known regulation), and title keywords (fallback). Combined and deduplicated
• Actionable cross-references — regulation names in analysis output are converted to CELEX numbers (LLM + regex fallback), verified against EUR-Lex, checked against library, and rendered with View/Compare/Analyse buttons. The citation network grows organically
• Demo mode as portfolio showcase — pre-loaded with CFP, Green Deal, AI Act analysis plus a Greek transposition comparison. Agent log animates the full reasoning trace with timed delays. Works without API key, EUR-Lex, or database

Technical Highlights

Key Findings

• Effort declining — fishing effort fell across most EU sea basins, with a marked Mediterranean drop post-2019 (West Med MAP trawler effort limits)
• Discards persist under LO — ~4.6% EU-wide discard rate; bottom trawls (OTB) dominate. De minimis and survivability exemptions cover substantial catch shares
• Fleet profiles stable — PCA + clustering shows most Mediterranean countries maintained their gear mix over 12 years; shifts are gradual
• 43% data confidential — confidential values disproportionately affect smaller countries and niche fisheries, limiting analytical granularity

Technical Highlights

Architecture Decisions

• Custom ReAct agent over framework — built the iterative agent loop from scratch in R rather than using LangChain/CrewAI. The agent plans hypotheses, R executes them via a safe action catalog (no eval/parse), and the agent reflects on results to decide what to explore next
• Predefined action catalog over code generation — the LLM returns JSON action descriptors, not code. 18 action handlers (correlation, ANOVA, PCA, clustering, cross-table merges) execute safely in tryCatch wrappers
• Multi-table as a first-class feature — automatic join detection using column name matching, FK-pattern recognition, and value overlap analysis. Cross-table hypothesis testing is prioritized over within-table analysis
• Two-mode architecture — start screen separates “you drive” (Classic) from “AI drives” (Auto-Discover) without duplicating code. Both modes share reactive state, so agent findings can be explored interactively in Classic mode
• Two-layer AI intelligence — rule-based engine works offline and instantly; Gemini LLM layer (free tier) adds depth when available. The app never depends on an API key for core functionality
• Modular Shiny design — 13+ independent modules (AI assistant, data upload, overview, target analysis, statsplots, stats, ML, interpretability, viz, network, pivot, PCA/clustering, predictions, report), each with isolated UI/server pairs
• Shared reactive state — a single reactiveValues object flows between modules; the AI Assistant reads from shared state to collect results across all modules and provide cross-cutting interpretation
• Parametric/non-parametric toggle — every statistical test has a non-parametric alternative (Wilcoxon, Kruskal-Wallis, Dunn’s, Spearman) with automatic effect size switching
• caret as the ML backbone — unified interface across 9 model types with full preprocessing pipeline (imputation, NZV, correlation filter, transforms, PCA) built on caret’s preProcess
• DALEX + ingredients for interpretability — model-agnostic explanations (importance, PDP, Break Down, LIME) that work identically regardless of the underlying model type
• ggstatsplot for publication output — embeds test results, effect sizes, CIs, and Bayesian analysis directly in plot subtitles, following APA reporting standards
• FactoMineR + factoextra for PCA/clustering — richer output than base R prcomp(), with automatic cos2/contribution extraction, FAMD for mixed data, and polished ggplot2 visualizations

Technical Highlights

Architecture Decisions

• Package with clean API over monolithic app — 5 exported functions wrap 30+ internal functions. Users get migrate() for the common case, process() + verify() for control. Shiny app is optional (Suggests, not Imports)
• Tidy CSV over grid dump — raw data exported as row, col, value triples filtered to only formula-referenced cells. Compact, readable, editable. Labels and decoration that no formula touches are excluded
• Dual output mode — Excel mode for quick use, CSV standalone for full migration. Same formula code in both; only the data loading section differs
• Grid reconstruction from tidy data — reconstruct_grid() helper is embedded in the generated script so it runs with zero dependencies. Rebuilds the same positional data frame (Sheet$Col[Row]) that formulas expect
• Verification decoupled from output mode — verify always runs the Excel-mode script (since formula code is identical in both modes), comparing R-computed values against Excel’s cached results
• Placeholder-based range extraction — ranges are replaced with <RANGE_N> tokens before single-cell transformation runs, preventing partial replacements (e.g., A1 inside A1:A10)
• Bottom-up function transformation — innermost (smallest-span) function calls are transformed first, enabling correct handling of arbitrarily nested expressions like SUM(IF(A1>0,B1,0))
• Dual data frame strategy for named tables — positional frames for formula execution, named table frames with real column headers for downstream analysis
• Smart CSV filtering — extract_referenced_cells() scans all formulas, expands ranges, tracks whole-column refs, and outputs only the cells that formulas actually need. Empty cells within referenced ranges are preserved as fillable input slots
• Zero external dependencies in CSV mode — generated script uses only base R. No packages to install, runs anywhere

Technical Highlights

Architecture Decisions

• Behavioral scoring over binary flags — rather than simple rule-based alerts, the risk model produces a continuous score combining multiple behavioral signals, enabling nuanced ranking and threshold-free analysis
• RAG over fine-tuning for domain context — four markdown knowledge files (IUU context, flag risks, Med geography, methodology) are injected into the system prompt, keeping the LLM grounded without model customization
• Sandboxed LLM code execution — AI-generated code runs in a restricted namespace with forbidden-import checks, preventing filesystem/network access while allowing full pandas/plotly capability
• GeoJSON geometry over region IDs — the GFW API region parameter caused 422 errors; switched to explicit polygon geometry for reliable Mediterranean bounding
• Static fallback with rich synthetic data — 80-row seeded dataset with 23 columns enables full dashboard functionality without API credentials, using verified sea-only coordinate zones

Technical Highlights

Architecture Decisions

• Adapter pattern for the scoring engine — the original scientific R functions are wrapped, not rewritten, preserving scientific integrity while enabling a modern web interface
• Wide-format storage — column names are parameter IDs, allowing the scoring engine to consume data directly without transformation
• Score caching with MD5 hash invalidation — scores are recomputed only when underlying data changes, keeping the UI responsive
• Modular Shiny design — each feature is an independent module with its own UI/server pair, enabling parallel development and isolated testing

Replaced a manual workflow of Excel spreadsheets and offline R scripts with a unified web application that reduced the time from data entry to environmental impact assessment from hours to seconds.

Technical Highlights

Architecture Decisions

• Modular UI decomposition — UI split into 12 separate files sourced at startup, keeping app.R as a pure orchestrator (~230 lines)
• Reactive data store for runtime additions — reactiveVal as mutable data store; questionnaire, Excel, and AI results are bind_rows'd, making new companies immediately available across all 15+ computations
• Three independent recommendation engines — rule-based catches threshold violations, dynamic matches score ranges, priority-based extracts actionable items from the quadrant matrix
• Role-adaptive AI assessment — CEO responses scored generously for business items, CTO responses with technical precision, consultant responses as professional observations
• Click-to-drill-down over embedded detail — click events open modal dialogs rather than embedding tables below every chart, keeping tabs scannable

Technical Highlights

Architecture Decisions

• Cluster-first adaptive routing — always routes toward the highest-scoring unconfirmed cluster, creating natural conversational flow. Exit conditions keep assessment under 5 minutes
• Data-driven question logic via wide CSV — each question row carries 360 dynamic columns. Domain experts can tune the assessment by editing spreadsheet cells without touching code
• Constraint-gated solution filtering before scoring — hard-excluded by budget/time/support/sector before composite scoring runs. Exclusion reasons surfaced in advisor report
• Expression-evaluated node status rules — each process map node stores an R expression evaluated at runtime. Adding a new node means adding one CSV row
• Separated engine from reactivity — R/engine.R contains pure functions (no Shiny dependencies), making the scoring pipeline independently testable
• Three-audience output design — Output A: plain language for SME owners. Output B: evidence tables for advisors. Output C: analytical visualizations for consultants

Technical Highlights

Technical Highlights

Architecture Decisions

• Mock data by design — transparent set.seed(42) simulation with correlated multivariate responses, block/pot random effects, and realistic missingness; shareable without confidentiality concerns
• GLMM over ANOVA for counts — true leaf count modeled with negative binomial (not normal ANOVA) to respect the data-generating process
• Dunnett’s over Bonferroni — purpose-built many-to-one comparison is more powerful when all tests compare to a single control
• Bootstrap + delta CIs — both analytical and resampling-based uncertainty for ED50, demonstrating awareness of small-sample limitations

Experimental Designs

Each Vignette Covers

• When to Use — decision criteria for choosing the design
• Exploratory Visualization — ggplot2 boxplots, interaction plots
• Model Fitting — aov() for fixed designs, lmer() for split-plot
• Assumption Checking — Q-Q plot, Shapiro-Wilk, Levene’s test via custom check_assumptions()
• Post-hoc Comparisons — Tukey HSD and emmeans pairwise contrasts with CLD

Technical Highlights

Educational Design

• Tangible algorithm comparison — students watch agents make decisions in real time, comparing random vs greedy vs memory-augmented strategies on identical grids
• Classification granularity tradeoff — lucky1 (5 types) vs lucky2 (2 categories) demonstrates precision vs speed in data categorization
• Visual state tracking — wool markers make visited cells immediately visible, building intuition for graph traversal and state management
• Progressive complexity — Random Walk establishes baseline, each subsequent strategy adds one improvement, making algorithmic thinking incremental