MedRecPro MCP Server

MedRecPro

MedRecPro is a pharmaceutical structured product label (SPL) management platform built with ASP.NET Core. It provides secure access to FDA drug label data through a RESTful API, an AI-powered chat interface, a Model Context Protocol (MCP) server for integration with AI assistants like Claude, and an interactive adverse-event risk dashboard built on a multi-stage table-standardization and risk-statistics pipeline.

Specifications

• HL7 Version: HL7 Dec 2023 https://www.fda.gov/media/84201/download
• Info: https://www.fda.gov/industry/fda-data-standards-advisory-board/structured-product-labeling-resources
• SPL Data Source: https://dailymed.nlm.nih.gov/dailymed/spl-resources-all-drug-labels.cfm
• Orange Book Data Source: https://www.fda.gov/drugs/drug-approvals-and-databases/approved-drug-products-therapeutic-equivalence-evaluations-orange-book

Technology Stack

• Runtime: ASP.NET Core (.NET 8.0 LTS)
• Database: Azure SQL Server (Serverless free tier) with Dapper + Entity Framework Core
• Authentication: Cookie-based auth with Google and Microsoft OAuth providers; JWT bearer tokens for API access; McpBearer JWT scheme for MCP server integration (claims normalized to standard JWT short names: sub, name, email)
• AI Integration: Claude API for natural language query interpretation and synthesis
• MCP Protocol: Model Context Protocol server with OAuth 2.1 (PKCE S256) for Claude.ai connector integration
• Hosting: Azure App Service (Windows, IIS) with Cloudflare CDN/WAF/DNS
• Secrets: Azure Key Vault
• API Documentation: Swagger/OpenAPI
• SPL Rendering: RazorLight templates for SPL XML-to-HTML generation

Solution Architecture

The solution's three web projects are deployed to a single Azure App Service using IIS virtual applications (the console, library, React SPA source, prototypes, and test projects are not deployed as separate apps):

                        Cloudflare (CDN/WAF/DNS)
                                |
                                v
    Azure App Service: "MedRecPro" (Windows, IIS)
   +--------------------------------------------------------+
   |                                                        |
   |  /                site\wwwroot       MedRecProStatic   |
   |  /adverse-events  (MedRecProStatic, React island)      |
   |  /api             site\wwwroot\api   MedRecPro API     |
   |  /mcp             site\wwwroot\mcp   MedRecProMCP      |
   |                                                        |
   +--------------------------------------------------------+
                        |
                        v
               Azure Key Vault
              (medrecprovault)

How the Projects Relate

MedRecProStatic is the user-facing front end. Its AI chat interface (/Home/Chat) communicates with the API using a request-interpret-execute-synthesize pattern: user queries are sent to the API's AI endpoints, which use Claude to map natural language to API calls. The static site also serves OAuth/MCP discovery metadata (/.well-known/*) at the domain root on behalf of the MCP server, because the MCP SDK resolves discovery URLs relative to the domain root rather than the /mcp path.

MedRecPro (API) is the core backend. It handles SPL XML parsing and import, label data CRUD, user authentication, AI query interpretation via Claude, database views for navigation, and SPL document rendering via RazorLight templates.

MedRecProMCP is an OAuth 2.1 gateway that exposes MedRecPro API capabilities as MCP tools. When Claude.ai connects, it authenticates users through Google/Microsoft OAuth, resolves upstream identity provider identities to numeric database user IDs (auto-provisioning new users if needed), then forwards authenticated MCP JWTs to the MedRecPro API. It uses JWT tokens, PKCE (S256), Dynamic Client Registration (RFC 7591), and a shared PKSecret for encrypted user ID exchange with the API.

MedRecProReact is the source for the adverse-event risk dashboard — a React + Vite single-page "island". Its Vite build emits a deterministic bundle directly into MedRecProStatic/wwwroot/ae-dashboard, which MedRecProStatic serves at /adverse-events. The dashboard reads only from the API's /api/AdverseEvent surface (AdverseEventController), which in turn queries the materialized AE risk tables produced by the table-standardization pipeline (Stage 5). Current dashboard focuses cover product-level risk, pharmacologic-class SOC correlation, and MedDRA-system-scoped class correlation. See the MedRecProReact README for the dashboard, and the MedRecProImportClass README for the risk-statistics contract.

Repository File Structure

