Schrems II + FISA 702 exposure

EU controllers cannot cleanly justify routing privileged or personal data through US-controlled inference. VoltageGPU is operated by VOLTAGE EI in France — RGPD Art. 28, no transfer mechanism needed.

Training-data leakage risk

Even with retention disabled, prompts traverse provider memory in cleartext. Intel TDX seals decryption inside the enclave — the hypervisor cannot read your prompts, and CPU-fused keys protect RAM.

AI Act Article 12 audit logging

Per-request attestation reports are ECDSA-signed by the TDX module. Pair them with completions for an audit trail that maps cleanly to Article 12 logging obligations.

# Standard OpenAI Python SDK — no fork, no patch
pip install openai>=1.40.0

# Standard OpenAI Node / TypeScript SDK
npm install openai@^4.60.0
# or: pnpm add openai@^4.60.0
# or: yarn add openai@^4.60.0

# .env — same names that the OpenAI SDK auto-detects work
OPENAI_BASE_URL=https://app.voltagegpu.com/v1
OPENAI_API_KEY=vg-...

# If you are migrating an app that already uses OPENAI_API_KEY for openai.com,
# keep both keys distinct; many SDK helpers (LangChain, LlamaIndex) read these.

# Drop-in: same OpenAI Python client, sovereign endpoint
from openai import OpenAI

client = OpenAI(
    base_url="https://app.voltagegpu.com/v1",
    api_key="vg-...",  # https://app.voltagegpu.com/settings/api-keys
)

response = client.chat.completions.create(
    model="Qwen3-32B-TEE",
    messages=[
        {"role": "system", "content": "You are a sovereign AI assistant."},
        {"role": "user",   "content": "Summarize this MSA section..."},
    ],
    temperature=0.2,
    max_tokens=1024,
)

print(response.choices[0].message.content)

# Streaming — identical iterator, sealed in TDX
from openai import OpenAI

client = OpenAI(
    base_url="https://app.voltagegpu.com/v1",
    api_key="vg-...",
)

stream = client.chat.completions.create(
    model="DeepSeek-V3-TEE",
    messages=[{"role": "user", "content": "Draft an Article 28 DPA clause..."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content or ""
    print(delta, end="", flush=True)

# Tool / function calling — every -TEE model with tools support
from openai import OpenAI
import json

client = OpenAI(
    base_url="https://app.voltagegpu.com/v1",
    api_key="vg-...",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "lookup_contract",
            "description": "Fetch a contract by id from the in-house DMS.",
            "parameters": {
                "type": "object",
                "properties": {
                    "contract_id": {"type": "string"},
                },
                "required": ["contract_id"],
            },
        },
    },
]

resp = client.chat.completions.create(
    model="Qwen3-235B-A22B-Instruct-2507-TEE",
    messages=[{"role": "user", "content": "Pull contract MSA-2026-0142 and find auto-renewal."}],
    tools=tools,
    tool_choice="auto",
)

tool_call = resp.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
print("Model wants to call:", tool_call.function.name, "with", args)

# Structured outputs — JSON mode + response_format
from openai import OpenAI
from pydantic import BaseModel

client = OpenAI(
    base_url="https://app.voltagegpu.com/v1",
    api_key="vg-...",
)

class Finding(BaseModel):
    clause: str
    severity: str       # "low" | "medium" | "high"
    rationale: str

class Review(BaseModel):
    findings: list[Finding]

resp = client.chat.completions.create(
    model="DeepSeek-R1-0528-TEE",
    messages=[
        {"role": "system", "content": "Return strict JSON conforming to the schema."},
        {"role": "user",   "content": "Review this NDA for Article 28 RGPD gaps..."},
    ],
    response_format={"type": "json_object"},
)

review = Review.model_validate_json(resp.choices[0].message.content)
for f in review.findings:
    print(f.severity, "-", f.clause)

# Async client — same import path, full asyncio support
import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://app.voltagegpu.com/v1",
    api_key="vg-...",
)

async def summarize(text: str) -> str:
    resp = await client.chat.completions.create(
        model="Qwen3-32B-TEE",
        messages=[{"role": "user", "content": f"Summarize: {text}"}],
    )
    return resp.choices[0].message.content

async def main():
    docs = ["...doc1...", "...doc2...", "...doc3..."]
    summaries = await asyncio.gather(*(summarize(d) for d in docs))
    for s in summaries:
        print(s)

asyncio.run(main())

// Drop-in: same OpenAI Node SDK, sovereign endpoint
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://app.voltagegpu.com/v1",
  apiKey:  process.env.VOLTAGEGPU_API_KEY!, // vg-...
});

const response = await client.chat.completions.create({
  model: "Qwen3-32B-TEE",
  messages: [
    { role: "system", content: "You are a sovereign AI assistant." },
    { role: "user",   content: "Summarize this MSA section..." },
  ],
  temperature: 0.2,
});

console.log(response.choices[0].message.content);

// Streaming with the official Node SDK iterator
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://app.voltagegpu.com/v1",
  apiKey:  process.env.VOLTAGEGPU_API_KEY!,
});

const stream = await client.chat.completions.create({
  model: "DeepSeek-V3-TEE",
  messages: [{ role: "user", content: "Draft an Article 28 clause..." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

// Tool / function calling with the Node SDK
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://app.voltagegpu.com/v1",
  apiKey:  process.env.VOLTAGEGPU_API_KEY!,
});

const resp = await client.chat.completions.create({
  model: "Qwen3-235B-A22B-Instruct-2507-TEE",
  messages: [
    { role: "user", content: "Pull contract MSA-2026-0142 and find auto-renewal." },
  ],
  tools: [
    {
      type: "function",
      function: {
        name: "lookup_contract",
        description: "Fetch a contract by id from the in-house DMS.",
        parameters: {
          type: "object",
          properties: { contract_id: { type: "string" } },
          required: ["contract_id"],
        },
      },
    },
  ],
  tool_choice: "auto",
});

const call = resp.choices[0].message.tool_calls?.[0];
console.log("Tool call:", call?.function.name, call?.function.arguments);

TTFT

Typical time-to-first-token: 350-650 ms on Qwen3-32B-TEE / Llama-3.3-70B-TEE from EU callers. Long-context flagships add 150-250 ms.

EU egress by default

Inference clusters in France and Germany. US-region pinning is available on Enterprise. No data leaves the trust domain in cleartext.

Edge runtime support

The OpenAI Node SDK works on Vercel Edge, Cloudflare Workers, Bun and Deno. Streaming uses standard SSE — no special transport.

PLUS

$20 / mo

Individual developer — first production calls.

• $5 included tokens
• 600 RPM / 1.2M TPM
• All -TEE chat models
• Email support

STARTER

$349 / mo

Small engineering team shipping their first agent.

• $80 included tokens
• 1,200 RPM / 3M TPM
• Streaming + tools + JSON mode
• Slack support

PRO

$1,199 / mo

Production agent fleets up to 10 seats.

• $280 included tokens
• 2,400 RPM / 6M TPM
• Per-request attestation
• Audit log export

ENTERPRISE

from $5,000 / mo

Regulated industries, dedicated capacity, custom DPA.

• SSO / SAML / SCIM
• Bespoke RPM/TPM
• Dedicated TDX capacity
• Named CSM + 99.9% SLA