Skip to content
Routeplane

Migrate from LiteLLM

Migrating from LiteLLM to Routeplane

Section titled “Migrating from LiteLLM to Routeplane”

LiteLLM is a Python SDK and self-hosted proxy for unifying access to 100+ LLM providers. Routeplane solves the same problem from a different angle: an agent-native proxy with a single OpenAI-compatible surface, runnable as a local binary (BYOK, no infra). This guide is for teams whose workload has shifted from backend services to agent runtimes and want a leaner, agent-first surface.

Routeplane Cloud (hosted endpoint, teams, audit) is on the Phase D roadmap. For now, self-host.

Why migrate?

Section titled “Why migrate?”
LiteLLM Proxy Routeplane (self-hosted)
Runtime Python Rust (single static binary)
Production deps Postgres + Redis + Docker/K8s None
Deployment Self-hosted only Local binary (Apache 2.0)
Design focus All-in-one LLM gateway: admin UI, virtual keys, budgets, with agent gateways added alongside Agent-first proxy: MCP / ACP / Skills, server tools as the core surface
Agent protocol surface MCP, A2A, Skills, CLI — bolted onto the horizontal gateway MCP, ACP, Skills, CLI — the product, not an add-on
License MIT (SDK) / paid enterprise tier Apache 2.0 throughout

Two things worth highlighting

Section titled “Two things worth highlighting”

1. Local-only today, hosted on the roadmap

Section titled “1. Local-only today, hosted on the roadmap”

With LiteLLM, the proxy is something you operate. With Routeplane, the local binary exposes the same OpenAI-compatible endpoint any future hosted mode will — your client code stays the same when you move between them. For now, self-host.

2. Agent-native, not all-in-one

Section titled “2. Agent-native, not all-in-one”

LiteLLM has shipped MCP, A2A, Skills, and a CLI alongside its horizontal LLM gateway — virtual keys, team budgets, spend dashboards, admin UI all included. Routeplane inverts that: agent primitives are the product, the team-admin stack is intentionally minimal. What you get on the Routeplane surface:

  • MCP gateway — proxy MCP servers so agents discover tools across hosts.
  • ACP gateway — first-class support for the Agent Client Protocol used by Claude Code, Codex, OpenCode, and others.
  • Guardrails — regex rules on the proxy hop that redact or block matching content inline.
  • OpenTelemetry export — OTLP traces and metrics to a backend you run.
  • Headless CLI — TUI wizard plus scriptable commands for setup and ops.
  • Structured outputs — JSON schema enforcement across all providers.

If you depend on LiteLLM’s team-admin UI, virtual keys, and per-user budgets, LiteLLM is still the better fit. If you’re building agents and want a lean, single-binary surface, Routeplane is.

Migration paths

Section titled “Migration paths”

From the LiteLLM Python SDK

Section titled “From the LiteLLM Python SDK”

LiteLLM as a library becomes a Routeplane base URL swap on the standard OpenAI SDK:

<Tabs items={[‘Before (LiteLLM SDK)’, ‘After (Routeplane)’]}> 

from litellm import completion


