cs-models 0.0.627__py3-none-any.whl → 0.0.847__py3-none-any.whl

cs_models/resources/DeepResearchSession/models.py

@@ -0,0 +1,170 @@
+"""Models for Deep Research Sessions - Agentic research orchestration."""
+import enum
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Integer,
+    String,
+    Text,
+    Boolean,
+    ForeignKey,
+    Enum,
+    Float,
+)
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+
+
+class DeepResearchStatusEnum(enum.Enum):
+    """Status enum for deep research sessions."""
+    NOT_STARTED = "NOT_STARTED"
+    DECOMPOSING = "DECOMPOSING"
+    WAITING_USER_CLARIFICATION = "WAITING_USER_CLARIFICATION"
+    WAITING_SCOPE_APPROVAL = "WAITING_SCOPE_APPROVAL"
+    RESEARCHING = "RESEARCHING"
+    SYNTHESIZING = "SYNTHESIZING"
+    WAITING_USER_REVIEW = "WAITING_USER_REVIEW"
+    DRILL_DOWN = "DRILL_DOWN"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    CANCELLED = "CANCELLED"
+
+
+class HITLStatusEnum(enum.Enum):
+    """Human-in-the-loop status enum."""
+    NONE = "NONE"
+    PENDING = "PENDING"
+    RESPONDED = "RESPONDED"
+    TIMEOUT = "TIMEOUT"
+
+
+class DeepResearchSessionModel(Base):
+    """
+    Model for Deep Research Sessions.
+
+    Each session represents a complex research task that is decomposed into
+    parallel sub-tasks executed by independent agents. Supports human-in-the-loop
+    checkpoints for clarification, scope approval, and result review.
+    """
+
+    __tablename__ = "deep_research_sessions"
+
+    id = Column(Integer, primary_key=True)
+
+    # User and organization
+    user_id = Column(String(128), nullable=False)
+    org_id = Column(String(128), nullable=True)
+
+    # Link to workbook (optional)
+    workbook_id = Column(
+        Integer,
+        ForeignKey("workbooks.id"),
+        nullable=True,
+    )
+
+    # Original query and configuration
+    original_query = Column(Text, nullable=False)
+    research_config = Column(Text, nullable=True)  # JSON string of config
+
+    # Execution status
+    status = Column(
+        "status",
+        Enum(DeepResearchStatusEnum),
+        default=DeepResearchStatusEnum.NOT_STARTED,
+        nullable=False,
+    )
+    current_phase = Column(String(50), nullable=True)
+
+    # AWS Step Functions tracking
+    step_function_arn = Column(String(512), nullable=True)
+    step_function_execution_arn = Column(String(512), nullable=True)
+
+    # Progress tracking
+    total_subtasks = Column(Integer, nullable=True, default=0)
+    completed_subtasks = Column(Integer, nullable=True, default=0)
+    failed_subtasks = Column(Integer, nullable=True, default=0)
+
+    # Human-in-the-loop state
+    hitl_status = Column(
+        "hitl_status",
+        Enum(HITLStatusEnum),
+        default=HITLStatusEnum.NONE,
+        nullable=False,
+    )
+    hitl_type = Column(String(50), nullable=True)  # clarification, scope_approval, review
+    hitl_questions = Column(Text, nullable=True)  # JSON array of questions
+    hitl_responses = Column(Text, nullable=True)  # JSON object of responses
+    hitl_task_token = Column(String(1024), nullable=True)  # Step Functions callback token
+    hitl_requested_at = Column(DateTime, nullable=True)
+    hitl_responded_at = Column(DateTime, nullable=True)
+
+    # Results storage
+    final_report_s3_key = Column(String(512), nullable=True)
+    executive_summary = Column(Text, nullable=True)
+    smart_grid_id = Column(
+        Integer,
+        ForeignKey("smart_grids.id"),
+        nullable=True,
+    )
+
+    # Metadata
+    total_citations = Column(Integer, nullable=True, default=0)
+    average_confidence = Column(Float, nullable=True)
+    total_documents_analyzed = Column(Integer, nullable=True, default=0)
+
+    # V2 Architecture Fields (Agentic Units)
+    architecture_version = Column(String(10), default="v1")  # "v1" = old DAG, "v2" = agentic units
+
+    # Orchestration state (V2)
+    current_iteration = Column(Integer, default=0)  # Plan-Execute-Evaluate cycle count
+    max_iterations = Column(Integer, default=10)
+    token_budget = Column(Integer, default=100000)
+    tokens_used = Column(Integer, default=0)
+
+    # Unit tracking (V2)
+    total_units = Column(Integer, default=0)
+    completed_units = Column(Integer, default=0)
+
+    # Evaluation state (V2)
+    last_evaluation = Column(Text, nullable=True)  # JSON: Last evaluator output
+    objective_confidence = Column(Float, nullable=True)  # Overall confidence
+
+    # Error handling
+    error_message = Column(Text, nullable=True)
+    retry_count = Column(Integer, nullable=True, default=0)
+
+    # Soft delete and timestamps
+    is_deleted = Column(Boolean, nullable=True)
+    created_at = Column(
+        DateTime,
+        nullable=False,
+        default=lambda: datetime.utcnow(),
+    )
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+    )
+    completed_at = Column(DateTime, nullable=True)
+
+    # ORM Relationships
+    subtasks = relationship(
+        "DeepResearchSubTaskModel",
+        primaryjoin="and_(DeepResearchSessionModel.id==DeepResearchSubTaskModel.session_id, "
+                    "or_(DeepResearchSubTaskModel.is_deleted==False, DeepResearchSubTaskModel.is_deleted==None))",
+        order_by="DeepResearchSubTaskModel.sequence_number",
+        back_populates="session",
+    )
+
+    # V2: Agentic Units relationship
+    agentic_units = relationship(
+        "DeepResearchAgenticUnitModel",
+        primaryjoin="and_(DeepResearchSessionModel.id==DeepResearchAgenticUnitModel.session_id, "
+                    "or_(DeepResearchAgenticUnitModel.is_deleted==False, DeepResearchAgenticUnitModel.is_deleted==None))",
+        order_by="DeepResearchAgenticUnitModel.wave_number",
+        back_populates="session",
+    )

