TL;DR: Lemonade Server is the AMD-backed, Apache 2.0 local LLM server that answers three API dialects — OpenAI, Ollama, and Anthropic — from one process on localhost:13305. It’s the only backend in this series with a real NPU acceleration path (Ryzen AI 300-series XDNA2), and since NVIDIA, Apple Silicon, and plain CPU support landed, it’s no longer AMD-only. Its context default is also the sanest in the series: -1, meaning the server computes the largest window that fits your device memory instead of silently truncating at 4K. The catch is youth — three releases shipped in the last two weeks of August alone, and one of them existed mainly to fix the one before it.

What you’ll be able to do after this guide:

• Install Lemonade on Windows, Linux, or macOS, pull Qwen3-Coder-30B-A3B-Instruct-GGUF, and sanity-check the endpoint with curl
• Wire the same server into Cline (OpenAI Compatible provider), Continue.dev (a provider that’s actually in Continue’s dropdown), and Aider (a native lemonade/ LiteLLM prefix — no openai/ workaround needed)
• Know which of the three API dialects each tool should talk to, and why lemonade launch claude is the shortest local-model path to Claude Code this series has covered

Honest take: Lemonade earns a spot in this series on two merits — it’s the only server here that can touch an NPU, and its one-port OpenAI/Ollama/Anthropic triple play means a single loaded model serves Cline, an Ollama-only tool, and Claude Code simultaneously. If you’re on a Ryzen AI laptop or a Strix Halo box, it’s the obvious pick over Ollama. On a plain NVIDIA tower, it’s a capable llama.cpp wrapper competing with more mature ones: vLLM and SGLang still win on raw agent-loop throughput, and Ollama still wins on installed-base muscle memory.

---

The eleventh backend comes from a chip company

Every previous entry in this series — Ollama, LM Studio, llama.cpp’s llama-server, vLLM, Docker Model Runner, Jan, KoboldCpp, SGLang, LocalAI — came from the software side. Lemonade comes from AMD. It started as the serving layer for AMD’s Ryzen AI stack, lives at github.com/lemonade-sdk/lemonade under Apache 2.0, and pitches itself as “the local AI server that gives you the same capabilities as cloud APIs, except 100% free and private.”

The hardware pedigree shows in both directions. On the plus side, Lemonade is the only server in this series that can route inference to a neural processing unit: Ryzen AI 300-series laptops carry an XDNA2 NPU, and Lemonade drives it through ONNX Runtime GenAI and FastFlowLM (flm) backends while every other server on this list shrugs and uses your GPU. On the minus side, the project moves at silicon-launch speed: v11.8.1 landed August 28, 2026 — the day before this writing — specifically to fix a systemd-upgrade regression that v11.8.0 introduced two days earlier. v11.7.0 (August 19) added a model-registration endpoint and winget installs; v11.6.0 (August 14) brought tool-calling and vision support for Muse-Glimmer-30B plus ROCm on Instinct GPUs. Three stable-channel releases in fourteen days is a velocity story and a churn warning in the same sentence.

And it’s genuinely not AMD-only anymore. The README’s support matrix spans NVIDIA GPUs (Turing or newer), AMD GPUs via ROCm — gfx1151 Strix Halo, RDNA4, RDNA3 — Apple Silicon, and plain x86_64/ARM64 CPUs, with Vulkan as the portable GPU path. XDA-Developers’ recent coverage was literally titled around switching to Lemonade after NVIDIA support landed, which tells you the project’s ambitions outgrew the Ryzen AI marketing brief.

Step 0 — Platform check

Lemonade runs on Windows 11, Linux (Ubuntu 24.04+, Fedora 43+, Debian Trixie+, Arch), and macOS. Installers are boring in the right way: an .msi (or winget, since v11.7.0) on Windows, snap/.deb/.rpm on Linux, a .pkg on macOS, plus Docker images and source builds.

The hardware question is where Lemonade differs from the rest of the series. Three tiers, in practice:

• NPU tier: a Ryzen AI 300/400-series laptop. The XDNA2 NPU handles inference through the ryzenai (ONNX Runtime GenAI) or flm recipes — useful for battery-friendly background inference, but the coding-model catalog lives mostly in GGUF/llama.cpp territory, so treat NPU as a bonus, not the plan.
• GPU tier: same story as every entry in this series — for the models worth pointing an agent at, you want 16–24 GB. That’s an RTX 3090-class card, a Radeon RX 7900 XTX on the ROCm path, or unified memory on a Ryzen AI Max+ 395 mini PC (Strix Halo, gfx1151 — explicitly on Lemonade’s support list). Lemonade’s own Continue guide sets the floor at an integrated GPU with 64 GB of system RAM and recommends a discrete GPU with 16 GB+ VRAM.
• CPU tier: works, slowly, same as any llama.cpp-based server.

