How to switch from a US AI provider to EU inference

Picture a Tuesday afternoon. Sprint review is at four, and someone from legal has just dropped a question into the team channel. Not "do we use AI", they know that. The question is: what sensitive data are we sending to it?

You start counting. The support bot gets the full ticket, including the customer's name, email and order history. The coding agent reads large parts of the repository as context. Someone in finance pastes contracts in for a summary. None of that is "a prompt" in the abstract. It's customer data, source code and confidential documents, and right now all of it goes to a US provider.

The follow-up question is obvious: how much work would it be to change that? The technical part is smaller than most teams expect. Melious speaks both the OpenAI and the Anthropic API format, so the code change is a base URL, a key and a model name. The harder part is everything around it: knowing which data flows where, picking the right replacement model, and switching without breaking a release. This guide walks through that in the order we'd do it ourselves.

1. Map where your sensitive data goes

Before touching any code, map your AI traffic by what it carries, not by which feature it powers. Four questions cover most of it.

What sensitive data is in the requests? Go through every integration and note what ends up in the request body: personal data from customers or employees, source code, contracts, internal documents, credentials that slipped into a config file. This list decides your priorities. The integration carrying the most sensitive data moves first, even if it isn't the biggest one.

Which API format? If your code uses the OpenAI SDK or anything built on it, you're on the OpenAI format. If it uses the Anthropic SDK, or you run coding agents like Claude Code, you're on the Anthropic format. Melious accepts both at the same base URL with the same key, so mixed stacks are fine.

Which models? List every model name in your code and config. Melious doesn't run OpenAI's proprietary models, and there's no automatic substitution for them, so each gpt-* name needs a deliberate replacement. Anthropic model names are handled differently (more on that below).

Which provider-specific features? This is where migrations usually snag. Streaming, tool calling, vision, structured outputs and embeddings work with the same request and response shapes. Provider-specific extras don't carry over one to one. The Assistants API isn't covered in the migration docs. Melious has its own server-side tools (web search, URL scraping, code execution and more), but they run through a separate Tools API with its own interface. If you depend on hosted extras today, plan that swap explicitly.

Don't skip embeddings in this map. If you run retrieval over internal documents, the documents themselves pass through the embedding endpoint, not just the final question.

2. Pick the replacement model

This is the decision that actually matters, and it's yours to make. Melious runs open-weight models (GLM, DeepSeek, Qwen, Kimi and others) from European data centres. You'll find them in the model hub or via GET /v1/models.

Open-weight models still trail the closed frontier on some tasks. For most day-to-day coding and text work you won't feel the gap. Whether your workload sits on the other side of that line is something we can't tell you in advance, which is why step 4 exists.

On the Anthropic format, you can keep claude-* model names in your code. Melious maps them to an open-weight model, and the response carries the original name back so client-side checks keep working. Convenient for a first test, but pin explicit model IDs once you know which ones you want.

3. Change the connection

For the OpenAI format, the client looks like this against Melious:

from openai import OpenAI

client = OpenAI(
    api_key="sk-mel-<YOUR_API_KEY>",
    base_url="https://api.melious.ai/v1",
)

response = client.chat.completions.create(
    model="<MODEL_ID>",
    messages=[{"role": "user", "content": "Name three Hanseatic cities."}],
)
print(response.choices[0].message.content)

The key, base_url and the model ID change. The import, the call and the response shape stay. Melious adds two fields to the response (environment_impact and billing_cost), which the OpenAI SDK ignores.

For the Anthropic SDK, the base URL is https://api.melious.ai without /v1, because the SDK adds its own version prefix. Coding agents deserve attention here, because they send your source code as context. For Claude Code, follow the Claude Code integration guide. Other OpenAI- or Anthropic-compatible tools like Cursor, Codex and Cline follow the same pattern.

4. Test side by side

New accounts get 5 EUR in credit. Use it for the one thing a blog post can't do for you: run your own test or eval suite against Melious and compare the results with your current provider.

Look at three things per run: output quality on your real workloads, latency, and cost. How far 5 EUR stretches depends on request length and the number of cases (we'd rather not guess a number for your workload). If the results hold, you have your answer. If one task type falls short, you know exactly where, and you can decide whether to switch everything else first.

5. Answer the sensitive-data question

Back to Tuesday afternoon. Legal didn't ask about models or SDKs. They asked what happens to the sensitive data. Here precision matters more than enthusiasm.

Every inference request runs on a provider inside the EU, and the request body and the response never leave it. There's no US or APAC fallback when European capacity gets tight. Melious doesn't log the content of your prompts or responses, only operational metadata like token counts, model and provider. No provider on the network trains on your traffic, and a provider that changes that policy comes off the list. Uploaded files are encrypted at rest.

The details are in privacy and data residency. That page is not a Data Processing Agreement, so hand your DPO the contractual documents as well, together with the data map from step 1. That map is often the more useful document of the two.

Lock-in on LLM APIs is mostly a story teams tell themselves. The wire format is shared, the SDKs take a base URL, and the real work is knowing where your sensitive data flows. Most teams have never written that down, because nobody asked. On Tuesday afternoon, somebody did.