cs_models/resources/DeepResearchSession/schemas.py

@@ -0,0 +1,94 @@
+"""Schemas for Deep Research Sessions."""
+from marshmallow import Schema, fields, validate
+
+from .models import DeepResearchStatusEnum, HITLStatusEnum
+
+
+class DeepResearchSessionResourceSchema(Schema):
+    """Schema for DeepResearchSessionModel."""
+
+    not_blank = validate.Length(min=1, error="Field cannot be blank")
+
+    id = fields.Integer(dump_only=True)
+    user_id = fields.String(required=True, validate=not_blank)
+    org_id = fields.String(allow_none=True)
+    workbook_id = fields.Integer(allow_none=True)
+
+    # Query and config
+    original_query = fields.String(required=True)
+    research_config = fields.String(allow_none=True)
+
+    # Status
+    status = fields.Enum(DeepResearchStatusEnum, by_value=True)
+    current_phase = fields.String(allow_none=True)
+
+    # Step Functions
+    step_function_arn = fields.String(allow_none=True)
+    step_function_execution_arn = fields.String(allow_none=True)
+
+    # Progress
+    total_subtasks = fields.Integer(allow_none=True)
+    completed_subtasks = fields.Integer(allow_none=True)
+    failed_subtasks = fields.Integer(allow_none=True)
+
+    # HITL
+    hitl_status = fields.Enum(HITLStatusEnum, by_value=True)
+    hitl_type = fields.String(allow_none=True)
+    hitl_questions = fields.String(allow_none=True)
+    hitl_responses = fields.String(allow_none=True)
+    hitl_task_token = fields.String(allow_none=True)
+    hitl_requested_at = fields.DateTime(allow_none=True)
+    hitl_responded_at = fields.DateTime(allow_none=True)
+
+    # Results
+    final_report_s3_key = fields.String(allow_none=True)
+    executive_summary = fields.String(allow_none=True)
+    smart_grid_id = fields.Integer(allow_none=True)
+
+    # Metadata
+    total_citations = fields.Integer(allow_none=True)
+    average_confidence = fields.Float(allow_none=True)
+    total_documents_analyzed = fields.Integer(allow_none=True)
+
+    # Error handling
+    error_message = fields.String(allow_none=True)
+    retry_count = fields.Integer(allow_none=True)
+
+    # Timestamps
+    is_deleted = fields.Boolean(allow_none=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+    completed_at = fields.DateTime(allow_none=True)
+
+    # Nested relationships (dump only)
+    subtasks = fields.Nested(
+        "DeepResearchSubTaskResourceSchema",
+        many=True,
+        dump_only=True,
+        exclude=("session_id",),
+    )
+
+
+class DeepResearchSessionCreateSchema(Schema):
+    """Schema for creating a new Deep Research Session."""
+
+    not_blank = validate.Length(min=1, error="Field cannot be blank")
+
+    original_query = fields.String(required=True, validate=not_blank)
+    workbook_id = fields.Integer(allow_none=True)
+    research_config = fields.Dict(allow_none=True)  # Will be serialized to JSON
+
+
+class DeepResearchSessionProgressSchema(Schema):
+    """Schema for returning session progress."""
+
+    id = fields.Integer()
+    status = fields.Enum(DeepResearchStatusEnum, by_value=True)
+    current_phase = fields.String(allow_none=True)
+    total_subtasks = fields.Integer()
+    completed_subtasks = fields.Integer()
+    failed_subtasks = fields.Integer()
+    hitl_status = fields.Enum(HITLStatusEnum, by_value=True)
+    hitl_type = fields.String(allow_none=True)
+    hitl_questions = fields.String(allow_none=True)
+    error_message = fields.String(allow_none=True)

cs_models/resources/DeepResearchSubTask/__init__.py

@@ -0,0 +1,20 @@
+"""Deep Research SubTask model and schema exports."""
+from .models import (
+    DeepResearchSubTaskModel,
+    SubTaskStatusEnum,
+    SubTaskTypeEnum,
+)
+from .schemas import (
+    DeepResearchSubTaskResourceSchema,
+    DeepResearchSubTaskSpecSchema,
+    DeepResearchSubTaskCreateSchema,
+)
+
+__all__ = [
+    "DeepResearchSubTaskModel",
+    "SubTaskStatusEnum",
+    "SubTaskTypeEnum",
+    "DeepResearchSubTaskResourceSchema",
+    "DeepResearchSubTaskSpecSchema",
+    "DeepResearchSubTaskCreateSchema",
+]

cs_models/resources/DeepResearchSubTask/models.py

@@ -0,0 +1,177 @@
+"""Models for Deep Research SubTasks - Individual research agents."""
+import enum
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Integer,
+    String,
+    Text,
+    Boolean,
+    ForeignKey,
+    Enum,
+    Float,
+)
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+
+
+class SubTaskStatusEnum(enum.Enum):
+    """Status enum for deep research subtasks."""
+    PENDING = "PENDING"
+    QUEUED = "QUEUED"
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    SKIPPED = "SKIPPED"
+    EXPANDED = "EXPANDED"  # Template task that has been expanded into child tasks
+
+
+class SubTaskTypeEnum(enum.Enum):
+    """Type enum for research dimensions and special task types."""
+    # Research dimensions
+    CUSTOM = "CUSTOM"
+    INVESTIGATION = "INVESTIGATION"
+    DISCOVERY = "DISCOVERY"  # Entity discovery tasks
+    SMART_GRID = "SMART_GRID"  # SmartGrid matrix research (items × dimensions)
+    AGGREGATION = "AGGREGATION"  # Aggregation of other task results
+
+
+class DeepResearchSubTaskModel(Base):
+    """
+    Model for Deep Research SubTasks.
+
+    Each subtask represents an independent research agent that executes
+    with a fresh context window. Subtasks do not communicate with each
+    other - all coordination flows through the main orchestrator.
+    """
+
+    __tablename__ = "deep_research_subtasks"
+
+    id = Column(Integer, primary_key=True)
+
+    # Parent session
+    session_id = Column(
+        Integer,
+        ForeignKey("deep_research_sessions.id"),
+        nullable=False,
+    )
+
+    # V2: Parent agentic unit (nullable for backward compatibility with v1)
+    agentic_unit_id = Column(
+        Integer,
+        ForeignKey("deep_research_agentic_units.id"),
+        nullable=True,
+    )
+
+    # Task identification
+    task_id = Column(String(100), nullable=True)  # Logical task ID (e.g., "t1", "t2_ide-cel")
+    sequence_number = Column(Integer, nullable=False, default=0)
+    task_type = Column(
+        "task_type",
+        Enum(SubTaskTypeEnum),
+        default=SubTaskTypeEnum.CUSTOM,
+        nullable=False,
+    )
+    task_label = Column(String(256), nullable=True)
+
+    # Template/Expansion tracking
+    is_template = Column(Boolean, nullable=True, default=False)  # True if this is a template task
+    parent_task_id = Column(
+        Integer,
+        ForeignKey("deep_research_subtasks.id"),
+        nullable=True,
+    )  # Links expanded tasks to their parent template
+
+    # Task specification (JSON)
+    specification = Column(Text, nullable=False)  # JSON with focus_question, entities, etc.
+    focus_question = Column(Text, nullable=True)  # Denormalized for quick access
+    entities = Column(Text, nullable=True)  # JSON array of entity objects
+    search_scope = Column(Text, nullable=True)  # JSON array: ["PUBLICATION", "CLINICAL_TRIAL"]
+    expected_output_format = Column(String(50), nullable=True)  # structured, narrative, table_row
+    time_range_start = Column(DateTime, nullable=True)
+    time_range_end = Column(DateTime, nullable=True)
+
+    # Entity discovery (for DISCOVERY tasks and for_each_entity_from pattern)
+    output_entities = Column(Boolean, nullable=True, default=False)  # True if this task outputs entities
+    entity_type = Column(String(50), nullable=True)  # Type of entities discovered (e.g., "drug", "event")
+    for_each_entity_from = Column(String(100), nullable=True)  # task_id of parent task to get entities from
+    entity_name = Column(String(256), nullable=True)  # Entity name this expanded task was created for
+    entity_data = Column(Text, nullable=True)  # JSON: Full entity info including synonyms
+    discovered_entities = Column(Text, nullable=True)  # JSON: Entities discovered by this task
+
+    # Execution status
+    status = Column(
+        "status",
+        Enum(SubTaskStatusEnum),
+        default=SubTaskStatusEnum.PENDING,
+        nullable=False,
+    )
+    lambda_request_id = Column(String(256), nullable=True)
+    started_at = Column(DateTime, nullable=True)
+    completed_at = Column(DateTime, nullable=True)
+
+    # Dependencies (for sequential tasks)
+    depends_on = Column(Text, nullable=True)  # JSON array of subtask IDs
+    priority = Column(Integer, nullable=True, default=1)
+
+    # Results
+    result_s3_key = Column(String(512), nullable=True)
+    result_summary = Column(Text, nullable=True)  # Brief summary of findings
+    citations_count = Column(Integer, nullable=True, default=0)
+    documents_analyzed = Column(Integer, nullable=True, default=0)
+
+    # SmartGrid integration (for SMART_GRID task type)
+    smart_grid_id = Column(Integer, nullable=True)  # FK to SmartGridModel (not enforced)
+    smart_grid_analysis_type = Column(String(50), nullable=True)  # "row", "column", or "both"
+
+    # Quality metrics
+    confidence_score = Column(Float, nullable=True)  # 0.0 - 1.0
+    relevance_score = Column(Float, nullable=True)  # 0.0 - 1.0
+    coverage_score = Column(Float, nullable=True)  # How well the question was answered
+
+    # Execution metrics
+    execution_time_ms = Column(Integer, nullable=True)
+    tokens_used = Column(Integer, nullable=True)
+    search_queries_count = Column(Integer, nullable=True)
+
+    # Error handling
+    error_message = Column(Text, nullable=True)
+    error_type = Column(String(100), nullable=True)
+    retry_count = Column(Integer, nullable=True, default=0)
+
+    # Soft delete and timestamps
+    is_deleted = Column(Boolean, nullable=True)
+    created_at = Column(
+        DateTime,
+        nullable=False,
+        default=lambda: datetime.utcnow(),
+    )
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+    )
+
+    # ORM Relationships
+    session = relationship(
+        "DeepResearchSessionModel",
+        back_populates="subtasks",
+    )
+
+    # Self-referential relationship for template → expanded tasks
+    parent_task = relationship(
+        "DeepResearchSubTaskModel",
+        remote_side=[id],
+        backref="expanded_tasks",
+        foreign_keys=[parent_task_id],
+    )
+
+    # V2: Relationship to parent agentic unit
+    agentic_unit = relationship(
+        "DeepResearchAgenticUnitModel",
+        back_populates="internal_tasks",
+    )

