Getting Started

pip install vaas-x

Requires Python 3.10+. Optional extras pull in dependencies only for the connectors or features you actually use:

pip install "vaas-x[websocket]"   # WebSocket streaming sources
pip install "vaas-x[mqtt]"        # MQTT sources
pip install "vaas-x[dataframe]"   # pandas DataFrame ingestion
pip install "vaas-x[ac]"          # ArtificialCognition (Professional tier+, see section 6)

Bootstrap profiles whatever you point it at -- no schema to design, no field mapping to configure. It works out from the data itself.

from vaasx import Bootstrap

brain = Bootstrap(api_key="YOUR_API_KEY", device_id="my_device")

# Point Bootstrap at a live source -- http(s), ws(s), mqtt, a local
# file (.jsonl/.csv/.json), a pandas DataFrame, or a plain Python generator.
brain.connect("readings.jsonl")

Once connected, Bootstrap continuously profiles each field, classifies the data's schema, batches readings into episodes, and flags anomalies -- all locally, on your own hardware. Only the resulting episodes cross the network.

Prefer to send data yourself instead of using a live connector:

brain.ingest([
    {"payload": {"temp_c": 41.2, "vibration_hz": 60.1}},
])

hits = brain.query("engine running hot", k=5)
for hit in hits:
    print(hit["score"], hit["episode"])

Results are ranked by similarity and, by default, weighted toward episodes with a recorded successful outcome (prefer_success=True) -- see the next section.

brain.outcome(episode_id=hits[0]["id"], success=True)

Telling the system whether a past episode's action actually worked lets future queries surface what worked, not just what looks similar -- the difference between a plain similarity search and outcome-grounded recall.

If your agent already knows its own outcome the moment it acts -- the common case for a decision loop -- skip the separate outcome() call and ingest the whole episode at once as state / action / outcome. The response's episode_ids gives you back an id for each item, so you can still reference it later even though you didn't need to call outcome() separately here:

def agent_step(observation, act_fn):
    action = act_fn(observation)
    result = execute(action)

    resp = brain.ingest([{
        "state": {"observation": observation},
        "action": {"taken": action},
        "outcome": {"success": result.success},
    }])
    episode_id = resp["episode_ids"][0]  # server-assigned -- no need to invent your own

    # Recall similar past situations before the agent's next decision
    past = brain.query(observation, k=3, prefer_success=True)
    return action, episode_id, past

You can still supply your own "episode_id" in the item if you need a predictable id (one you've already used elsewhere in your own system) -- the server only generates one when you don't.

from vaasx import HiveMind

fleet = HiveMind(api_key="YOUR_API_KEY")
fleet.add_shard("device_1")
fleet.add_shard("device_2")

hits = fleet.query("your query", k=10)

Fans the same authenticated query out across every device on your account and merges the ranked results -- no per-device setup beyond registering the device IDs.

Early access. Text encoding is live today and its encode()/ingest()/outcome() calls route through the same production episode pipeline Bootstrap itself uses. The vision, audio, IMU, depth, and thermal encoders construct and run, but their models are still in active training -- treat multimodal results other than text as experimental. retrieve() has its own caveat, separate from encoder readiness: see the developer guide for exactly when it's available and how to check.

from vaasx.ac import ArtificialCognition

ac = ArtificialCognition(brain)
fused = ac.encode(text="engine running hot")
episode_id = ac.ingest(fused, device_id="my_device")
ac.outcome(episode_id, success=True)

try:
    hits = ac.retrieve(fused, device_id="my_device", k=5)
except Exception:
    hits = []  # retrieve() isn't available on every resolver yet -- see developer-guide.html

from vaasx import VaasxAPIError

try:
    brain.query("...")
except VaasxAPIError as e:
    print(e.status_code, e.detail)

Rate-limit and quota errors return a 4xx with a machine-readable detail field -- see the API reference for the full endpoint list.

Full pricing and upgrade flow: vaasx.com/pricing.

The vaas-x package ships Bootstrap's local edge pipeline -- statistical profiling, schema classification, episode accumulation, and anomaly detection -- so your raw data is pre-processed on your own hardware before anything reaches the network. Retrieval indexing, the ranking logic behind query(), and encrypted-search deployments run entirely server-side against your account and are never present in the installed package, compiled or otherwise. This is a deliberate architectural boundary, not a limitation -- it's what lets Bootstrap run identically from a microcontroller to an enterprise server, and it means your data's processing logic isn't something a copy of the SDK could expose.

Full developer reference (every connector, complete rate limits, every error code, REST reference): Developer Guide. Endpoint summary: API Overview. Platform architecture: Core Platform Guide.

Questions: support@vaasx.com  |  Sales and Enterprise: hello@vaasx.com