Migrate from LiteLLM

LiteLLM is a self-hosted proxy; Curate-Me is the managed equivalent with governance, PII scanning, HITL approvals, and a 229-page ops dashboard built in. If you’re moving off self-hosted infra to reduce ops burden — this is the guide.

Migration time: 15–30 minutes. Zero downtime if you do a blue/green swap.

Environment variable mapping

LiteLLM env var	Curate-Me equivalent	Notes
`LITELLM_MASTER_KEY`	—	Replaced by `CM_API_KEY`
`OPENAI_API_KEY`	Store in Secrets → set `OPENAI_API_KEY=stored`	Store in dashboard once; gateway injects it
`ANTHROPIC_API_KEY`	Store in Secrets → set `ANTHROPIC_API_KEY=stored`	Same pattern
`LITELLM_API_BASE` / `OPENAI_BASE_URL`	`OPENAI_BASE_URL=https://api.curate-me.ai/v1/openai`	Per-provider path
`LITELLM_LOG`	—	Replaced by CM dashboard traces
`LITELLM_MAX_BUDGET`	`CM_DAILY_BUDGET_USD` (per-key or per-org)	Set in dashboard or via API
`LITELLM_BUDGET_DURATION`	—	CM budgets are per-day; monthly budgets via API
`LITELLM_DROP_PARAMS`	—	Not needed; CM passes params through
`REDIS_URL`	`REDIS_URL`	If you’re running CM gateway self-hosted

Before / after code diff

Python


-import litellm
-litellm.api_key = os.environ["LITELLM_MASTER_KEY"]
-litellm.api_base = "http://localhost:4000"
-
-response = litellm.completion(
-    model="gpt-4o",
-    messages=[{"role": "user", "content": "Hello"}],
-)
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://api.curate-me.ai/v1/openai",
+    api_key="cm_sk_your_gateway_key",  # or set OPENAI_API_KEY env var
+)
+
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello"}],
+)
print(response.choices[0].message.content)

Or using the Curate-Me Python SDK for tighter integration:


from curate_me.gateway import CurateGateway
 
gw = CurateGateway(api_key="cm_sk_your_gateway_key")
client = gw.openai()  # uses stored secret; no provider key needed
 
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)

TypeScript


-import OpenAI from 'openai';
-
-const client = new OpenAI({
-  apiKey: process.env.LITELLM_MASTER_KEY,
-  baseURL: 'http://localhost:4000',
-});
+import OpenAI from 'openai';
+
+const client = new OpenAI({
+  apiKey: process.env.CM_API_KEY,         // cm_sk_...
+  baseURL: 'https://api.curate-me.ai/v1/openai',
+});
 
const response = await client.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello' }],
});
console.log(response.choices[0].message.content);

curl


-curl http://localhost:4000/chat/completions \
-  -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"Hello"}]}'
+curl https://api.curate-me.ai/v1/openai/chat/completions \
+  -H "X-CM-API-Key: $CM_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"Hello"}]}'

Step-by-step migration

Create a Curate-Me account and get your gateway key

Store your provider secrets

Your upstream keys (OpenAI, Anthropic, etc.) must be stored in Curate-Me — the gateway injects them on each request so they never appear in client code.


# Store your OpenAI key
curl -X POST https://api.curate-me.ai/v1/admin/secrets \
  -H "X-CM-API-Key: cm_sk_your_gateway_key" \
  -H "Content-Type: application/json" \
  -d '{"provider": "openai", "secret": "sk-your-openai-key", "label": "production"}'
 
# Store your Anthropic key
curl -X POST https://api.curate-me.ai/v1/admin/secrets \
  -H "X-CM-API-Key: cm_sk_your_gateway_key" \
  -H "Content-Type: application/json" \
  -d '{"provider": "anthropic", "secret": "sk-ant-your-key", "label": "production"}'

Or use the CLI helper (see below) to print a migration script from your LiteLLM config.

Set a daily budget (recommended)

Prevent bill surprises from day one:


curl -X POST https://api.curate-me.ai/v1/admin/budgets \
  -H "X-CM-API-Key: cm_sk_your_gateway_key" \
  -H "Content-Type: application/json" \
  -d '{"daily_limit_usd": 25.0, "scope": "org"}'

Or in the dashboard: Costs → Budgets → Set Daily Cap.

Update your environment variables


# Remove LiteLLM vars
unset LITELLM_MASTER_KEY
unset LITELLM_API_BASE
 
# Add Curate-Me vars
export CM_API_KEY=cm_sk_your_gateway_key
export OPENAI_BASE_URL=https://api.curate-me.ai/v1/openai
export OPENAI_API_KEY=cm_sk_your_gateway_key   # gateway key doubles as the "API key"
 
# For Anthropic
export ANTHROPIC_BASE_URL=https://api.curate-me.ai/v1/anthropic

Verify your first request


curl https://api.curate-me.ai/v1/openai/chat/completions \
  -H "X-CM-API-Key: $CM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Migration test — what is 2+2?"}]
  }'

You should see the X-CM-Request-Id header in the response and a new trace appear in Dashboard → Traces within a few seconds.

Shut down LiteLLM

Once you’ve verified traffic is flowing through Curate-Me, stop the LiteLLM proxy:


# If running via Docker
docker stop litellm
 
# If running via systemd
sudo systemctl stop litellm

CLI helper: import LiteLLM config

The curate CLI can read your litellm_config.yaml and print an equivalent set of Curate-Me setup commands:


curate import-litellm-config ~/.litellm/litellm_config.yaml

Output example:


# Curate-Me equivalent of your litellm_config.yaml
# Run these commands to set up the same provider secrets and routing:
 
curl -X POST https://api.curate-me.ai/v1/admin/secrets \
  -H "X-CM-API-Key: $CM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"provider": "openai", "secret": "YOUR_OPENAI_KEY", "label": "migrated-from-litellm"}'
 
# Model alias: gpt-4-turbo → gpt-4-turbo-preview
# Note: Curate-Me passes model names through unchanged.
# Remove litellm model_list aliases and use native model names.
 
export OPENAI_BASE_URL=https://api.curate-me.ai/v1/openai
export OPENAI_API_KEY=cm_sk_your_gateway_key

The CLI helper is a print-only stub — it reads your config and outputs equivalent commands but does not mutate any state. Review and run the output manually.

LiteLLM feature equivalents

LiteLLM feature	Curate-Me equivalent
`max_budget` per key	Per-key daily budget in dashboard
`router_strategy: least-busy`	Multi-key load balancing (roadmap)
Prompt logging to Langfuse	Built-in traces dashboard + Langfuse integration (roadmap)
Fallback models	Provider failover (roadmap)
Redis caching	Response caching (roadmap)
`drop_params`	Not needed — CM passes params through
Virtual keys	API keys in dashboard Settings → API Keys
Team spend tracking	Per-team budgets in Costs → Teams

What LiteLLM does that Curate-Me doesn’t (yet)

100+ provider integrations — CM has 50 (44 production-ready)
Semantic caching — CM does not cache responses today
Model fallback routing — configurable fallback chains are on the roadmap
Self-hosted option — CM is managed SaaS only

Rollback

If you need to revert:


# Restore LiteLLM env vars
export LITELLM_MASTER_KEY=your-old-key
export OPENAI_BASE_URL=http://localhost:4000
 
# Restart LiteLLM
docker start litellm  # or: sudo systemctl start litellm
 
# Remove CM vars
unset CM_API_KEY

No data is lost — CM stores your traces and costs even after you stop routing through it.