cs_models/resources/DeepResearchSubTask/schemas.py

@@ -0,0 +1,105 @@
+"""Schemas for Deep Research SubTasks."""
+from marshmallow import Schema, fields, validate
+
+from .models import SubTaskStatusEnum, SubTaskTypeEnum
+
+
+class DeepResearchSubTaskResourceSchema(Schema):
+    """Schema for DeepResearchSubTaskModel."""
+
+    not_blank = validate.Length(min=1, error="Field cannot be blank")
+
+    id = fields.Integer(dump_only=True)
+    session_id = fields.Integer(required=True)
+
+    # Task identification
+    task_id = fields.String(allow_none=True)  # Logical task ID (e.g., "t1", "t2_ide-cel")
+    sequence_number = fields.Integer(required=True)
+    task_type = fields.Enum(SubTaskTypeEnum, by_value=True)
+    task_label = fields.String(allow_none=True)
+
+    # Template/Expansion tracking
+    is_template = fields.Boolean(allow_none=True)
+    parent_task_id = fields.Integer(allow_none=True)
+
+    # Task specification
+    specification = fields.String(required=True)
+    focus_question = fields.String(allow_none=True)
+    entities = fields.String(allow_none=True)
+    search_scope = fields.String(allow_none=True)
+    expected_output_format = fields.String(allow_none=True)
+    time_range_start = fields.DateTime(allow_none=True)
+    time_range_end = fields.DateTime(allow_none=True)
+
+    # Entity discovery fields
+    output_entities = fields.Boolean(allow_none=True)
+    entity_type = fields.String(allow_none=True)
+    for_each_entity_from = fields.String(allow_none=True)
+    entity_name = fields.String(allow_none=True)
+    entity_data = fields.String(allow_none=True)
+    discovered_entities = fields.String(allow_none=True)
+
+    # Execution status
+    status = fields.Enum(SubTaskStatusEnum, by_value=True)
+    lambda_request_id = fields.String(allow_none=True)
+    started_at = fields.DateTime(allow_none=True)
+    completed_at = fields.DateTime(allow_none=True)
+
+    # Dependencies
+    depends_on = fields.String(allow_none=True)
+    priority = fields.Integer(allow_none=True)
+
+    # Results
+    result_s3_key = fields.String(allow_none=True)
+    result_summary = fields.String(allow_none=True)
+    citations_count = fields.Integer(allow_none=True)
+    documents_analyzed = fields.Integer(allow_none=True)
+
+    # Smart Grid
+    smart_grid_id = fields.Integer(allow_none=True)
+    smart_grid_analysis_type = fields.String(allow_none=True)
+
+    # Quality metrics
+    confidence_score = fields.Float(allow_none=True)
+    relevance_score = fields.Float(allow_none=True)
+    coverage_score = fields.Float(allow_none=True)
+
+    # Execution metrics
+    execution_time_ms = fields.Integer(allow_none=True)
+    tokens_used = fields.Integer(allow_none=True)
+    search_queries_count = fields.Integer(allow_none=True)
+
+    # Error handling
+    error_message = fields.String(allow_none=True)
+    error_type = fields.String(allow_none=True)
+    retry_count = fields.Integer(allow_none=True)
+
+    # Timestamps
+    is_deleted = fields.Boolean(allow_none=True)
+    created_at = fields.DateTime(dump_only=True)
+    updated_at = fields.DateTime(dump_only=True)
+
+
+class DeepResearchSubTaskSpecSchema(Schema):
+    """Schema for subtask specification object."""
+
+    focus_question = fields.String(required=True)
+    entities = fields.List(fields.Dict(), allow_none=True)
+    search_scope = fields.List(fields.String(), allow_none=True)
+    output_format = fields.String(allow_none=True)
+    expected_fields = fields.List(fields.String(), allow_none=True)
+    max_documents = fields.Integer(allow_none=True)
+    time_range = fields.List(fields.String(), allow_none=True)
+    retrieval_hints = fields.Dict(allow_none=True)
+
+
+class DeepResearchSubTaskCreateSchema(Schema):
+    """Schema for creating a subtask."""
+
+    session_id = fields.Integer(required=True)
+    sequence_number = fields.Integer(required=True)
+    task_type = fields.Enum(SubTaskTypeEnum, by_value=True, required=True)
+    task_label = fields.String(allow_none=True)
+    specification = fields.Nested(DeepResearchSubTaskSpecSchema, required=True)
+    depends_on = fields.List(fields.Integer(), allow_none=True)
+    priority = fields.Integer(allow_none=True)