The deep hardware math — which GPU, how much VRAM buys which model — is runaihome.com’s territory: their AMD Lemonade NPU + GPU guide covers the acceleration tiers, and the local AI models by VRAM guide is the pre-purchase read.

Step 1 — Install, pull, sanity-check

On Windows, winget install or the .msi; on Ubuntu, the .deb; on macOS, the .pkg. Whichever route, you end up with the lemond server process and a lemonade CLI that controls it. Check the pulse, then pull the series’ standard 24 GB coding pick — the same Qwen3-Coder that Lemonade’s own Continue guide uses as its example:

lemonade status
# → confirms the server is reachable at http://localhost:13305

lemonade pull Qwen3-Coder-30B-A3B-Instruct-GGUF
lemonade load Qwen3-Coder-30B-A3B-Instruct-GGUF --ctx-size 32768

Note the port: 13305, configurable with --port or the LEMONADE_PORT environment variable. This matters more than usual because Lemonade’s port changed during the project’s life — older third-party writeups and even the LiteLLM provider docs show localhost:8000/api/v1 in examples, and Lemonade’s own Continue guide mentions 8020/8040 as ports you might have picked. If a config that worked in someone’s January tutorial dies with connection-refused today, the port is the first suspect — the same triage order as the Ollama connection-refused guide. Both /v1 and /api/v1 prefixes answer, so http://localhost:13305/v1 and http://localhost:13305/api/v1 are the same API.

Sanity-check like every backend in this series:

curl http://localhost:13305/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "Qwen3-Coder-30B-A3B-Instruct-GGUF",
       "messages": [{"role": "user", "content": "Say ready."}]}'
# → {"object":"chat.completion","choices":[{"message":{"role":"assistant","content":"Ready."}}],...}

No API key needed by default — auth is off until you set LEMONADE_API_KEY, at which point every tool config below needs the key.

Step 2 — One port, three API dialects

This is Lemonade’s structural trick, and nothing else in the series does it. The same lemond process on 13305 serves:

• OpenAI-compatible: /v1/chat/completions, /v1/completions, /v1/embeddings, /v1/models, /v1/responses, plus audio, image, and realtime endpoints. Tool calling rides the standard tools parameter, streaming is standard SSE, and the supported-parameter list includes tools, functions, response_format, and logit_bias.
• Ollama-compatible: POST /api/chat, POST /api/generate, GET /api/tags, POST /api/show, POST /api/embed, and the rest of the read-side Ollama surface (/api/create, /api/copy, /api/push return 501). The docs note the Ollama default port 11434 in the context of auto-detection, so tools hardwired to “find Ollama” have a path in.
• Anthropic-compatible: POST /v1/messages, streaming and non-streaming, with system, temperature, and “basic tools” support. Unsupported Anthropic-specific fields “are ignored and surfaced via warning logs/headers” rather than erroring.

For the three tools in this series’ title, the OpenAI dialect is the one you’ll use. But the other two earn their keep fast: the Ollama surface catches every editor plugin that only ships an Ollama provider, and the Anthropic surface is what makes the Claude Code bonus section below a one-liner. There’s an MCP gateway in there too, exposing loaded models to MCP-speaking clients — a different integration style than the MCP servers we’ve covered for coding tools, pointing the protocol at the model rather than at tools.

Step 3 — Context: the sanest default in the series, with one asterisk

Every backend in this series has a context personality. Ollama and llama-server default small and truncate silently — the failure mode behind an entire error-fix article. vLLM and SGLang default to the model maximum and crash loudly at startup. LocalAI ships 512-token bare configs. Lemonade’s documented default is ctx_size: -1, and the configuration docs define it precisely: “the server computes the largest context that fits in available device memory using GGUF architecture metadata.”

That’s the right default, and it’s worth saying so: an agent session on a 24 GB card gets whatever the card can actually hold, not a 4,096-token stub. Two asterisks keep it honest, though. First, “available device memory” is measured on your machine at load time — a GPU already holding a game, a browser, or a second model resolves a smaller window, and the resulting truncation looks like tool-calling flakiness, exactly the symptom chain from the Cline + Ollama tool-loop fix. Second, Lemonade’s own Continue guide tells agent-mode users to set context explicitly (lemonade load <model> --ctx-size 8192 is its example), which reads as the project not fully trusting auto-resolution for agent traffic either.

The practical rule stays the same as the whole series: pin it explicitly and make the tool agree with the server. Load with --ctx-size 32768 (the working agent floor; 65536 if VRAM allows after weights), then set the same number in Cline’s context-window field. You can confirm what the server actually resolved by reading context_length from GET /v1/models/{model_id} — a nicety most backends here don’t offer.

Step 4 — Models that fit

Three catalog entries matter for coding work, all pullable by exact name:

