// Integration Layer: Connecting extracted questions to your existing semantic modeling engine
// This preserves your current architecture while adding automated extraction capabilities
/**
* The integration service that connects extracted questions to your existing
* semantic modeling engine and concept node infrastructure
*/
class SemanticExtractionIntegrationService {
private readonly semanticEngine: SemanticModelingEngine;
private readonly conceptNodeMapper: ConceptNodeMappingService;
private readonly rationaleGenerator: AutomatedRationaleGenerator;
private readonly attributeMapper: AttributeKeyValueMapper;
constructor(
existingSemanticEngine: SemanticModelingEngine,
existingConceptNodes: ConceptNodeRepository,
existingRationaleBuilder: RationaleBuilderService
) {
this.semanticEngine = existingSemanticEngine;
this.conceptNodeMapper = new ConceptNodeMappingService(existingConceptNodes);
this.rationaleGenerator = new AutomatedRationaleGenerator(existingRationaleBuilder);
this.attributeMapper = new AttributeKeyValueMapper();
}
/**
* MAIN INTEGRATION METHOD: Takes generated questions and integrates them
* with your existing semantic modeling engine
*/
async integrateExtractedQuestions(
generatedQuestions: GeneratedQuestionSet,
guidelineMetadata: GuidelineMetadata
): Promise<IntegratedSemanticStructure> {
console.log(`Integrating ${generatedQuestions.questions.length} extracted questions with semantic engine`);
// Step 1: Map extracted medical concepts to your existing concept nodes
const conceptNodeMappings = await this.mapToExistingConceptNodes(generatedQuestions);
console.log(`✓ Mapped to ${conceptNodeMappings.length} concept nodes`);
// Step 2: Create the attribute key:value pairs that your system uses for inference
const attributeMappings = await this.createAttributeMappings(generatedQuestions, conceptNodeMappings);
console.log(`✓ Created ${attributeMappings.length} attribute mappings`);
// Step 3: Build inherited relationships for your semantic inference engine
const inheritedRelationships = await this.buildInheritedRelationships(
conceptNodeMappings,
generatedQuestions.branchingLogic
);
console.log(`✓ Built ${inheritedRelationships.length} inherited relationships`);
// Step 4: Create search node templates that work with your existing system
const searchNodeTemplates = await this.generateSearchNodeTemplates(
generatedQuestions,
conceptNodeMappings,
attributeMappings
);
console.log(`✓ Generated ${searchNodeTemplates.length} search node templates`);
// Step 5: Build the automated rationale generation rules
const rationaleRules = await this.buildRationaleGenerationRules(
generatedQuestions,
conceptNodeMappings
);
console.log(`✓ Built comprehensive rationale generation rules`);
return {
conceptNodeMappings,
attributeMappings,
inheritedRelationships,
searchNodeTemplates,
rationaleRules,
integrationMetadata: {
sourceGuideline: guidelineMetadata.title,
integrationTimestamp: new Date(),
compatibilityScore: await this.calculateCompatibilityScore(conceptNodeMappings),
semanticCoverage: await this.calculateSemanticCoverage(generatedQuestions, conceptNodeMappings)
}
};
}
/**
* CONCEPT NODE MAPPING: Maps extracted medical concepts to your existing domain concept nodes
* This ensures consistency with your current semantic structure
*/
private async mapToExistingConceptNodes(
generatedQuestions: GeneratedQuestionSet
): Promise<ConceptNodeMapping[]> {
const mappings: ConceptNodeMapping[] = [];
for (const question of generatedQuestions.questions) {
// Extract medical concepts from the question structure
const extractedConcepts = await this.extractMedicalConceptsFromQuestion(question);
for (const concept of extractedConcepts) {
// Try to find existing concept nodes that match this concept
const existingNodes = await this.semanticEngine.findMatchingConceptNodes(
concept.snomedId,
concept.medicalTerm,
concept.conceptType
);
if (existingNodes.length > 0) {
// Use existing concept node
mappings.push({
questionId: question.questionId,
extractedConcept: concept,
mappedConceptNode: existingNodes[0],
mappingType: 'EXISTING_MATCH',
confidence: 0.95,
medicalNecessityRole: this.determineMedicalNecessityRole(question, concept),
// This is crucial - connects to your rationale builder
rationaleContribution: this.extractRationaleContribution(question, concept)
});
} else {
// Create new concept node that's compatible with your existing structure
const newConceptNode = await this.createCompatibleConceptNode(concept, question);
mappings.push({
questionId: question.questionId,
extractedConcept: concept,
mappedConceptNode: newConceptNode,
mappingType: 'NEW_COMPATIBLE',
confidence: 0.85,
medicalNecessityRole: this.determineMedicalNecessityRole(question, concept),
rationaleContribution: this.extractRationaleContribution(question, concept)
});
}
}
}
return mappings;
}
/**
* ATTRIBUTE MAPPING: Creates the key:value pairs your system uses for inference
* This is where your "attribute key:value ls that map to objects with added insights" happens
*/
private async createAttributeMappings(
generatedQuestions: GeneratedQuestionSet,
conceptMappings: ConceptNodeMapping[]
): Promise<AttributeMapping[]> {
const attributeMappings: AttributeMapping[] = [];
for (const question of generatedQuestions.questions) {
// Create attribute mappings for each answer choice
for (const answerChoice of question.answerChoices) {
// Find the concept node mapping for this question
const relatedMappings = conceptMappings.filter(m => m.questionId === question.questionId);
for (const mapping of relatedMappings) {
const attributeMapping: AttributeMapping = {
attributeKey: this.generateAttributeKey(question, answerChoice, mapping),
attributeValue: answerChoice.value,
// The "objects with added insights" part
mappedObject: {
conceptNode: mapping.mappedConceptNode,
medicalContext: {
clinicalSignificance: answerChoice.clinicalSignificance,
urgencyLevel: question.clinicalContext?.urgencyLevel,
evidenceLevel: question.rationaleContribution?.evidenceLevel
},
// This enables your semantic inference
semanticInferences: await this.generateSemanticInferences(mapping, answerChoice),
// This drives your rationale generation
rationaleMetadata: {
contributionType: answerChoice.rationaleContribution,
weight: answerChoice.weight || 0,
evidenceText: this.generateEvidenceText(question, answerChoice),
sourceReference: question.sourceReference
}
},
// Integration with your existing inference engine
inferenceRules: await this.createInferenceRules(mapping, answerChoice),
// Connects to your smart form branching logic
branchingInstructions: this.extractBranchingInstructions(answerChoice)
};
attributeMappings.push(attributeMapping);
}
}
}
return attributeMappings;
}
/**
* INHERITED RELATIONSHIPS: Builds the relationships your semantic engine uses for inference
* This preserves your existing inference capabilities while adding medical necessity logic
*/
private async buildInheritedRelationships(
conceptMappings: ConceptNodeMapping[],
branchingLogic: BranchingRule[]
): Promise<InheritedRelationship[]> {
const relationships: InheritedRelationship[] = [];
// Build hierarchical relationships from your branching logic
for (const branchingRule of branchingLogic) {
const triggerMapping = conceptMappings.find(m => m.questionId === branchingRule.triggerQuestion);
if (!triggerMapping) continue;
for (const condition of branchingRule.conditions) {
// Find concept mappings for the next questions in the branch
const nextQuestionMappings = conceptMappings.filter(m =>
condition.nextQuestionSet?.includes(m.questionId)
);
for (const nextMapping of nextQuestionMappings) {
// Create inherited relationship that your semantic engine can use
const relationship: InheritedRelationship = {
parentConceptNode: triggerMapping.mappedConceptNode,
childConceptNode: nextMapping.mappedConceptNode,
relationshipType: this.determineRelationshipType(condition),
// The medical necessity context that drives rationale generation
medicalNecessityContext: {
conditionValue: condition.answerValue,
outcomeType: condition.outcome,
evaluationLogic: condition.evaluationLogic,
clinicalReasoning: condition.rationaleText
},
// Inference rules for your semantic engine
inferenceWeight: this.calculateInferenceWeight(condition),
propagationRules: await this.createPropagationRules(triggerMapping, nextMapping, condition),
// Integration with your existing system
semanticSignificance: this.calculateSemanticSignificance(triggerMapping, nextMapping),
// Source traceability for audit
derivedFromBranching: {
branchingRuleId: branchingRule.ruleId,
sourceGuideline: triggerMapping.extractedConcept.sourceDocument,
extractionConfidence: triggerMapping.confidence
}
};
relationships.push(relationship);
}
}
}
// Build domain-specific relationships (e.g., anatomical, procedural)
const domainRelationships = await this.buildDomainSpecificRelationships(conceptMappings);
relationships.push(...domainRelationships);
return relationships;
}
/**
* AUTOMATED RATIONALE GENERATION: Creates the rules that generate detailed explanations
* This is where your "automatically generates a detailed rationale" happens
*/
private async buildRationaleGenerationRules(
generatedQuestions: GeneratedQuestionSet,
conceptMappings: ConceptNodeMapping[]
): Promise<RationaleGenerationRule[]> {
const rationaleRules: RationaleGenerationRule[] = [];
// Rule 1: Emergency/Red Flag Approval Rules
const emergencyQuestions = generatedQuestions.questions.filter(q =>
q.questionType === "BINARY_WITH_SUBCRITERIA" &&
q.clinicalContext?.urgencyLevel === "IMMEDIATE_EMERGENCY"
);
for (const emergencyQ of emergencyQuestions) {
rationaleRules.push({
ruleId: `emergency_approval_${emergencyQ.questionId}`,
triggerCondition: {
questionId: emergencyQ.questionId,
answerValue: "YES_RED_FLAG_PRESENT"
},
rationaleTemplate: {
decision: "APPROVED",
primaryReasoning: `The presence of {EMERGENCY_CONDITION} constitutes a medical emergency requiring immediate {PROCEDURE} evaluation.`,
supportingEvidence: [
"Clinical documentation of emergency condition: {SELECTED_SUBCRITERIA}",
"Medical emergency overrides standard evaluation criteria",
"Delay in treatment could result in permanent neurological damage"
],
guidelineReference: `As per {SOURCE_GUIDELINE}, {EMERGENCY_CONDITION} is classified as a red flag indicator requiring urgent imaging evaluation.`,
regulatoryBasis: emergencyQ.sourceReference?.documentTitle,
confidenceLevel: "HIGH"
},
// This connects to your existing rationale builder format
outputFormat: "STANDARD_RATIONALE_BUILDER",
automaticApproval: true
});
}
// Rule 2: Branching Logic Evaluation Rules
for (const branchingRule of generatedQuestions.branchingLogic) {
for (const condition of branchingRule.conditions) {
if (condition.outcome === "AUTOMATIC_APPROVAL") {
rationaleRules.push({
ruleId: `branching_approval_${branchingRule.ruleId}`,
triggerCondition: {
questionId: branchingRule.triggerQuestion,
answerValue: condition.answerValue
},
rationaleTemplate: {
decision: "APPROVED",
primaryReasoning: condition.rationaleText || "Meets established medical necessity criteria",
supportingEvidence: await this.extractSupportingEvidence(branchingRule, condition),
evaluationPathway: `${condition.evaluationLogic} pathway evaluation`,
guidelineCompliance: "Fully compliant with established treatment guidelines"
},
outputFormat: "STANDARD_RATIONALE_BUILDER",
automaticApproval: true
});
} else if (condition.outcome === "AUTOMATIC_DENIAL") {
rationaleRules.push({
ruleId: `branching_denial_${branchingRule.ruleId}`,
triggerCondition: {
questionId: branchingRule.triggerQuestion,
answerValue: condition.answerValue
},
rationaleTemplate: {
decision: "DENIED",
primaryReasoning: "Does not meet established medical necessity criteria",
contradictoryEvidence: await this.extractContradictoryEvidence(branchingRule, condition),
riskBenefitAnalysis: "Potential risks outweigh limited clinical benefits",
alternativeRecommendations: await this.generateAlternatives(branchingRule, condition)
},
outputFormat: "STANDARD_RATIONALE_BUILDER",
automaticDenial: true
});
}
}
}
return rationaleRules;
}
/**
* CONCRETE EXAMPLE: How your MRI Red Flag gets integrated
* This shows the complete transformation from PDF to working rationale generation
*/
async demonstrateRedFlagIntegration(): Promise<IntegrationExample> {
// Starting with your actual MRI document's CES criterion
const originalText = "Cauda equina syndrome (CES), either directly or indirectly...";
// After pattern recognition and question generation, here's the integration:
const integrationResult = {
// 1. Concept Node Mapping
conceptNodeMapping: {
questionId: "red_flag_ces_q001",
extractedConcept: {
snomedId: "192757006",
medicalTerm: "Cauda equina syndrome",
conceptType: "EMERGENCY_CONDITION"
},
mappedConceptNode: {
nodeId: "cn_emergency_neurological_001",
nodeType: "EMERGENCY_CONDITION",
semanticProperties: {
urgency: "IMMEDIATE",
bodySystem: "NEUROLOGICAL",
anatomicalLocation: "LUMBAR_SPINE"
}
},
medicalNecessityRole: "IMMEDIATE_APPROVAL_CRITERION",
rationaleContribution: "SUFFICIENT_ALONE"
},
// 2. Attribute Mapping (your key:value pairs with added insights)
attributeMapping: {
attributeKey: "emergency_condition.ces.documented",
attributeValue: "YES_RED_FLAG_PRESENT",
mappedObject: {
conceptNode: "cn_emergency_neurological_001",
medicalContext: {
clinicalSignificance: "Medical emergency requiring immediate intervention",
urgencyLevel: "IMMEDIATE_EMERGENCY",
evidenceLevel: "CLINICAL_EMERGENCY"
},
semanticInferences: [
"Override standard evaluation criteria",
"Activate emergency approval pathway",
"Require immediate clinical intervention"
],
rationaleMetadata: {
contributionType: "SUFFICIENT_FOR_APPROVAL",
weight: 100,
evidenceText: "Documented presence of cauda equina syndrome with supporting clinical findings",
sourceReference: "PURE MRI LOW BACK Guidelines, Page 1, Red Flag Indicators"
}
}
},
// 3. Inherited Relationship (for your semantic inference engine)
inheritedRelationship: {
parentConceptNode: "cn_emergency_neurological_001",
childConceptNode: "cn_mri_lumbar_spine",
relationshipType: "EMERGENCY_REQUIRES",
medicalNecessityContext: {
conditionValue: "YES_RED_FLAG_PRESENT",
outcomeType: "IMMEDIATE_APPROVAL",
evaluationLogic: "SINGLE_POSITIVE_SUFFICIENT",
clinicalReasoning: "CES requires immediate MRI to prevent permanent neurological damage"
}
},
// 4. Automated Rationale Generation (the final output)
generatedRationale: `
MEDICAL NECESSITY DETERMINATION
Procedure: MRI Lumbar Spine
Guideline Source: PURE MRI LOW BACK Guidelines
DETERMINATION: APPROVED
The requested MRI of the lumbar spine is medically necessary and appropriate.
RATIONALE:
The patient presents with documented evidence of Cauda Equina Syndrome (CES), which constitutes a medical emergency requiring immediate MRI evaluation. CES is characterized by compression of nerve roots at the end of the spinal cord, potentially resulting in permanent neurological damage if not identified and treated urgently.
SUPPORTING CLINICAL EVIDENCE:
✓ Red Flag Indicator Present: Cauda equina syndrome documented
✓ Clinical Findings: [Specific subcriteria from evaluation]
✓ Emergency Classification: Medical emergency per treatment guidelines
MEDICAL JUSTIFICATION:
As per PURE MRI LOW BACK Guidelines (Page 1, Red Flag Indicators), the presence of CES is classified as a red flag condition that automatically justifies MRI evaluation. The guideline specifically states: "Acute cauda equina syndrome (CES) is a medical emergency... MRI is optimal for providing a rapid and comprehensive evaluation of CES, allowing for expedient surgical intervention."
REGULATORY BASIS:
This determination is based on evidence-based treatment guidelines that classify CES as requiring immediate imaging evaluation. The presence of this emergency condition overrides standard evaluation criteria and justifies urgent MRI regardless of other factors.
CONCLUSION:
The requested MRI lumbar spine meets all established medical necessity criteria and is recommended for immediate approval based on the presence of emergency red flag indicators.
Confidence Level: HIGH
Review Date: ${new Date().toLocaleDateString()}
Guidelines Applied: PURE MRI LOW BACK Guidelines
`.trim()
};
return integrationResult;
}
/**
* Helper methods for the integration process
*/
private async extractMedicalConceptsFromQuestion(question: StructuredQuestion): Promise<MedicalConcept[]> {
// Extract SNOMED-mapped concepts from question content
const concepts: MedicalConcept[] = [];
// Extract from sub-criteria if present
if (question.subCriteria) {
for (const subCriterion of question.subCriteria) {
if (subCriterion.snomedCode) {
concepts.push({
snomedId: subCriterion.snomedCode,
medicalTerm: subCriterion.text,
conceptType: this.inferConceptType(subCriterion.text),
sourceDocument: question.sourceReference?.documentTitle
});
}
}
}
return concepts;
}
private determineMedicalNecessityRole(question: StructuredQuestion, concept: MedicalConcept): string {
if (question.clinicalContext?.urgencyLevel === "IMMEDIATE_EMERGENCY") {
return "IMMEDIATE_APPROVAL_CRITERION";
} else if (question.rationaleContribution?.contributionType === "SUFFICIENT_ALONE") {
return "SUFFICIENT_CRITERION";
} else {
return "SUPPORTING_CRITERION";
}
}
private generateAttributeKey(
question: StructuredQuestion,
answerChoice: AnswerChoice,
mapping: ConceptNodeMapping
): string {
// Generate semantic attribute keys that your system can use for inference
const conceptType = mapping.mappedConceptNode.nodeType.toLowerCase();
const medicalTerm = mapping.extractedConcept.medicalTerm.toLowerCase().replace(/\s+/g, '_');
const status = answerChoice.value.toLowerCase();
return `${conceptType}.${medicalTerm}.${status}`;
}
private async generateSemanticInferences(
mapping: ConceptNodeMapping,
answerChoice: AnswerChoice
): Promise<string[]> {
// Generate the inferences your semantic engine can use
const inferences: string[] = [];
if (answerChoice.rationaleContribution === "IMMEDIATE_APPROVAL") {
inferences.push("Override standard evaluation criteria");
inferences.push("Activate emergency approval pathway");
} else if (answerChoice.rationaleContribution === "SUFFICIENT_FOR_APPROVAL") {
inferences.push("Meets sufficient criteria for approval");
inferences.push("No additional criteria required");
}
return inferences;
}
private generateEvidenceText(question: StructuredQuestion, answerChoice: AnswerChoice): string {
// Generate evidence text for rationale building
return `${answerChoice.text} - ${answerChoice.clinicalSignificance || 'Clinical finding documented'}`;
}
private extractBranchingInstructions(answerChoice: AnswerChoice): BranchingInstruction | null {
if (answerChoice.nextQuestions && answerChoice.nextQuestions.length > 0) {
return {
action: "SHOW_QUESTIONS",
targetQuestions: answerChoice.nextQuestions,
condition: answerChoice.branchingImplication
};
}
return null;
}
}