cs_models/resources/Designation/models.py

@@ -6,6 +6,7 @@ from sqlalchemy import (
     DateTime,
     ForeignKey,
     Boolean,
+    Text,
     String,
 )
 
@@ -22,6 +23,12 @@ class DesignationModel(Base):
         nullable=False,
     )
     designation = Column(String(128), nullable=False, index=True)
+    news_id = Column(
+        Integer,
+        ForeignKey('newswires.id'),
+        nullable=True,
+    )
+    designation_text = Column(Text, nullable=True)
     is_deleted = Column(Boolean, nullable=True)
     updated_at = Column(
         DateTime,

cs_models/resources/Designation/schemas.py

@@ -11,5 +11,7 @@ class DesignationResourceSchema(Schema):
     id = fields.Integer(dump_only=True)
     intervention_condition_id = fields.Integer(required=True)
     designation = fields.String(validate=not_blank, required=True)
+    designation_text = fields.String(allow_none=True)
+    news_id = fields.Integer(allow_none=True)
     is_deleted = fields.Boolean(allow_none=True)
     updated_at = fields.DateTime()

cs_models/resources/DesignationOutbox/models.py

@@ -7,6 +7,7 @@ from sqlalchemy import (
     ForeignKey,
     Text,
     String,
+    Boolean,
 )
 
 from ...database import Base
@@ -28,6 +29,7 @@ class DesignationOutboxModel(Base):
         ForeignKey('newswires.id'),
         nullable=False,
     )