response = completion(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
    api_key="sk-...",
)
```python import openai

Local: routeplane (BYOK via env vars) — see /docs/get-started/quickstart

Section titled “Local: routeplane (BYOK via env vars) — see /docs/get-started/quickstart”

client = openai.OpenAI( base_url=“http://127.0.0.1:4356/v1”, api_key=“not-used-in-local-byok”, # loopback proxy accepts placeholder; real key is on the daemon )

response = client.chat.completions.create( model=“openai/gpt-4o”, messages=[{“role”: “user”, “content”: “Hello”}], )

</Tab>
</Tabs>


Fallbacks and provider selection that you'd configure with `litellm.Router` move into Routeplane's [routing presets](/features/presets) and [model fallback rules](/features/model-fallback) — declared once, not per call site.


### From the LiteLLM Proxy


The proxy migration replaces the Python process + Postgres + Redis with a single binary. Install and launch:


<Tabs items={['Before (LiteLLM Proxy)', 'After (Routeplane local)']}>
<Tab value="Before (LiteLLM Proxy)">
```bash
docker run -d -p 5432:5432 -e POSTGRES_PASSWORD=pass postgres
docker run -d -p 6379:6379 redis
pip install 'litellm[proxy]'
litellm --config config.yaml --port 8000
 ```bash # Install from the v0.1.0 source tarball (see Installation docs) curl -L -O https://routeplaneapp.vercel.app/downloads/routeplane-v0.1.0-source.tar.gz tar -xzf routeplane-v0.1.0-source.tar.gz cd johnmwhitman-routeplane-*/ cargo install --path apps/routeplane

Set provider keys; Routeplane auto-detects on start

Section titled “Set provider keys; Routeplane auto-detects on start”

export OPENAI_API_KEY=sk-… export ANTHROPIC_API_KEY=sk-ant-…

Start the daemon

Section titled “Start the daemon”

routeplane init # writes ./routeplane.yaml routeplane start # listens on http://127.0.0.1:4356

</Tab>
</Tabs>


## Feature mapping


| LiteLLM concept | Routeplane equivalent | Docs |
|---|---|---|
| `model_list` in `config.yaml` | Provider keys + routing presets | [Presets](/features/presets) |
| `router_settings` (retries, fallback) | Model fallback rules | [Model fallback](/features/model-fallback) |
| `routing_strategy` (least-busy, latency) | Provider selection | [Provider selection](/features/provider-selection) |
| `cache` (Redis/DynamoDB backed) | Not built into the proxy — handle in app/edge if needed | — |
| Virtual keys + budgets + admin UI | Env-var keys (local); cloud workspaces (roadmap) | [BYOK](/features/byok) |
| Guardrails / PII / content filter | Agent firewall on the proxy hop | [Guardrails](/features/guardrails) |
| Callbacks (Langfuse, Datadog, etc.) | OTLP export to your own backend | [OpenTelemetry](/features/opentelemetry) |
| MCP Gateway | MCP gateway | [MCP](/concepts/tools) |
| A2A Agent Gateway | ACP gateway | [ACP](/concepts/agents) |
| LiteLLM Proxy CLI | `routeplane` CLI / TUI | [Headless CLI](/concepts/cli) |


## What Routeplane intentionally doesn't ship


To set expectations honestly: Routeplane does not ship a built-in admin UI for team/user budgets, virtual-key generation by API, or a spend analytics dashboard at parity with LiteLLM Enterprise. Env-var-scoped keys (local) and future workspace keys (cloud) cover the common cases, but if your migration depends on per-user virtual keys with quotas enforced inside the proxy, plan for that gap or stay on LiteLLM for those workloads.


## Migration checklist


<Callout type="info">
**Before migration**
- [ ] List the providers and models you actually use (skip the rest)
- [ ] Note any custom callbacks/middleware — see if a [guardrail rule](/features/guardrails) covers it
</Callout>


<Callout type="success">
**Migration**
- [ ] Install the Routeplane daemon ([Installation](/get-started/installation))
- [ ] Export provider keys — Routeplane auto-detects on start
- [ ] Update client `base_url` to `http://127.0.0.1:4356/v1`
- [ ] Verify with a sample request
- [ ] Decommission Postgres / Redis if local-only setup is sufficient
</Callout>


## Next steps


<Cards>
  <Card title="Quick Start" href="/get-started/quickstart" description="Run Routeplane locally in under a minute" />
  <Card title="Comparison" href="/get-started/comparison" description="Side-by-side with OpenRouter, LiteLLM, and generic gateways" />
  <Card title="Agent features" href="/concepts/tools" description="MCP, ACP, skills, server tools" />
</Cards>


## Get help


- **Discord**: [Join the community](https://discord.gg/G3zVrZDa5C) for migration support
- **GitHub**: [Open an issue](https://github.com/routeplane/routeplane/issues)
- **Email**: contact@routeplane.app for enterprise migration assistance