Documentation & API Reference

Python SDK Quickstart

Synthesize Multimodal Tensors in 3 Lines

Install the high-performance Python SDK and initialize real-time streaming connections to Neural OS clusters.

# Install via pip

$ pip install neural-os-core

from neural_os import NeuralEngine

# Initialize client with sub-1.5ms edge routing
engine = NeuralEngine(api_key="nos_live_9981247")

# Stream sub-millisecond tensor response
response = engine.synthesize_stream(
    prompt="Refactor CUDA memory alignment for FP8 tensors",
    concurrency=64
)

for token in response.stream():
    print(token, end="", flush=True)

cURL REST Example

curl -X POST https://api.neural-os.ai/v3/inference \
  -H "Authorization: Bearer nos_live_9981247" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "neural-llm-70b-fp8",
    "prompt": "Synthesize risk report",
    "temperature": 0.7
  }'

Security Specification

Hardware Enclave Bearer Authentication

All API requests to Neural OS clusters require HTTP Bearer authentication headers passed with valid, SOC2 encrypted API keys.

HTTP Header Protocol

Authorization: Bearer nos_live_9981247a8f901c2e

Never expose secret API keys in client-side code or public repositories. Always proxy requests through server environment variables.

Credential Lifecycle

API Key Scopes & Instant Revocation

Generate fine-grained scoped keys inside your Dashboard for staging, testing, or production AI agents.

Key Types & Permission Matrix

Production Live Key (`nos_live_`): Full read/write inference & model fine-tuning.
Staging Dev Key (`nos_test_`): Sandbox environment with mock latency streams.
Read-Only Key (`nos_ro_`): Restricted to metric polling & cluster logs.

REST Endpoint

POST /v3/inference

Execute sub-millisecond multimodal inference requests against specialized FP8 kernel clusters.

Request Body JSON Schema

{
  "model": "neural-llm-70b-fp8",
  "prompt": "Synthesize real-time financial ledger data",
  "temperature": 0.7,
  "max_tokens": 4096,
  "precision": "fp8_e4m3",
  "stream": true
}

Agent Mesh Endpoint

POST /v3/agents/swarm

Initialize an autonomous swarm worker node with concurrency threads and self-healing execution loops.

{
  "agent_name": "Financial Synthesizer #99",
  "task_category": "market_analytics",
  "concurrency_threads": 64,
  "auto_heal": true,
  "target_latency_ms": 1.5
}

Training Endpoint

POST /v3/finetune/lora

Trigger automated LoRA weight fine-tuning with automated hyperparameter optimization.

{
  "base_model": "Neural-LLM-70B-FP8",
  "dataset_url": "s3://my-bucket/training_dataset.jsonl",
  "lora_rank": 16,
  "lora_alpha": 32,
  "callback_webhook": "https://api.company.com/webhooks/lora"
}

Official Python Library

Python SDK (`neural-os-core`)

High-concurrency Python client powered by PyTorch 2.4 and memory-pinned C++ bindings.

import asyncio
from neural_os import AsyncNeuralEngine

async def run_swarm():
    client = AsyncNeuralEngine(api_key="nos_live_9981247")
    swarm = await client.agents.deploy_swarm(
        name="Code Refactor Bot",
        threads=32
    )
    print(f"Swarm active on node {swarm.node_id}")

asyncio.run(run_swarm())

TypeScript / Node.js

TypeScript SDK (`@neural-os/core`)

Native ESM & CommonJS TypeScript library with full type safety for Next.js, Node, or Bun.

// npm install @neural-os/core

import { NeuralEngine } from '@neural-os/core';

const engine = new NeuralEngine({ apiKey: process.env.NEURAL_OS_KEY });

const stream = await engine.synthesizeStream({
  prompt: "Synthesize real-time vector embeddings",
  precision: "fp8"
});

for await (const chunk of stream) {
  process.stdout.write(chunk.text);
}

High Performance Systems

Rust (`neural_os`) & Go (`go-sdk`)

Zero-allocation Rust crate and idiomatic Go package for low-level systems integration.

// Cargo.toml: neural_os = "3.0"

use neural_os::NeuralClient;

#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = NeuralClient::new("nos_live_9981247");
    let response = client.synthesize("Analyze thermal feed").await?;
    println!("Inference: {:?}", response);
    Ok(())
}