+    processed = Column(Boolean, nullable=True)
     updated_at = Column(
         DateTime,
         nullable=False,

cs_models/resources/DesignationOutbox/schemas.py

@@ -13,4 +13,5 @@ class DesignationOutboxResourceSchema(Schema):
     designation = fields.String(validate=not_blank, required=True)
     designation_text = fields.String(validate=not_blank)
     news_id = fields.Integer(required=True)
+    processed = fields.Boolean(allow_none=True)
     updated_at = fields.DateTime()

cs_models/resources/Digest/models.py

@@ -20,6 +20,7 @@ class DigestModel(Base):
         ForeignKey('user_saved_searches.id'),
         nullable=False,
     )
+    user_id = Column(String(128), nullable=True, index=True)
     type = Column(String(128), nullable=False)
     description = Column(String(256), nullable=False)
     created_at = Column(DateTime, nullable=True)

cs_models/resources/Digest/schemas.py

@@ -10,6 +10,7 @@ class DigestResourceSchema(Schema):
 
     id = fields.Integer(dump_only=True)
     saved_search_id = fields.Integer(required=True)
+    user_id = fields.String(allow_none=True)
     type = fields.String(required=True)
     description = fields.String(required=True)
     created_at = fields.DateTime()

cs_models/resources/DocChunk/models.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Text,
+    Boolean,
+)
+
+from ...database import Base
+
+
+class DocChunkModel(Base):
+    __tablename__ = "doc_chunks"
+
+    id = Column(Integer, primary_key=True)
+    artifact_id = Column(String(50), nullable=False)
+    chunk_cui = Column(String(50), nullable=False)
+    chunk_text = Column(Text, nullable=False)
+    chunk_embedding = Column(Text, nullable=False)
+    embedding_source = Column(String(50), nullable=False)
+    is_deleted = Column(Boolean, nullable=True)
+    is_indexed = Column(Boolean, nullable=True)
+    indexed_date = Column(DateTime, nullable=True)
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        # https://stackoverflow.com/questions/58776476/why-doesnt-freezegun-work-with-sqlalchemy-default-values
+        default=lambda: datetime.utcnow(),
+        onupdate=lambda: datetime.utcnow(),
+    )