Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python
8.2 KB
Raw Blame
"""OpenRAG SDK data models."""

from typing import Literal

from pydantic import BaseModel, Field


# Chat models
class Source(BaseModel):
    """A source document returned in chat/search results."""

    filename: str
    text: str
    score: float
    page: int | None = None
    mimetype: str | None = None


class ChatResponse(BaseModel):
    """Response from a non-streaming chat request."""

    response: str
    chat_id: str | None = None
    sources: list[Source] = Field(default_factory=list)


class StreamEvent(BaseModel):
    """Base class for streaming events."""

    type: Literal["content", "sources", "done"]


class ContentEvent(StreamEvent):
    """A content delta event during streaming."""

    type: Literal["content"] = "content"
    delta: str


class SourcesEvent(StreamEvent):
    """A sources event containing retrieved documents."""

    type: Literal["sources"] = "sources"
    sources: list[Source]


class DoneEvent(StreamEvent):
    """Indicates the stream is complete."""

    type: Literal["done"] = "done"
    chat_id: str | None = None


# Search models
class SearchResult(BaseModel):
    """A single search result."""

    filename: str
    text: str
    score: float
    page: int | None = None
    mimetype: str | None = None


class SearchResponse(BaseModel):
    """Response from a search request."""

    results: list[SearchResult]


# Document models
class IngestResponse(BaseModel):
    """Response from document ingestion (async task-based)."""

    task_id: str
    status: str | None = None  # Optional - we poll for actual status
    filename: str | None = None


class IngestTaskStatus(BaseModel):
    """Status of an ingestion task."""

    task_id: str
    status: str  # "pending", "running", "completed", "failed"
    total_files: int = 0
    processed_files: int = 0
    successful_files: int = 0
    failed_files: int = 0
    files: dict = {}  # Detailed per-file status


class DeleteDocumentResponse(BaseModel):
    """Response from document deletion."""

    success: bool
    deleted_chunks: int = 0
    filename: str | None = None
    message: str | None = None
    error: str | None = None
    # Populated when deleting by filter_id — one entry per resolved data_source.
    filenames: list[str] | None = None
    filter_id: str | None = None
    per_file: list[dict] | None = None


# Chat history models
class Message(BaseModel):
    """A message in a conversation."""

    role: str
    content: str
    timestamp: str | None = None


class Conversation(BaseModel):
    """A conversation summary."""

    chat_id: str
    title: str = ""
    created_at: str | None = None
    last_activity: str | None = None
    message_count: int = 0


class ConversationDetail(Conversation):
    """A conversation with full message history."""

    messages: list[Message] = Field(default_factory=list)


class ConversationListResponse(BaseModel):
    """Response from listing conversations."""

    conversations: list[Conversation]


# Settings models
class AgentSettings(BaseModel):
    """Agent configuration settings."""

    llm_provider: str | None = None
    llm_model: str | None = None
    system_prompt: str | None = None


class KnowledgeSettings(BaseModel):
    """Knowledge base configuration settings."""

    embedding_provider: str | None = None
    embedding_model: str | None = None
    chunk_size: int | None = None
    chunk_overlap: int | None = None
    table_structure: bool | None = None
    ocr: bool | None = None
    picture_descriptions: bool | None = None


class SettingsResponse(BaseModel):
    """Response from settings endpoint."""

    agent: AgentSettings = Field(default_factory=AgentSettings)
    knowledge: KnowledgeSettings = Field(default_factory=KnowledgeSettings)


# Request models
class SearchFilters(BaseModel):
    """Filters for search requests."""

    data_sources: list[str] | None = None
    document_types: list[str] | None = None


# Settings update models
class SettingsUpdateOptions(BaseModel):
    """Options for updating settings."""

    llm_model: str | None = None
    llm_provider: str | None = None
    system_prompt: str | None = None
    embedding_model: str | None = None
    embedding_provider: str | None = None
    chunk_size: int | None = None
    chunk_overlap: int | None = None
    table_structure: bool | None = None
    ocr: bool | None = None
    picture_descriptions: bool | None = None


