Skip to content

ontocast.agent.serialize

Serialization agent for OntoCast.

This module provides functionality for serializing the knowledge graph (ontology and facts) to the triple store.

Attributes

logger = logging.getLogger(__name__) module-attribute

Classes

Functions:

serialize(state, tools)

Serialize the knowledge graph to the triple store.

This function: - Handles version management for updated ontologies - Tracks budget usage - Serializes both ontology and facts to the triple store

Parameters:

Name Type Description Default
state AgentState

Current agent state with ontology and facts

 required
tools ToolBox

ToolBox containing serialization tools

 required

Returns:

Type Description
AgentState

Updated agent state after serialization
Source code in ontocast/agent/serialize.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
def serialize(state: AgentState, tools: ToolBox) -> AgentState:
    """Serialize the knowledge graph to the triple store.

    This function:
    - Handles version management for updated ontologies
    - Tracks budget usage
    - Serializes both ontology and facts to the triple store

    Args:
        state: Current agent state with ontology and facts
        tools: ToolBox containing serialization tools

    Returns:
        Updated agent state after serialization
    """
    # Initialize empty facts graph if not set (for ontology-only render mode)
    if state.aggregated_facts is None:
        state.aggregated_facts = RDFGraph()
        logger.info("No facts to serialize (ontology-only render mode)")

    # Ontology versioning now supports multiple per-anchor artifacts.
    ontologies_for_versioning = document_ontology_access(state).serialization_targets()
    if state.ontology_updates_applied and ontologies_for_versioning:
        logger.info(
            "Ontology updates produced %d operation(s); updating %d artifact(s).",
            len(state.ontology_updates_applied),
            len(ontologies_for_versioning),
        )
        for ontology in ontologies_for_versioning:
            ontology.mark_as_updated(state.ontology_updates_applied)
            ontology.sync_properties_to_graph()
    elif state.ontology_units:
        logger.debug(
            "Ontology units present without explicit updates; skipping version bump"
        )
    else:
        logger.debug("Ontology unchanged during processing")

    # Report LLM budget usage
    if state.budget_tracker:
        logger.info(state.budget_tracker.get_summary())
        duration_summary = state.budget_tracker.get_duration_summary()
        if duration_summary:
            logger.info(duration_summary)
        parallelism_summary = state.budget_tracker.get_parallelism_summary()
        if parallelism_summary:
            logger.info(parallelism_summary)

    provenance_graph_uri = f"{str(state.graph_uri).rstrip('/')}/ontology-provenance"
    if len(state.ontology_provenance_artifact) > 0:
        logger.info(
            "Persisting ontology provenance artifact (%d triples) to graph %s",
            len(state.ontology_provenance_artifact),
            provenance_graph_uri,
        )
        if tools.triple_store_manager is not None:
            tools.triple_store_manager.serialize(
                state.ontology_provenance_artifact,
                graph_uri=provenance_graph_uri,
            )

    tools.serialize(state)
    return state