Your own AI Overview: the spine

Write path

How a claim gets into the index

Before you can retrieve anything, a change in your systems of record has to travel — safely — into a vector store.

• Trigger on the commit, not the file. Your data platform writes Parquet to an S3 data lake and then fires a change event when the batch is committed in manifest.json. We listen for that on EventBridge — not raw S3 ObjectCreated, which fires per file before the batch is done and would read a half-written table.
• The feed is change-data-capture, not a snapshot. Each row carries an operation — Insert, Update or Delete. We collapse the rows to each record’s latest state before indexing, so claim 88431 is one current document, not a pile of edits.
• A delete must leave the index. Deletes arrive as tombstone rows (the operation column set to 'D'). We don’t skip them — we evict that document from the store. A redacted claim disappears from retrieval, which in a regulated shop is not optional.

class ChangeEvent(StrEnum):
    BATCH_TABLE_WRITTEN = "batchTableWrittenOut"
    BATCH_COMPLETED = "batchCompleted"
    STREAMING_BATCH_COMPLETED = "streamingBatchCompleted"
    SCHEMA_CHANGED = "tableSchemaChanged"

# Events that mean "a committed batch is ready to ingest for this table".
INGESTABLE = {ChangeEvent.STREAMING_BATCH_COMPLETED, ChangeEvent.BATCH_TABLE_WRITTEN}

And the fork that makes a delete a first-class outcome — the tombstone becomes an eviction, not a skipped row:

for key, row in latest.items():
    doc_id = f"{doc_type}/{key}"
    if _op(row) == "D":
        deletes.append(doc_id)     # tombstone → evict from the index
        continue
    upserts.append(Document(...))  # latest state → chunk, embed, upsert

Read path

Six nodes from question to citation

The query side is one explicit LangGraph graph — step through it and watch a real insurance question turn into a grounded, cited answer.

• Identity comes from the token, never the prompt. The signed token resolves to a tenant, an environment, and roles. The question can ask for anything; it can’t grant itself access.
• Each phase is a graph node. Because the pipeline is an explicit graph, every later post in this series deepens exactly one node without touching the others.
• Thin evidence means abstain. If retrieval comes back weak, the guardrail node scores groundedness and the system declines rather than guessing — then writes an audit record either way.

That stepper isn’t a diagram of the code — it is the code. The graph is wired once, one node per phase:

g = StateGraph(QueryState)

g.add_node("fan_out",    lambda st: fan_out.run(st, s))
g.add_node("retrieve",   lambda st: retrieve.run(st, s, embedder=embedder, store=store))
g.add_node("rerank",     lambda st: rerank.run(st, s, reranker=reranker))
g.add_node("ground",     lambda st: ground.run(st, s, llm=llm))
g.add_node("guardrails", lambda st: guardrails.run(st, s))
g.add_node("audit",      lambda st: audit.run(st, s))

g.add_edge(START, "fan_out")
g.add_edge("fan_out", "retrieve")
g.add_edge("retrieve", "rerank")
g.add_edge("rerank", "ground")
g.add_edge("ground", "guardrails")
g.add_edge("guardrails", "audit")
g.add_edge("audit", END)

Isolation

Why nothing crosses tenants

The same code serves every insurer and every environment — what keeps them apart is one key carried end to end. A TenantScope (tenant + env) rides on every document, chunk and query, and the vector index is namespaced tenant__env. Retrieval fails closed: a query for acme can only ever look inside acme__prod, so a globex chunk — or a dev chunk — is physically unreachable.

@dataclass(frozen=True, slots=True)
class TenantScope:
    tenant_id: str
    env: str  # e.g. "dev", "qa", "prod"

    def namespace(self) -> str:
        return f"{self.tenant_id}__{self.env}"

git clone https://github.com/xaviramirezcom/open-ai-overview
cd open-ai-overview
git checkout v1-spine

uv sync --extra local
cp .env.example .env        # set the *_PROVIDER / VECTOR_STORE values to "local"

own-overview seed           # generate synthetic P&C data + ingest it
own-overview query "Why did the premium on POL-55012 go up?" --role adjuster
own-overview query "Why did the premium on POL-55012 go up?" --role underwriter

def build_query_graph(*, settings=None, embedder=None, store=None,
                      reranker=None, llm=None):
    """Compile the query graph. Components default from config but can be
    injected (tests, notebooks, alternate providers)."""
    s = settings or get_settings()
    embedder = embedder or build_embedder(s)
    store = store or build_vector_store(s, embedder=embedder)
    reranker = reranker or build_reranker(s)
    llm = llm or build_llm(s)

    g = StateGraph(QueryState)
    g.add_node("fan_out",    lambda st: fan_out.run(st, s))
    g.add_node("retrieve",   lambda st: retrieve.run(st, s, embedder=embedder, store=store))
    # ... rerank · ground · guardrails · audit, then edges wire them in order ...
    return g.compile()

Explain it back

Your team wires the ingestion Lambda to fire on S3 ObjectCreated so new data shows up “the instant it lands.” A week later, answers occasionally cite garbled, half-populated claims. What went wrong, and what should the trigger have been?