Allergies and Intolerances Section

Template ID: 2.16.840.1.113883.10.20.22.2.6.1 Version: R2.1 (2015-08-01) Badge: Core Section

Overview

The Allergies and Intolerances Section documents a patient's allergic reactions and non-allergic adverse reactions to substances. This critical safety information helps prevent exposure to allergens and substances that could cause harm to the patient.

Clinical Purpose and Context

The Allergies and Intolerances Section records: - Documented allergies to medications, foods, and environmental substances - Drug intolerances and adverse reactions - Severity of allergic reactions - Types of reactions experienced (e.g., rash, anaphylaxis) - Current status of the allergy (active or resolved)

This information is essential for: - Preventing adverse drug events - Informing prescribing decisions - Guiding treatment planning - Ensuring patient safety across care settings - Meeting Meaningful Use requirements

When to Include

The Allergies Section is a required section in virtually all C-CDA document types, including: - Continuity of Care Documents (CCD) - Discharge Summaries - Transfer Summaries - Consultation Notes - Progress Notes - History and Physical Notes

Even if a patient has no known allergies, the section must be included with narrative text stating "No known allergies."

Template Details

Official OID

• Root: 2.16.840.1.113883.10.20.22.2.6.1
• Extension: 2015-08-01 (R2.1)

Conformance Level

• Conformance: SHALL (Required in all standard C-CDA documents)
• Section Code: 48765-2 (LOINC - "Allergies and adverse reactions Document")

Cardinality

• Section: 1..1 (Required)
• Entries: 1..* (At least one Allergy Concern Act entry is required)

Related Templates

• Allergy Concern Act (V3): 2.16.840.1.113883.10.20.22.4.30:2015-08-01
• Allergy Observation (V2): 2.16.840.1.113883.10.20.22.4.7:2014-06-09

Protocol Requirements

The AllergyProtocol defines the data contract for allergy entries. Each allergy must provide:

Required Properties

Property	Type	Description
allergen	str	Human-readable allergen name
allergy_type	str	Type: 'allergy' or 'intolerance'
status	str	Status: 'active' or 'resolved'

Optional Properties

Property	Type	Description
allergen_code	Optional[str]	RxNorm, UNII, or SNOMED CT code
allergen_code_system	Optional[str]	Code system: 'RxNorm', 'UNII', 'SNOMED CT'
reaction	Optional[str]	Reaction/manifestation description
severity	Optional[str]	Severity: 'mild', 'moderate', 'severe', 'fatal'
onset_date	Optional[date]	Date when allergy was first identified

Data Types and Constraints

• allergen: Free-text name (e.g., "Penicillin", "Peanuts", "Latex")
• allergen_code: Preferred code systems are RxNorm (drugs), UNII (substances), SNOMED CT
• allergy_type: Distinguishes true allergies from intolerances
• reaction: Clinical manifestation (e.g., "Hives", "Anaphylaxis", "Nausea")
• severity: Clinical severity assessment
• status: Determines the concern act's statusCode
• onset_date: When the allergy was first identified or occurred

Code Example

Here's a complete working example using ccdakit to create an Allergies Section:

from datetime import date
from ccdakit.builders.sections.allergies import AllergiesSection
from ccdakit.core.base import CDAVersion

# Define an allergy using a simple class that implements AllergyProtocol
class Allergy:
    def __init__(self, allergen, allergy_type, status, allergen_code=None,
                 allergen_code_system=None, reaction=None, severity=None, onset_date=None):
        self._allergen = allergen
        self._allergen_code = allergen_code
        self._allergen_code_system = allergen_code_system
        self._allergy_type = allergy_type
        self._reaction = reaction
        self._severity = severity
        self._status = status
        self._onset_date = onset_date

    @property
    def allergen(self):
        return self._allergen

    @property
    def allergen_code(self):
        return self._allergen_code

    @property
    def allergen_code_system(self):
        return self._allergen_code_system

    @property
    def allergy_type(self):
        return self._allergy_type

    @property
    def reaction(self):
        return self._reaction

    @property
    def severity(self):
        return self._severity

    @property
    def status(self):
        return self._status

    @property
    def onset_date(self):
        return self._onset_date