VRAM	Model	Why this one
24 GB	Qwen3-Coder-30B-A3B-Instruct-GGUF	The series’ standard agentic pick (30.5B total, 3.3B active, Apache 2.0); the model Lemonade’s own Continue guide demonstrates with
24 GB	Muse-Glimmer-30B-GGUF	Added to the catalog in v11.6.0 with “draft decoding, vision, and tool-calling support” — draft (speculative) decoding is a real agent-loop speedup no other series backend preconfigures; we reviewed the model itself in the Muse Glimmer 30B guide
32 GB+	Qwen3.5-35B-A3B-GGUF	The model Lemonade’s Claude Code guide reaches for; the bigger sibling when unified memory allows

v11.7.0 added more Qwen and NVIDIA Nemotron entries, and v11.8.0’s lemonade update-models command re-pulls catalog models when upstream GGUFs change — a chore every other backend leaves to you. Models outside the catalog register via lemonade pull with an explicit checkpoint or the v11.7.0 POST /v1/models/register endpoint. The quant universe is GGUF on the llama.cpp recipe, same files Ollama and KoboldCpp use.

No suitable GPU? The same server on a RunPod instance works as a remote backend — swap localhost:13305 for the pod URL in every config below. The broader open-source serving stack is aifoss.dev’s beat.

One hedge worth stating plainly: Lemonade’s documented tool-calling story lives on the OpenAI chat/completions endpoint with llama.cpp-recipe models, and the catalog labels capabilities per model. The NPU recipes (ryzenai, flm) are documented for chat and embeddings — if you’re doing agent work, stay on the GGUF/llama.cpp path and let the NPU handle lighter duty.

Step 5 — Wire in the three tools

Cline: OpenAI Compatible provider

• Provider: OpenAI Compatible
• Base URL: http://localhost:13305/v1
• API Key: any non-empty string unless you’ve set LEMONADE_API_KEY — then the real key
• Model ID: exact catalog name — Qwen3-Coder-30B-A3B-Instruct-GGUF
• Model Configuration: set the context window to the --ctx-size you loaded with, so Cline’s truncation math matches the server’s reality

Cline’s own troubleshooting order — base URL, key, model ID, in that order — applies unchanged, and the model ID is the strictest of the three here: it must match the catalog name character-for-character, capitals included. Turn on Use Compact Prompt for local models, same as every backend in this series.

Continue.dev: actually in the dropdown

Lemonade is one of the few series backends with a first-party Continue integration guide, and the flow uses Continue’s UI rather than YAML surgery: model dropdown → Add Chat Model → select Lemonade Server from the provider list → confirm http://localhost:13305 → pick your pulled model. If you manage config.yaml by hand or need a non-default port, the generic OpenAI-provider shape works identically to the rest of the series:

models:
  - name: Qwen3-Coder 30B (Lemonade)
    provider: openai
    model: Qwen3-Coder-30B-A3B-Instruct-GGUF
    apiBase: http://localhost:13305/v1
    apiKey: none
    roles: [chat, edit, apply]

Lemonade serves embeddings on llama.cpp-recipe models too, so Continue’s @codebase indexing can point at the same server. For agent mode, remember the context pin from Step 3 — that’s the guide’s own advice.

Aider: a native lemonade/ prefix

Aider routes through LiteLLM, and LiteLLM ships a first-party Lemonade provider — so unlike most of this series, there’s no openai/ masquerade needed:

export LEMONADE_API_BASE=http://localhost:13305/api/v1
aider --model lemonade/Qwen3-Coder-30B-A3B-Instruct-GGUF

Two footnotes. LiteLLM’s own doc example still shows the old localhost:8000 default, so set LEMONADE_API_BASE explicitly rather than trusting any default. And if your Aider install is old enough that its pinned LiteLLM predates the provider, you’ll hit the LLM Provider NOT provided crash from the Aider model-not-found guide — either upgrade Aider or fall back to the series-standard escape hatch:

export OPENAI_API_BASE=http://localhost:13305/v1
export OPENAI_API_KEY=none
aider --model openai/Qwen3-Coder-30B-A3B-Instruct-GGUF

Add a .aider.model.metadata.json for context and cost metadata exactly as in the vLLM guide to silence unknown-model warnings.

Bonus: Claude Code in one line

Because Lemonade speaks the Anthropic dialect natively, its Claude Code integration skips the env-var choreography from our Claude Code + Ollama setup entirely:

lemonade launch claude -m Qwen3.5-35B-A3B-GGUF

The docs’ claim is blunt: “Lemonade automatically configures Claude Code to use your local server.” One command, no ANTHROPIC_BASE_URL exports. The usual local-model honesty applies — a 35B quant is not Sonnet-class judgment, and the local-agent limits we documented for Ollama apply here unchanged — but as plumbing, this is the shortest path in the series.