class SettingsUpdateResponse(BaseModel):
    """Response from settings update."""

    message: str


# Models (list available LLM/embedding models per provider)
class ModelOption(BaseModel):
    """A single model option returned by the models list endpoint."""

    value: str
    label: str
    default: bool = False


class ModelsResponse(BaseModel):
    """Response from listing models for a provider."""

    language_models: list[ModelOption] = Field(default_factory=list)
    embedding_models: list[ModelOption] = Field(default_factory=list)


# Knowledge filter models
class KnowledgeFilterQueryData(BaseModel):
    """Query configuration stored in a knowledge filter."""

    query: str | None = None
    filters: dict[str, list[str]] | None = None
    limit: int | None = None
    score_threshold: float | None = Field(default=None, alias="scoreThreshold")
    color: str | None = None
    icon: str | None = None

    model_config = {"populate_by_name": True}


class KnowledgeFilter(BaseModel):
    """A knowledge filter definition."""

    id: str
    name: str
    description: str | None = None
    query_data: KnowledgeFilterQueryData | None = Field(default=None, alias="queryData")
    owner: str | None = None
    created_at: str | None = Field(default=None, alias="createdAt")
    updated_at: str | None = Field(default=None, alias="updatedAt")

    model_config = {"populate_by_name": True}


class CreateKnowledgeFilterOptions(BaseModel):
    """Options for creating a knowledge filter."""

    name: str
    description: str | None = None
    query_data: KnowledgeFilterQueryData = Field(alias="queryData")

    model_config = {"populate_by_name": True}


class UpdateKnowledgeFilterOptions(BaseModel):
    """Options for updating a knowledge filter."""

    name: str | None = None
    description: str | None = None
    query_data: KnowledgeFilterQueryData | None = Field(default=None, alias="queryData")

    model_config = {"populate_by_name": True}


class CreateKnowledgeFilterResponse(BaseModel):
    """Response from creating a knowledge filter."""

    success: bool
    id: str | None = None
    error: str | None = None


class KnowledgeFilterSearchResponse(BaseModel):
    """Response from searching knowledge filters."""

    success: bool
    filters: list[KnowledgeFilter] = Field(default_factory=list)


class GetKnowledgeFilterResponse(BaseModel):
    """Response from getting a knowledge filter."""

    success: bool
    filter: KnowledgeFilter | None = None
    error: str | None = None


class DeleteKnowledgeFilterResponse(BaseModel):
    """Response from deleting a knowledge filter."""

    success: bool
    error: str | None = None


class PrincipalLabel(BaseModel):
    """A principal label entry in a file's ACL (connector-ingested files only)."""

    principal: str
    kind: str
    provider: str
    display_name: str = ""
    email: str = ""
    external_id: str = ""


class FileRecord(BaseModel):
    """A single ingested file record returned by the list-files endpoint."""

    filename: str
    document_id: str
    mimetype: str
    file_size: int
    source_url: str
    owner: str
    owner_name: str
    owner_email: str
    connector_type: str
    embedding_model: str
    embedding_dimensions: int | None = None
    indexed_time: str
    chunk_count: int
    allowed_users: list[str] = Field(default_factory=list)
    allowed_groups: list[str] = Field(default_factory=list)
    allowed_principal_labels: list[PrincipalLabel] = Field(default_factory=list)


class GetAllFilesResponse(BaseModel):
    """Response from GET /v1/files/get_all — offset pagination, no cursor."""

    files: list[FileRecord]
    total: int
    page: int
    page_size: int


class ListFilesResponse(BaseModel):
    """Response from GET /v2/files — cursor-based composite-aggregation pagination."""

    files: list[FileRecord]
    total: int
    is_approximate: bool
    page: int
    page_size: int
    after_key: dict | None = None