# Create allergy instances
allergies = [
    Allergy(
        allergen="Penicillin",
        allergen_code="7980",
        allergen_code_system="RxNorm",
        allergy_type="allergy",
        reaction="Hives",
        severity="moderate",
        status="active",
        onset_date=date(2015, 6, 10)
    ),
    Allergy(
        allergen="Peanuts",
        allergen_code="256349004",
        allergen_code_system="SNOMED CT",
        allergy_type="allergy",
        reaction="Anaphylaxis",
        severity="severe",
        status="active",
        onset_date=date(2010, 3, 22)
    ),
    Allergy(
        allergen="Latex",
        allergen_code="111088007",
        allergen_code_system="SNOMED CT",
        allergy_type="allergy",
        reaction="Contact dermatitis",
        severity="mild",
        status="active"
    ),
    Allergy(
        allergen="Aspirin",
        allergen_code="1191",
        allergen_code_system="RxNorm",
        allergy_type="intolerance",
        reaction="Nausea",
        severity="mild",
        status="active",
        onset_date=date(2018, 9, 5)
    )
]

# Build the Allergies Section
section_builder = AllergiesSection(
    allergies=allergies,
    title="Allergies and Intolerances",
    version=CDAVersion.R2_1
)

# Generate XML element
section_element = section_builder.build()

# Convert to XML string (for demonstration)
from lxml import etree
xml_string = etree.tostring(section_element, pretty_print=True, encoding='unicode')
print(xml_string)

Official Reference

For complete specification details, refer to the official HL7 C-CDA R2.1 documentation: - HL7 C-CDA R2.1 Implementation Guide - Section: 5.5 - Allergies and Intolerances Section (entries required)

Best Practices

Common Patterns

1. Always Document "No Known Allergies"
2. Never omit the Allergies section
3. If no allergies exist, include the section with "No known allergies" narrative

4. Use a special "No Known Allergies" observation if required by your implementation

5. Use Appropriate Code Systems

6. RxNorm for medication allergies
7. UNII for chemical substance allergies

8. SNOMED CT for broader allergen categories (foods, environmental)

9. Distinguish Allergies from Intolerances

10. True allergies involve immune system response
11. Intolerances are adverse reactions without immune involvement

12. This distinction affects clinical decision-making

13. Document Severity Accurately

14. Severity should reflect the worst known reaction
15. 'severe' or 'fatal' reactions require special clinical attention

16. Document even if historical or suspected

17. Include Reaction Details

18. Specific reactions help clinicians assess risk
19. Multiple reactions can be documented for a single allergen
20. Use clinical terminology for reactions

Validation Tips

1. Section Code Validation
2. Ensure section code is 48765-2 (LOINC)

3. This is automatically set by the builder

4. Template ID Validation

5. Verify the template ID includes extension="2015-08-01"

6. R2.1 requires this specific version

7. Required Allergy Observation Elements

8. Each allergy must have a participant (allergen)
9. Value element indicates allergy or intolerance

10. At least one reaction observation or severity observation is recommended

11. Status Code Consistency

12. Concern Act statusCode: 'active' for current allergies
13. Concern Act statusCode: 'completed' for resolved allergies
14. Allergy Observation statusCode: always 'completed'

Gotchas to Avoid

1. Empty Allergy Sections
2. NEVER create a document without an Allergies section
3. Always include at least one entry or "No Known Allergies"

4. This is a critical safety requirement

5. Missing Allergen Codes

6. While allergen codes are optional in the protocol, they're highly recommended
7. Codes enable automated decision support and allergy checking

8. Use nullFlavor if a suitable code cannot be found

9. Incorrect Code Systems

10. Different allergen types require different code systems
11. RxNorm OID: 2.16.840.1.113883.6.88
12. UNII OID: 2.16.840.1.113883.4.9

13. SNOMED CT OID: 2.16.840.1.113883.6.96

14. Reaction vs. Allergen Confusion

15. Allergen is what the patient is allergic to (Penicillin)
16. Reaction is what happens (Hives, Anaphylaxis)

17. Don't confuse these in documentation

18. Severity Coding

19. Use standard severity codes from ObservationValue value set
20. 'mild', 'moderate', 'severe' map to specific SNOMED codes

21. Severity affects clinical alerting systems

22. Historical Data Quality

23. Patient-reported allergies may lack detail
24. Document what's known and use nullFlavor for unknowns

25. Severity and reaction may be "UNK" for old allergies

26. Status Management

27. Be cautious marking allergies as 'resolved'
28. Many institutions keep all allergies as 'active' for safety

29. Document resolution date if marked resolved

30. Cross-Reactivity

31. Document related allergen cross-sensitivities
32. Example: Penicillin allergy may indicate cephalosporin sensitivity

33. Consider including notes about related substances

34. Food vs. Drug Allergies

35. Both types should be documented
36. Food allergies can affect medication excipients

37. Use appropriate code systems for each type

38. Narrative-Entry Consistency

    • Ensure narrative table matches structured data
    • The builder handles this automatically
    • Critical for human readers and validators

39. Duplicate Entries

    • Avoid documenting the same allergy multiple times
    • If reaction changed, update existing allergy rather than adding new
    • Use persistent IDs to track allergies across documents