Lemonade vs. the field

	Lemonade	Ollama	LocalAI	vLLM / SGLang
Best for	AMD hardware, NPU laptops, one server serving three API dialects	One dev, zero fuss	One server, many modalities	Throughput and agent loops
Default port	13305	11434	8080	8000 / 30000
API dialects	OpenAI + Ollama + Anthropic + MCP gateway	Ollama + OpenAI subset + Anthropic (recent)	OpenAI + Anthropic + ElevenLabs	OpenAI
Context default	-1: auto-computes largest fit from GGUF metadata	4K-ish, VRAM-scaled (truncates silent)	512 bare / 8K gallery (truncates silent)	Model max (OOMs loud)
NPU path	Yes — XDNA2 via ONNX Runtime GenAI / FLM	No	No	No
The catch	Young and fast-moving; three releases in mid-August, one a regression fix	Hides the knobs	The most YAML	NVIDIA-first, Python stacks

When to skip Lemonade

Skip it on a dedicated NVIDIA inference box where tokens-per-second is the whole game — vLLM and SGLang remain the engines, and Lemonade’s llama.cpp recipe won’t outrun them. Skip it if your setup already runs happily on Ollama and nothing in the triple-API or NPU story tempts you; switching servers to stand still is churn, not progress. And weigh the youth honestly: a project that ships a regression fix within 48 hours is responsive, but you were also the one holding the regression for those 48 hours.

Take it seriously if you’re on AMD hardware — a Ryzen AI laptop, a Strix Halo mini PC, a Radeon card that ROCm treats well — because Lemonade is the first server in this series built by people with a direct stake in that silicon working. Take it seriously too if the one-port triple API solves a real problem for you: one loaded 30B model simultaneously answering Cline over the OpenAI dialect, a legacy Ollama-only plugin over /api/chat, and Claude Code over /v1/messages is a genuinely tidy setup that would otherwise take three servers and three copies of the weights.

FAQ

Is /v1 or /api/v1 the right base path? Both answer on port 13305 — http://localhost:13305/v1 and http://localhost:13305/api/v1 reach the same OpenAI-compatible API. Use /v1 for Cline and Continue; the LiteLLM provider’s examples use /api/v1. What actually breaks configs is the port: older writeups show 8000.

Do I need an API key? Not by default. Auth activates only when LEMONADE_API_KEY is set, and then every request needs it. Cline requires a non-empty key field regardless; any placeholder works against a keyless server.

Does tool calling work for Cline’s agent loop? Yes, on the OpenAI chat/completions endpoint via the standard tools parameter, with llama.cpp-recipe models that support it — Qwen3-Coder-30B-A3B-Instruct-GGUF is the safe pick, and Muse-Glimmer-30B-GGUF gained explicit tool-calling support in v11.6.0. Keep agent work off the NPU recipes.

My session degrades after a few turns — context bug? Check what auto-resolution actually gave you: GET /v1/models/{model_id} reports the live context_length. If the GPU was busy at load time, -1 resolved small. Reload with an explicit --ctx-size 32768 and mirror the number in your tool’s context setting.

Can it really replace Ollama for tools that only support Ollama? For the read-and-chat surface, yes: /api/chat, /api/generate, /api/tags, /api/show, and embeddings are implemented. Model-management writes (/api/create, /api/copy, /api/push) return 501, so tools that create or push Ollama models won’t fully work.

Sources

• Lemonade README — lemonade-sdk/lemonade (GitHub)
• Lemonade releases (v11.8.1 Aug 28, v11.8.0 Aug 26, v11.7.0 Aug 19, v11.6.0 Aug 14 2026)
• Lemonade OpenAI-compatible API — official docs source (GitHub)
• Lemonade Anthropic-compatible API — official docs source (GitHub)
• Lemonade Ollama-compatible API — official docs source (GitHub)
• Lemonade CLI reference (port 13305, —ctx-size, backends) — official docs source (GitHub)
• Lemonade server configuration (ctx_size -1 auto-resolution) — official docs source (GitHub)
• Lemonade + Continue integration guide — official docs source (GitHub)
• Lemonade + Claude Code integration guide — official docs source (GitHub)
• LiteLLM Lemonade provider docs
• Lemonade by AMD: A Unified API for Local AI Developers — AMD technical article
• I switched my local AI setup to AMD’s Lemonade after Nvidia support landed — XDA-Developers
• Cline OpenAI Compatible provider docs
• Continue.dev OpenAI provider (apiBase) docs
• Aider OpenAI-compatible API docs

Last updated August 29, 2026. Pricing and features change frequently; verify current state before purchasing.

Know which coding tool is worth paying for

Hands-on comparisons of AI coding assistants and what each one costs to run — including the local-model path. Sent only when something changes. Unsubscribe anytime.

Email address Subscribe