Python SDK

vertical-ai-sdk

A thin client over the API — plus a real mechanism for layering your own utility-specific standards on top of it, entirely on your side of the network boundary.

install + quickstart

$ pip install vertical-ai-sdk

from vertical_ai_sdk import Client

client = Client(api_key="vaico_live_...")

# jurisdiction-scoped facades -- code param pre-filled for you
result = client.overhead.nesc.grade(inp, source_ref="...")
result = client.overhead.go95.grade(inp, source_ref="...")
result = client.overhead.csa.grade(inp, source_ref="...")

your own setting-depth table, applied client-side

from vertical_ai_sdk.overhead.standards import OverheadStandardsPack, PoleSettingDepthOverride

my_standard = OverheadStandardsPack(setting_depth_overrides={
    OverheadStandardsPack.setting_depth_override_key(40.0, "average_soil"):
        PoleSettingDepthOverride(height_ft=40.0, soil_condition="average_soil", depth_ft=6.5, source="Construction Standard Sec. 3.2"),
})

ansi = client.overhead.derive_setting_depth(height_ft=40.0, species="douglas_fir", source_ref="...")
verdict = my_standard.classify_setting_depth(ansi, height_ft=40.0, soil_condition="average_soil")
# verdict.effective_setting_depth_ft is your own 6.5ft -- a direct substitute for the ANSI figure, never leaving your process

Three domains today, honestly scoped

The full API spans 17 domains. The SDK covers three of them — overhead and underground with real, typed client methods and jurisdiction facades, plus ada (PROWAG accessibility) covering 3 of its 26 routes, chosen to prove the same mechanism on a genuinely different domain rather than wrapped end to end. That's a deliberate, disclosed scope, not an oversight: every other domain is reachable directly over the REST API (see docs), and more domains land in the SDK as this shape keeps proving out.

pip install vertical-ai-sdkclient.overheadclient.undergroundclient.ada

StandardsPack — your data never leaves your infrastructure

Generic physics and cited regulatory floors are computed server-side. A utility's own proprietary layer — a margin, a substitute table, a jurisdiction's own adoption status, pure reference data with no code anchor at all — is a Python subclass you write and run entirely on your own machines. Four real shapes, each grounded in a real gap or a real production schema, not designed in the abstract:

Margin on a code floor

NESC/GO-95/CSA clearances and tension limits stay legally fixed — you can't override what the code requires, only add your own conservative margin on top of it. Defaults to "use the code minimum exactly" if you don't override anything.

Pure reference data

Framing assemblies, angle limits by conductor/insulator/framing combination, span-length policy — data with no code anchor at all. Defaults to "no limit configured" rather than inventing a threshold on your behalf.

Utility-table substitution

Setting depth, anchor pull-out capacity — a published table entry replaces the server's computed floor outright, not an additive margin. Closes real, disclosed gaps named directly in production engineering code but never built server-side.

Jurisdiction edition tracking

Which edition of a code your own AHJs enforce, and what they've locally amended — private operational knowledge no domain API can know on your behalf. Defaults to "adoption status unknown" until you populate it.

Get an API key Read the docs