How Lemonade Works With Apps and the OpenAI API Standard

Updated

Lemonade works with existing apps because it exposes OpenAI-compatible API endpoints, so any tool already built for the OpenAI API can point at your local Lemonade instance instead. It also ships an embeddable SDK for adding Lemonade directly into your own application, and a Marketplace for finding apps that already integrate it. This applies if you want local, private inference behind apps you already use, or if you are building an app and want to bundle a local AI runtime.

The two integration paths

Lemonade supports two distinct ways to connect, and they serve different needs:

Path What it means Best for
OpenAI API standard Apps that speak the OpenAI API work out-of-box by targeting Lemonade's endpoints Using Lemonade behind hundreds of existing apps without code changes
Embeddable SDK A native or embedded copy of Lemonade inside your app Shipping an app with local AI built in

The site states Lemonade "is integrated in many apps and works out-of-box with hundreds more thanks to the OpenAI API standard." So the first path is mostly configuration, not development.

Using Lemonade behind apps you already have

The mechanism is straightforward: installation equips your computer with an AI runtime plus GUI, CLI, and API endpoints. Those endpoints follow the OpenAI API standard, so an app that lets you set a custom API base URL can be redirected to your local Lemonade server.

The practical steps:

  1. Install Lemonade on your machine (Windows, macOS, Linux via Docker, Snap, Ubuntu, Arch, Fedora, or Debian).
  2. Confirm the local API endpoints are running — installation provides them alongside the GUI and CLI.
  3. In your target app, change the API base URL to your Lemonade endpoint and select a model.
  4. Verify by sending a test request; the expected result is a response served locally rather than from a cloud provider.

The common sticking point is apps that hard-code a provider and don't expose a base URL setting. Those can't be redirected without the app itself adding support — check for a custom endpoint option before assuming compatibility.

Embedding Lemonade in your own app

If you're building rather than configuring, the Embeddable SDK is the route. The site describes it as letting you "add native support or an embedded copy of Lemonade in your app," and the Quick Start is framed around getting "up and running in minutes."

Supporting resources listed on the site:

  • Embeddable SDK — for adding Lemonade into your app
  • API Reference — for the endpoint surface
  • Source on GitHub — for reading and contributing to the implementation

The SDK path matters when you don't want to depend on a separately installed runtime — you ship the capability with the app.

What your app gets

Integration isn't limited to chat. Lemonade is described as omni-modal: your app gets chat, vision, image, speech, transcription, and embeddings. That means a single integration can cover multiple feature types rather than wiring up separate services per modality.

Local-first, with optional routing

Lemonade is local-first on all major platforms, but it can "route to servers and cloud APIs on-demand." In practice this means you can keep inference on-device by default and fall back to remote capacity when you need it, without changing how your app calls the API.

Privacy and openness as integration factors

Two stated properties affect integration decisions:

  • Fully private — transparent, zero telemetry, data stays where you put it, no upsell.
  • Truly open — free to use, shaped in public, built with a community.

For apps handling sensitive data, the zero-telemetry and local-stay claims are the relevant ones. For teams that need to modify or audit the stack, the open-source engines and public roadmap working groups are the relevant ones.

Finding apps that already work

The Marketplace is the entry point for discovering apps with existing Lemonade integration. Beyond that, the OpenAI API standard is what extends compatibility to apps that were never built with Lemonade in mind — they work because they already target that API shape.

Choosing your path

  • You use apps and want local inference behind them → rely on the OpenAI API standard; check each app for a configurable base URL.
  • You're building an app and want AI bundled in → use the Embeddable SDK.
  • You want to see what's already integrated → start with the Marketplace.
  • You need to keep data on-device but occasionally scale → local-first with on-demand routing to servers and cloud APIs.

The deciding question is whether you control the app's code. If you do, the SDK gives you the tightest integration. If you don't, OpenAI API compatibility is your lever — and it only works when the app exposes an endpoint setting.