OpenAI SDK on a confidential,
EU-controlled endpoint.

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, a French controller, under an RGPD Art. 28 DPA; compute sub-processors are listed and the transfer is documented once.

Training-data leakage risk

Even with retention disabled, prompts sit in the provider's memory in cleartext. Here the model runs inside an Intel TDX trust domain: the host and its hypervisor see encrypted memory, not your prompts; our relay sees them in clear on the way.

Evidence you check yourself

GET /v1/attestation returns the Intel TDX quote and NVIDIA GPU evidence of the instances serving a model, bound to a nonce you choose. Archive it next to your logs. It covers the instances, not each response.

# 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://api.voltagegpu.com/v1
OPENAI_API_KEY=vgpu_...

# 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.
# Requests pass through our relay, which sees them in clear (TLS ends at our host).
# To keep plaintext off our servers, run your own inference server in a
# Confidential VM and terminate TLS inside its trust domain.
from openai import OpenAI

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

response = client.chat.completions.create(
    model="google/gemma-4-31B-turbo-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, model in TDX
from openai import OpenAI

client = OpenAI(
    base_url="https://api.voltagegpu.com/v1",
    api_key="vgpu_...",
)

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3.2-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://api.voltagegpu.com/v1",
    api_key="vgpu_...",
)

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="Qwen/Qwen3.5-397B-A17B-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://api.voltagegpu.com/v1",
    api_key="vgpu_...",
)

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-ai/DeepSeek-V3.2-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://api.voltagegpu.com/v1",
    api_key="vgpu_...",
)

async def summarize(text: str) -> str:
    resp = await client.chat.completions.create(
        model="google/gemma-4-31B-turbo-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())

// The OpenAI Node SDK on our endpoint.
// Requests pass through our relay, which sees them in clear (TLS ends at our host).
// To keep plaintext off our servers, run your own inference server in a
// Confidential VM and terminate TLS inside its trust domain.
import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "google/gemma-4-31B-turbo-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://api.voltagegpu.com/v1",
  apiKey:  process.env.VOLTAGEGPU_API_KEY!,
});

const stream = await client.chat.completions.create({
  model: "deepseek-ai/DeepSeek-V3.2-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://api.voltagegpu.com/v1",
  apiKey:  process.env.VOLTAGEGPU_API_KEY!,
});

const resp = await client.chat.completions.create({
  model: "Qwen/Qwen3.5-397B-A17B-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

Time-to-first-token depends on the model and the prompt length. Measure it on your own traffic: a first call costs a fraction of a cent.

Isolated by hardware, not by a map

The model runs inside Intel TDX enclaves, so the host cannot read the trust domain wherever the capacity sits. French controller, EU-hosted customer database, GPU capacity operated in the US. Our relay sees requests in clear on the way in.

Edge runtime support

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