MedRecPro/                          # Root repository
  README.md                         # This file
  .gitignore
  LICENSE.txt

  MedRecPro/                        # ASP.NET Core Web API
    Program.cs                      # App startup, DI, middleware
    MedRecPro.csproj                # .NET 8.0 project file
    appsettings.json                # Base configuration
    appsettings.Development.json    # Local dev overrides
    web.Release.config              # IIS release config
    Controllers/
      ApiControllerBase.cs          # Base controller (route prefix, #if DEBUG directives)
      AuthController.cs             # OAuth login/logout, user info
      UsersController.cs            # User CRUD, activity logs, authentication, MCP user resolution/provisioning
                                      #   [Authorize(Policy = "ApiAccess")] — accepts both cookie auth and McpBearer JWT
                                      #   signup and authenticate endpoints use [AllowAnonymous]
      LabelController.cs            # Label CRUD, views, search, import, AI endpoints
      AiController.cs               # AI interpret/synthesize, conversations, context
      SettingsController.cs         # App info, feature flags, metrics, logs, cache
      AdverseEventController.cs     # Adverse-event dashboard data: products, favorites,
                                      #   triage/forest/quadrant, reverse-lookup, interchange,
                                      #   class SOC correlation, and MedDRA-system-scoped
                                      #   class correlation map/heatmap/cell (gated by AeDashboard flag)
    Service/
      SplImportService.cs           # SPL ZIP file import and parsing orchestration
      SplParsingService.cs          # Core SPL XML parsing
      SplDataService.cs             # Database operations for label data
      SplContextService.cs          # SPL document context management
      SplDocumentRenderingService.cs    # SPL-to-HTML rendering via RazorLight
      SplStructuredBodyRenderingService.cs
      SplSectionRenderingService.cs
      SplIngredientRenderingService.cs
      SplPackageRenderingService.cs
      SplCharacteristicRenderingService.cs
      SplAuthorRenderingService.cs
      SplTextContentRenderingService.cs
      SplRenderingRegistrationService.cs
      TarpitService.cs              # IP tracking, delay calculation, endpoint abuse detection
      ViewRenderService.cs          # Razor view rendering
      ZipImportWorkerService.cs     # Background ZIP import worker
      BackgroudTaskService.cs       # Background task management
      DatabaseKeepAliveService.cs   # Keeps Azure SQL Serverless awake during business hours
      AzureTokenCredentialService.cs
      AzureAppHostTokenCredentialService.cs
      ParsingServices/              # 20+ specialized SPL XML parsers
        SectionParser.cs
        ProductIdentityParser.cs
        PackagingParser.cs
        ... (and more)
      ParsingValidators/            # SPL validation services
    DataAccess/
      RepositoryDataAccess.cs       # Core data access layer
      UserDataAccess.cs             # User-specific queries
      DtoLabelAccess.cs             # Label DTO queries (base)
      DtoLabelAccess-Views.cs       # Database view queries
      DtoLabelAccess-Document.cs    # Document queries
      DtoLabelAccess-Ingredient.cs  # Ingredient queries
      DtoLabelAccess-Organization.cs
      DtoLabelAccess-ProductHierarchy.cs
      DtoLabelAccess-ContentHierarchy.cs
      DtoLabelAccess-BatchLoaders.cs
      DtoLabelAccess-AeDashboard.cs # Adverse-event dashboard queries and derivations
      AeDashboardDerivation.cs      # Pure signal/triage/interchange/correlation math
      AeDashboardFavoriteAccess.cs  # User favorite product persistence
      AeCorrelationPipelineModels.cs # Internal (non-response) correlation pipeline records
      ... (and more)
    Middleware/
      TarpitMiddleware.cs           # Progressive delay for 404 abuse and endpoint rate limiting
    Models/                         # Domain models, DTOs, enums
      Labels.cs                     # Core label entities
      User.cs                       # User model
      Import.cs                     # Import models
      Comparison.cs                 # Label comparison models
      SectionStructure.cs           # Section hierarchy
      DocumentRendering.cs          # Rendering models
      TarpitSettings.cs             # Tarpit configuration (thresholds, delays, monitored endpoints)
      ... (and more)
    Skills/                         # AI skill definitions (markdown prompts for Claude)
      skills.md                     # Master skill index
      selectors.md                  # Query routing rules
      retryPrompt.md                # Retry logic prompt
      labelProductIndication.md     # Indication discovery skill
      equianalgesicConversion.md    # Opioid conversion skill
      product-extraction.md         # Product extraction skill
      pharmacologic-class-matching.md
      interfaces/                   # Modular skill interface definitions
        response-format.md
        synthesis-rules.md
        api/                        # API-specific skill docs
          indication-discovery.md
          label-content.md
          equianalgesic-conversion.md
          pharmacologic-class.md
          product-extraction-api.md
          user-activity.md
          cache-management.md
          session-management.md
          data-rescue.md
          retry-fallback.md
      prompts/                      # AI prompt templates
        product-extraction-prompt.md
        pharmacologic-class-matching-prompt.md
    Views/
      SplTemplates/                 # RazorLight templates for SPL XML rendering
        GenerateSpl.cshtml          # Main SPL generation template
        _Section.cshtml             # Section partial
        _Product.cshtml             # Product partial
        _Ingredient.cshtml          # Ingredient partial
        _Packaging.cshtml           # Packaging partial
        _Author.cshtml              # Author partial
        ... (18 templates total)
      Stylesheets/                  # SPL rendering stylesheets
    Helpers/                        # Utility classes
      ClaimHelper.cs                # Centralized claim extraction (cookie auth + MCP JWT)
      EncryptionHelper.cs           # ID encryption/decryption
      ConnectionStringHelper.cs     # DB connection management
      XmlHelpers.cs                 # XML parsing utilities
      ... (and more)
    Auth/
      BasicAuthenticationHandler.cs # Basic auth handler
    Attributes/                     # Custom validation attributes for SPL fields
    Filters/
      ActivityLogActionFilter.cs    # Request activity logging
      RequireActorAttributeFilter.cs      # Actor-based authorization filter
      RequireUserRoleAttributeFilter.cs   # Role-based authorization filter
    Migrations/                     # EF Core migrations
    Exceptions/
    SQL/                            # Database schema and maintenance scripts
      MedRecPro.sql                 # Full database schema
      MedRecPro_Views.sql           # View definitions
      MedRecPro_Indexes.sql         # Index definitions
      MedRecPro-Deployment.sql      # Deployment scripts
      DbTriggerSetup.sql            # Database triggers
      MedRecPro-Export-Import.ps1   # PowerShell export/import script
      MedRecPro-AzureStatus.sql     # Azure status queries
      MedRecPro-AzureRebuildIndex.sql
      MedRecPro-AzureDisableIndex.sql
      MedRecPro-AzureNuke.sql       # Full database reset (use with caution)
      MedRecPro-AzureOnlineQueryEditorRebuildIndex.sql
      MedRecPro-TableNames.sql
      MedRecPro-TableTruncate.sql
      MedRecPro-TableMissingIndexes.sql
      MedRecPro-TableCreate-OrangeBook.sql  # Orange Book table definitions (7 tables)
      MedRecPro-AzureOrangeBookNuke.sql     # Orange Book targeted truncation
      MedRecPro-Table-tmp_FlattenedAdverseEventCoverageTable.sql  # Stage 5 AE source-row coverage audit
      MedRecPro-Table-tmp_FlattenedAdverseEventTable.sql          # Stage 5 RR-ready AE stats (RR/DNRR/CI + PERSISTED log columns)
      MedRecPro-Table-tmp_FlattenedAdverseEventRiskTable.sql      # Materialized dbo.vw_AeRisk for the dashboard
      MedRecPro-Table-tmp_AeDashboardProductCatalog.sql           # Materialized dbo.vw_AeDashboardProductCatalog (picker)
      MedRecPro-AdverseEvent-Export-Import.ps1  # BCP full-refresh of the AE tables (local -> Azure SQL)

  MedRecProStatic/                  # Static site and AI chat interface
    Program.cs                      # Startup, middleware, OAuth discovery endpoints
    MedRecProStatic.csproj          # .NET 8.0 project file
    web.config                      # IIS config (httpErrors PassThrough, handler isolation)
    appsettings.json
    appsettings.Development.json
    Controllers/
      HomeController.cs             # Index, Terms, Privacy, Chat pages
      AdverseEventDashboardController.cs  # /adverse-events React island host
    Middleware/
      TarpitMiddleware.cs           # Progressive delay for 404 abuse and endpoint rate limiting
    Models/
      PageContent.cs                # Strongly-typed content models
      TarpitSettings.cs             # Tarpit configuration (thresholds, delays, monitored endpoints)
    Services/
      ContentService.cs             # JSON content loader
      TarpitService.cs              # IP tracking, delay calculation, endpoint abuse detection
    Views/
      Home/
        Index.cshtml                # Landing page
        Terms.cshtml                # Terms of Service
        Privacy.cshtml              # Privacy Policy
        Chat.cshtml                 # AI chat interface
      AdverseEventDashboard/
        Index.cshtml                # Layout-free React dashboard host (mounts ae-dashboard bundle)
      Shared/
        _Layout.cshtml              # Master layout
        _Masthead.cshtml            # Shared masthead partial (logo, nav incl. "Insight" -> /adverse-events)
    Content/
      config.json                   # Site config (URLs, branding, version)
      pages.json                    # Page content (home, terms, privacy)
    wwwroot/
      ae-dashboard/                 # Committed Vite build output from MedRecProReact
      css/                          # Stylesheets (incl. masthead.css)
      js/
        site.js                     # Global scripts
        chat/                       # AI chat modules (18 files)
          index.js                  # Main orchestrator
          api-service.js            # API communication
          endpoint-executor.js      # API endpoint execution
          batch-synthesizer.js      # Response synthesis
          checkpoint-manager.js     # State checkpoints
          checkpoint-renderer.js    # Progress UI rendering
          message-renderer.js       # Chat message rendering
          markdown.js               # Markdown-to-HTML
          config.js                 # Chat configuration
          state.js                  # Client state management
          ... (and more)
      lib/                          # Third-party (Bootstrap, jQuery)

  MedRecProMCP/                     # MCP Server (OAuth 2.1 gateway)
    Program.cs                      # Startup, DI, endpoint mappings
    MedRecProMCP.csproj             # .NET 8.0 project file
    server.json                     # MCP registry metadata
    web.config                      # IIS config
    appsettings.json / .Development.json / .Production.json
    Configuration/
      McpServerSettings.cs
      MedRecProApiSettings.cs
      JwtSettings.cs
      OAuthProviderSettings.cs
    Endpoints/
      OAuthEndpoints.cs             # OAuth authorize, token, register, callbacks
      OAuthMetadataEndpoints.cs     # .well-known metadata
    Services/
      McpTokenService.cs            # JWT token generation/validation
      OAuthService.cs               # OAuth flow orchestration
      ClientRegistrationService.cs  # Dynamic Client Registration (RFC 7591)
      PkceService.cs                # PKCE implementation
      FilePersistedCacheService.cs  # File-based persistent cache
      MedRecProApiClient.cs         # HTTP client for API calls
      UserResolutionService.cs      # Resolves upstream IdP email to numeric DB user ID
    Handlers/
      TokenForwardingHandler.cs     # Forwards MCP JWT to API (DelegatingHandler)
    Helpers/
      StringCipher.cs               # AES encryption (copy from API for user ID decryption)
    Tools/
      DrugLabelTools.cs             # MCP tools: drug label search and export
      UserTools.cs                  # MCP tools: user/account operations
    Models/
      AiAgentDtos.cs                # AI integration models
      WorkPlanModels.cs             # Work plan models
    Templates/
      McpDocumentation.html         # Embedded docs page

  MedRecProConsole/                 # Bulk import CLI tool (SPL + Orange Book)
    Program.cs                      # Entry point, interactive menu, CLI argument dispatch
    Services/
      ImportService.cs              # SPL import orchestration
      ImportProgressTracker.cs      # SPL progress tracking
      OrangeBookImportService.cs    # Orange Book import orchestration (ZIP extraction, truncation, progress)
    Models/
      AppSettings.cs
      CommandLineArgs.cs            # CLI args: --orange-book, --nuke, --connection, --auto-quit, --verbose
      ImportParameters.cs
      ImportQueueItem.cs
      ImportResults.cs
      ImportProgressFile.cs
    Helpers/
      ConfigurationHelper.cs
      ConsoleHelper.cs              # Interactive menu (import, orange-book/ob, database/db, help, quit)
      HelpDocumentation.cs

  MedRecProImportClass/             # Shared class library for import operations
    Models/
      OrangeBook.cs                 # Orange Book entity classes (Applicant, Product, Patent, Exclusivity, junctions)
      ... (SPL models)
    Service/
      ParsingServices/
        OrangeBookProductParsingService.cs  # Orange Book products.txt parsing, batch upserts, entity matching
        ... (20+ SPL parsers)
      TransformationServices/             # SPL table-standardization pipeline (Stage 0 -> Stage 5)
        TableStandardizationServiceCollectionExtensions.cs  # AddTableStandardization(...) DI graph
        ColumnStandardizationService.cs   # Stage 3.25 column standardization (SOC normalization, Phase 2 content)
        AeParameterCategoryDictionaryService.cs  # Scoped service (1,189 entries) resolving NULL ParameterCategory → canonical SOC
        IAeParameterCategoryDictionaryService.cs # Interface for AE ParameterCategory dictionary lookup
        AdverseEventTableFlattening/      # Stage 5 AE denormalization (RR/DNRR/CI) + RelativeRiskCalculator
        ... (parsers, validators, dictionaries — see MedRecProImportClass/README.md)
    TableStandards/                 # Normalization rules, column contracts, and table-type definitions
      normalization-rules.md        # Deterministic Tier 1 rules + ML.NET Tier 2 guidance
      column-contracts.md           # Per-TableCategory column contracts
      table-types.md                # TableCategory classification decision tree
    Context/
      ApplicationDbContext.cs       # EF Core context (auto-registers OrangeBook entities via reflection)

  MedRecProReact/                   # React + Vite source for the adverse-event dashboard
    index.html                      # Vite entry (mounts #aeDashboardApp / #root)
    vite.config.js                  # base /ae-dashboard/, builds into MedRecProStatic/wwwroot/ae-dashboard
    package.json                    # React 19, Vite 8, Vitest 4, ESLint 10
    src/
      App.jsx                       # Dashboard shell (product + class + system focus, all panels)
      api/                          # /api/AdverseEvent client + dev/prod base resolution
      lib/ hooks/ components/       # Normalizers, scales, hooks, charts (forest/quadrant/correlation/system)
      test/                         # Vitest specs (see MedRecProReact/README.md)

  MedRecProTest/                    # Unit and integration tests
    SplImportServiceTests.cs
    ProductRenderingServiceTests.cs
    ComparisonServiceTests.cs
    ColumnStandardizationServiceTests.cs  # Column standardization + AE dictionary integration tests
    AeParameterCategoryDictionaryServiceTests.cs  # AE dictionary service unit tests (17 tests)
    UserDataAccessTests.cs
    LogActivityAsyncTests.cs
    StringCipherTests.cs
    ResolveMcpUserTests.cs          # MCP user resolution and auto-provisioning tests
    TarpitServiceTests.cs           # Tarpit service unit tests (404 tracking + endpoint abuse)
    TarpitMiddlewareTests.cs        # Tarpit middleware integration tests
    AdverseEventControllerTests.cs  # AE dashboard controller routing, auth, validation, feature gating
    AeDashboardDataAccessTests.cs   # AE dashboard query + correlation data-access tests
    AeDashboardDerivationTests.cs   # AE signal/triage/interchange/correlation derivation math tests

API Endpoints Summary

All API endpoints are accessed under /api in production (IIS virtual application). Controllers use #if DEBUG directives to handle the path prefix difference between local development (/api/[controller]) and production where IIS strips the /api prefix.

Authentication (/api/Auth)

Users (/api/Users)

Labels (/api/Label)

The main data controller with 40+ endpoints covering navigation views, search, CRUD, import, rendering, and AI features.

Navigation & Search Views:

Label Content & Rendering:

Drug Safety:

AI-Powered Endpoints:

CRUD & Import:

Reference:

AI (/api/Ai)

Settings (/api/Settings)

Adverse Event Dashboard (/api/AdverseEvent)

Backs the React adverse-event risk dashboard. The whole controller is gated by the FeatureFlags:AeDashboard:Enabled flag (returns 503 when disabled). Reads are anonymous (favorite state is enriched for authenticated users); favorite writes require ApiAccess. Class-picker and MedDRA system-picker responses expose pagination/aggregate totals via the X-Page-Number, X-Page-Size, X-Total-Count, and X-Chartable-Count headers.

MCP Server (/mcp)

The MCP server exposes its own endpoints. See the MedRecProMCP README for full details.

MedRecProStatic and MCP Relationship

MedRecProStatic serves the OAuth/MCP discovery metadata at the domain root because the MCP SDK resolves /.well-known/* relative to the domain, not the MCP endpoint path. When Claude connects to https://www.medrecpro.com/mcp, the SDK looks for discovery at https://www.medrecpro.com/.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server.

These endpoints are registered directly in MedRecProStatic's Program.cs as static JSON responses. Attempts to redirect from the root site to /mcp/.well-known/* failed because 302 redirects cause the MCP SDK to derive the wrong resource URI, and reverse proxying through Cloudflare triggers Bot Fight Mode (403 errors).

MedRecProStatic also has a critical web.config setting (httpErrors existingResponse="PassThrough") placed outside the <location> element so it is inherited by the MCP and API virtual applications. Without this, IIS replaces 401 responses with HTML error pages, breaking the MCP OAuth challenge flow.

Database Schema and SQL Scripts

Database schema definitions and maintenance scripts are maintained in MedRecPro/SQL/. These are the authoritative source for schema updates, view definitions, and index management.

When updating database schemas or views, modify the scripts in MedRecPro/SQL/ and run them against the target database. The MedRecPro_Views.sql file is particularly important as the navigation view queries (ingredient search, labeler search, pharmacologic class hierarchy, etc.) are defined there and power many of the API search endpoints. The adverse-event dashboard is backed by the dbo.vw_AeRisk, dbo.vw_AeDrugSummary, and dbo.vw_AeDashboardProductCatalog views (also in MedRecPro_Views.sql), the last two materialized into tmp_ tables by the Stage 5 pipeline so the dashboard reads without runtime statistics.

AI Skills System

The API includes an agentic AI layer that enables natural language interaction with pharmaceutical data. The system follows a request-interpret-execute-synthesize pattern:

1. User submits a natural language query to POST /api/Ai/interpret
2. Claude interprets the query and returns API endpoint specifications
3. The client executes the specified API endpoints
4. Results are sent to POST /api/Ai/synthesize
5. Claude produces a human-readable response with suggested follow-ups

AI skills are defined as markdown prompt files in MedRecPro/Skills/. Key skills include:

• Indication Discovery - Find drugs by indication/use case
• Equianalgesic Conversion - Opioid dose conversion calculations
• Product Extraction - AI-powered extraction of product details from text
• Pharmacologic Class Matching - Map drugs to pharmacologic classifications
• Label Content - Retrieve and synthesize label sections
• Data Rescue - Fallback strategies for missing or incomplete data

Adverse Event Risk Dashboard

The platform turns the free-text adverse-event tables buried in SPL labels into comparable risk statistics and exposes them as an interactive dashboard at /adverse-events.

The data flow spans three projects:

1. MedRecProImportClass / MedRecProConsole — the SPL table-standardization pipeline parses heterogeneous label tables into a uniform analytical schema and, in Stage 5, pre-computes Relative Risk (RR), Dose-Normalized RR (DNRR), and 95% confidence intervals per adverse-event row. Results are materialized into the tmp_FlattenedAdverseEvent* tables. See the MedRecProImportClass README for the full pipeline and the statistical contract.
2. MedRecPro (API) — AdverseEventController (/api/AdverseEvent) serves dashboard-ready, encrypted-ID payloads from the materialized risk views: per-product triage/forest/quadrant, symptom reverse lookup, comparator-aware two-product therapeutic interchange, pharmacologic-class SOC × SOC correlation maps/heatmaps/cell drill-downs, and MedDRA-system-scoped class × class / class × drug correlation views. The feature is gated by FeatureFlags:AeDashboard:Enabled.
3. MedRecProReact — a React + Vite single-page island that renders the product, class, and By System dashboard focuses. Its build output is committed into MedRecProStatic/wwwroot/ae-dashboard and served by MedRecProStatic. See the MedRecProReact README.

Because the observation units for correlation views are intentionally narrow — a single drug within a class for SOC × SOC maps, or shared selected-system terms for By System class-pair maps — sample sizes can be small. The dashboard is deliberately honesty-first: below-floor cells are suppressed rather than fabricated, non-renderable system matrices return warnings, the By System focus is single-system by design, and comparator-mixed payloads are explicitly flagged. The displayed figures are bounded by what each label discloses and what the parser can extract — absence of a signal is not evidence of its absence in practice.

FDA Orange Book Integration

Documentation truncated — see the full README on GitHub.