Integrations

Most tools only need three values: an API key, a base URL, and a model ID. EmpirioLabs exposes OpenAI-compatible chat completions plus an Anthropic-style Messages endpoint, so setup is usually a provider dropdown and one URL change.

Building an integration that other people use? Let them connect their account with Sign in with EmpirioLabs AI instead of pasting a key.

Automation and API tools

ZapierMaken8nPostmanGitHub ActionsWordPress

App frameworks and SDKs

Vercel AI SDKLangChainFabricLiteLLMHaystackMastraNeuroLinkStrands AgentsADKLangflowRAGFlowDifySupabaseRailway

Coding agents and editors

VS CodeClaude CodeCodex CLIOpenCodeClineZedContinueAiderQwen CodeOpenHandsgooseGemini CLICrushKilo CLIFactory DroidHermes AgentOpenClawKilo, Roo, Cursor

Chat apps

Open WebUILibreChatLobeChatTypingMindSillyTavernPersonaLLMbig-AGI

Media, gateways, and routers

ComfyUIOpperMerge GatewayLiquid InferencePhaseoPoeRespanTouchmark

Tools for any agent

MCP serverAgent skills

Fastest setup

The EmpirioLabs AI CLI starts a coding agent already connected to EmpirioLabs AI. It signs you in once, lists the models each agent can run from the live catalog, and leaves the agent’s own settings unchanged.

curl -fsSL https://empiriolabs.ai/install.sh | sh

empirio            # choose an agent and a model
empirio claude     # or start one directly

Install commands for each agent, sign-in options and every command are on the CLI page. For other tools, use the connection values below.

Connection values

Thinking and reasoning controls

EmpirioLabs exposes reasoning controls only on models that list them in their model page or machine-readable schema. Do not send these fields to every model by default.

For OpenAI-compatible Chat Completions and Responses, supported controls can include enable_thinking, thinking_budget, or reasoning_effort, depending on the model:

{
  "model": "qwen3-7-max",
  "messages": [
    { "role": "user", "content": "Answer briefly." }
  ],
  "enable_thinking": false
}

For the Anthropic-style Messages endpoint, use Anthropic-style thinking when the model supports thinking:

{
  "model": "qwen3-7-max",
  "messages": [
    { "role": "user", "content": "Work through this carefully." }
  ],
  "thinking": {
    "type": "enabled",
    "budget_tokens": 1024
  }
}

reasoning_effort accepts none, low, medium, high, and max on every reasoning-capable model. EmpirioLabs normalizes the value into the selected model’s supported reasoning fields, so the same effort string works across model families regardless of whether the model service expects reasoning_effort, enable_thinking, or thinking_budget natively.

{
  "model": "deepseek-v4-pro",
  "messages": [
    { "role": "user", "content": "Solve this carefully." }
  ],
  "reasoning_effort": "max"
}

Tool support varies:

Smoke test

Run this before configuring a larger tool. If this works, your key, credits, network, and model ID are good.

export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
curl "https://api.empiriolabs.ai/v1/chat/completions" \
  -H "Authorization: Bearer $EMPIRIOLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3-7-max",
    "messages": [
      { "role": "user", "content": "Reply with one sentence." }
    ]
  }'

To list current model IDs:

curl "https://api.empiriolabs.ai/v1/models?available=true" \
  -H "Authorization: Bearer $EMPIRIOLABS_API_KEY"

Zapier

The EmpirioLabs AI app for Zapier brings chat, image, video and speech generation, transcription, and embeddings into your Zaps, finds a job by its ID, and starts a Zap when a generation job finishes. Its Run a Tool action runs any other EmpirioLabs AI tool, such as document OCR, web search or image analysis, and lists new tools as they are added.

1. Open EmpirioLabs AI on Zapier and sign in.
2. In a Zap, choose EmpirioLabs AI as the app and connect it with your API key.

The app’s page also has ready-made Zap templates, such as Gmail draft replies, transcriptions of new Google Drive audio files, and Slack summaries of new RSS items.

You can also start a workflow with EmpirioLabs AI right here:

Make

The EmpirioLabs AI app for Make, verified by Make, adds modules for chat completions, embeddings, image, video and speech generation, transcription, jobs, and any other API call, plus a trigger that watches for finished jobs. Its Run a tool module runs any other EmpirioLabs AI tool, such as document OCR, web search or research, and lists new tools as they are added.

1. In a Make scenario, add a module, search for EmpirioLabs AI, and choose the module you need.
2. Create a connection with your API key.

To start from a ready-made scenario, open one of these and choose Use this scenario: meeting notes from Google Drive recordings, a weekly research brief in Slack, images and alt text for a Google Sheets content calendar, or invoice data read from Gmail attachments into Google Sheets.

n8n

The EmpirioLabs AI node for n8n, verified by n8n, adds chat, embeddings, image, video and speech generation, transcription, document reading, web search, jobs, and the model catalog to your workflows, and it works as a tool for the n8n AI Agent. Document > Read returns a PDF or an image as Markdown and plain text, from a binary field or a URL, and Web Search > Search runs a query on any search model. Its trigger starts a workflow when a generation job finishes. The package is n8n-nodes-empiriolabs, and its source is on GitHub.

1. In n8n Cloud, search the nodes panel for EmpirioLabs AI and install the node. In a self-hosted instance, open Settings > Community Nodes, choose Install a community node, enter n8n-nodes-empiriolabs, confirm the notice, and choose Install.
2. Add the EmpirioLabs AI node to a workflow and create an EmpirioLabs AI API credential with your API key.

Ready-made workflows in n8n’s template library:

• Transcribe Google Drive meeting recordings and email notes with EmpirioLabs AI and Gmail
• Post weekly research briefs to Slack with EmpirioLabs AI and data tables
• Create form-based video requests with EmpirioLabs AI, Gmail and Google Drive

Bubble

The EmpirioLabs AI plugin for Bubble adds chat completions, embeddings, image generation, and the model and tool lists to your app’s workflows. Its Run a Tool action runs any other EmpirioLabs AI tool, such as document OCR, web search, or video and speech generation, and new tools are available as soon as they are added.

1. Open the EmpirioLabs AI plugin, choose your app, and select Install.
2. In your app’s Plugins tab, select EmpirioLabs AI and enter Bearer followed by a space and your API key in the API Key field.
3. In a workflow, add an EmpirioLabs AI action, such as Create Chat Completion, and read its result in a later step, for example Result of step 1's choices:first item's message content.

In the prompt, input, and arguments fields, add :formatted as JSON-safe to dynamic text, or type static text in double quotes. Start Image Generation, and Run a Tool for long tasks such as video, return a job_id: run Get Job with it until its status is completed, then read the image from its result.

Postman

The EmpirioLabs AI workspace on Postman has every endpoint of the API reference as a collection with example requests, and a request for the MCP server. The collection updates when the API reference changes.

1. Open the EmpirioLabs AI API collection and choose Fork.
2. In your fork, set the apiKey collection variable to your API key. Keep it in the current value, which Postman never shares.
3. Open any request and choose Send.

To try the MCP server, open EmpirioLabs AI MCP, choose Connect, and sign in with your EmpirioLabs AI account.

GitHub Actions

The EmpirioLabs AI action on GitHub Marketplace sends a prompt to an EmpirioLabs AI model from a workflow, and later steps use the reply: summarize a pull request, draft release notes, or review a file. Its source is EmpirioLabs-AI/empiriolabs-action.

1. In your repository, open Settings > Secrets and variables > Actions. Add your API key as the secret EMPIRIOLABS_API_KEY, and a model ID from Models & Pricing as the variable EMPIRIOLABS_MODEL.
2. Add the action to a job:

- uses: EmpirioLabs-AI/empiriolabs-action@v1.0.0
  id: ai
  with:
    api-key: ${{ secrets.EMPIRIOLABS_API_KEY }}
    model: ${{ vars.EMPIRIOLABS_MODEL }}
    prompt: Explain what a semantic version number is, in two sentences.
- name: Print the reply
  env:
    REPLY: ${{ steps.ai.outputs.text }}
  run: printf '%s\n' "$REPLY"

The step’s outputs are text (the reply), usage (token usage as JSON), and finish-reason. prompt-file sends long input such as a diff or a log, and messages sends a whole conversation. The README has every input and a pull request summary workflow.

WordPress

The EmpirioLabs AI Provider plugin for WordPress adds EmpirioLabs AI to the AI Client in WordPress 7.0 and later. Plugins and features that use the AI Client can then run text, image, speech, and video models, and embedding models on WordPress 7.2 and later. The model list comes from the live catalog.

1. Download empiriolabs-ai-provider.zip from the latest release.
2. In WordPress, open Plugins > Add Plugin, choose Upload Plugin, select the file, and activate the plugin.
3. Open Settings > Connectors, choose Set up next to EmpirioLabs AI, and save your API key.

$text = wp_ai_client_prompt( 'Write a two-sentence welcome message for a bakery website.' )
	->using_provider( 'empiriolabs' )
	->generate_text();

To choose a model, add using_model_preference( 'MODEL_ID' ) with a model ID from Models & Pricing. The README has examples for images, speech, and video.

Vercel AI SDK

Use the AI SDK OpenAI-compatible provider with your EmpirioLabs AI key. Any chat model ID from Models & Pricing works.

npm install ai @ai-sdk/openai-compatible

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';
const empiriolabs = createOpenAICompatible({
  name: 'empiriolabs',
  baseURL: 'https://api.empiriolabs.ai/v1',
  apiKey: process.env.EMPIRIOLABS_API_KEY,
});
const { text } = await generateText({
  model: empiriolabs('qwen3-7-max'),
  prompt: 'Write a haiku about Paris.',
});

streamText and tool calling work the same way. To give an agent EmpirioLabs AI tools, add the AI SDK tools package below for media generation and the model catalog, or connect the AI SDK MCP client to the MCP server for every platform tool, including web search, batches, GPU Cloud and hosted agents.

Vercel integration

Add EmpirioLabs AI on Vercel to give your Vercel projects an EmpirioLabs AI API key as EMPIRIOLABS_API_KEY, so the code above runs on Vercel without copying a key by hand.

1. On the integration’s page, choose Connect Account, then select your Vercel team and the projects the integration can access.
2. Sign in to EmpirioLabs AI if asked, check the projects that should get the key, and choose Connect.

The key is stored as a Vercel Secret for Production, Preview and Development, and each project uses it from its next deployment. Requests made with it are billed to your EmpirioLabs AI account. A project that already has its own EMPIRIOLABS_API_KEY keeps it.

The connection is listed in your Settings under Connected applications. To change which projects have the key, choose Configure on the integration in Vercel, then Change projects. Disconnect it in Settings at any time; removing the integration on Vercel disconnects it too.

Agent template

EmpirioLabs AI Agent is an open-source Next.js agent built on the provider above and the AI SDK MCP client. Chat with any model from the live catalog, and the agent uses the MCP server’s tools for images, video, speech, transcription, documents, web search and more. It reads the tool list on every request, so new tools appear without a code change.

• Deploy on Railway, or see the Railway section.
• Deploy to Vercel with the button in the repository’s README: the Vercel integration can add the key for you.

Leave EMPIRIOLABS_API_KEY unset, and each visitor signs in with their own EmpirioLabs AI account or continues with their own API key. Set it to use one key for every visitor, for a private deployment.

AI SDK tools

The @empiriolabs/ai-sdk package gives AI SDK agents EmpirioLabs AI tools for image generation and editing, video generation, text to speech, transcription, and generation jobs, plus a model finder with prices. Each generation is billed to your EmpirioLabs AI account at the model’s listed price; findModels is free.

npm install @empiriolabs/ai-sdk ai zod @ai-sdk/openai-compatible

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText, isStepCount } from 'ai';
import { empiriolabsTools } from '@empiriolabs/ai-sdk';
const empiriolabs = createOpenAICompatible({
  name: 'empiriolabs',
  baseURL: 'https://api.empiriolabs.ai/v1',
  apiKey: process.env.EMPIRIOLABS_API_KEY,
});
const { text } = await generateText({
  model: empiriolabs('qwen3-8-flash'),
  tools: empiriolabsTools(),
  stopWhen: isStepCount(4),
  prompt:
    'Find a cheap image model, then use it to generate one image of a lighthouse at dawn in watercolor. ' +
    'Reply with the image link.',
});
console.log(text);

When a tool call names no model, the tool uses a featured model for that task. A job that is still running after 5 minutes comes back with a jobId, which the agent passes to checkGenerationJob later. Links to generated files are signed and expire, so download anything you want to keep. The tools read your key from EMPIRIOLABS_API_KEY; run them on your server. Options and result shapes are in the package README.

LangChain

EmpirioLabs AI is a listed provider in LangChain’s Python and JavaScript provider integrations, with ChatEmpirioLabs and EmpirioLabsEmbeddings. The package is langchain-empiriolabs on PyPI, and @empiriolabs/langchain on npm for JavaScript and TypeScript.

pip install langchain-empiriolabs

import os
from langchain_empiriolabs import ChatEmpirioLabs
os.environ["EMPIRIOLABS_API_KEY"] = "sk-empiriolabs-your_key_here"
llm = ChatEmpirioLabs(model="qwen3-8-flash")
print(llm.invoke("Explain backpropagation in one paragraph.").content)

Streaming, tool calling, and EmpirioLabsEmbeddings work the same way as any other LangChain chat model.

In JavaScript and TypeScript, use ChatEmpirioLabs from @empiriolabs/langchain with any chat model ID from Models & Pricing:

npm install @empiriolabs/langchain @langchain/core
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"

import { ChatEmpirioLabs } from '@empiriolabs/langchain';
const llm = new ChatEmpirioLabs({ model: 'qwen3-8-flash' });
const message = await llm.invoke('Explain backpropagation in one paragraph.');
console.log(message.content);

Streaming, bindTools, withStructuredOutput, image input, and EmpirioLabsEmbeddings work the same way on models that support them, and createAgent from langchain accepts the model directly.

LLM CLI

LLM is Simon Willison’s command-line tool for running prompts against language models. The llm-empiriolabs plugin adds EmpirioLabs AI chat models to it.

llm install llm-empiriolabs
llm keys set empiriolabs
llm -m empiriolabs/qwen3-7-max "Explain backpropagation in one paragraph."

llm models list shows each model as empiriolabs/<model-id>. Setting EMPIRIOLABS_API_KEY works instead of llm keys set. The source is in EmpirioLabs-AI/llm-empiriolabs.

Fabric

Fabric is an open-source command-line framework that runs reusable AI prompts, called patterns. EmpirioLabs AI is one of its built-in vendors from version 1.4.557 (danielmiessler/Fabric#2318).

Run fabric --setup, choose EmpirioLabs AI, and paste your API key, or set EMPIRIOLABS_AI_API_KEY in your environment or in ~/.config/fabric/.env. Then:

fabric --listmodels
echo "Explain backpropagation in one paragraph." | fabric -V "EmpirioLabs AI" -m MODEL_ID

fabric --listmodels shows every model in the catalog as EmpirioLabs AI|<model-id>. Replace MODEL_ID with a chat model id from the model catalog, and add -p <pattern> to run one of Fabric’s patterns.

LiteLLM

EmpirioLabs AI is a built-in LiteLLM provider, so the SDK and the LiteLLM Proxy can route to any EmpirioLabs AI chat model with the empiriolabs/ prefix. On LiteLLM versions that predate the provider, use the OpenAI-compatible fallback below.

import os
import litellm
os.environ["EMPIRIOLABS_API_KEY"] = "sk-empiriolabs-your_key_here"
response = litellm.completion(
    model="empiriolabs/qwen3-7-plus",
    messages=[{"role": "user", "content": "Hello!"}],
)

model_list:
  - model_name: qwen3-7-plus
    litellm_params:
      model: empiriolabs/qwen3-7-plus
      api_key: os.environ/EMPIRIOLABS_API_KEY

Older LiteLLM versions (or image generation) can use the OpenAI-compatible route directly:

import os
import litellm
response = litellm.image_generation(
    prompt="A glass cathedral at sunset, dramatic lighting",
    model="openai/seedream-5-0-lite",
    api_base="https://api.empiriolabs.ai/v1",
    api_key=os.environ["EMPIRIOLABS_API_KEY"],
)

The image endpoint returns the finished OpenAI-shaped response.

Haystack

Haystack (by deepset) supports EmpirioLabs AI. Point Haystack’s OpenAI components at https://api.empiriolabs.ai/v1 with your EmpirioLabs key, then use any EmpirioLabs chat or embedding model inside a pipeline. Use OpenAIChatGenerator for chat, since the plain OpenAIGenerator is deprecated.

import os
from haystack.components.generators.chat import OpenAIChatGenerator
from haystack.dataclasses import ChatMessage
from haystack.utils import Secret
os.environ["EMPIRIOLABS_API_KEY"] = "sk-empiriolabs-your_key_here"
generator = OpenAIChatGenerator(
    api_key=Secret.from_env_var("EMPIRIOLABS_API_KEY"),
    api_base_url="https://api.empiriolabs.ai/v1",
    model="qwen3-7-max",
)
response = generator.run(messages=[ChatMessage.from_user("Reply with one sentence.")])
print(response["replies"][0].text)

import os
from haystack.components.embedders import OpenAITextEmbedder
from haystack.utils import Secret
os.environ["EMPIRIOLABS_API_KEY"] = "sk-empiriolabs-your_key_here"
embedder = OpenAITextEmbedder(
    api_key=Secret.from_env_var("EMPIRIOLABS_API_KEY"),
    api_base_url="https://api.empiriolabs.ai/v1",
    model="text-embedding-v4",
)
result = embedder.run(text="Specialized AI model hosting for open, proprietary, and custom stacks.")
print(len(result["embedding"]))

Mastra

Mastra is an open-source TypeScript framework for AI agents and applications. EmpirioLabs AI is a built-in provider in Mastra’s model router: name a model as empiriolabs/<model-id>, and Mastra reads your key from EMPIRIOLABS_API_KEY. Mastra’s EmpirioLabs AI provider page lists the model IDs it offers.

npm install @mastra/core zod
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"

import { Agent } from '@mastra/core/agent';
const agent = new Agent({
  id: 'my-agent',
  name: 'My Agent',
  instructions: 'You are a helpful assistant.',
  model: 'empiriolabs/qwen3-8-flash',
});
const result = await agent.generate('Reply with one sentence.');
console.log(result.text);

NeuroLink

NeuroLink is Juspay’s open-source TypeScript SDK for building AI applications across many model providers. EmpirioLabs AI is a built-in provider: set provider to empiriolabs, and NeuroLink reads your key from EMPIRIOLABS_API_KEY. NeuroLink’s own EmpirioLabs AI guide covers its other options.

npm install @juspay/neurolink
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"

import { NeuroLink } from '@juspay/neurolink';
const neurolink = new NeuroLink();
const result = await neurolink.generate({
  input: { text: 'Reply with one sentence.' },
  provider: 'empiriolabs',
  model: 'qwen3-8-flash',
});
console.log(result.content);

Strands Agents

Strands Agents is an open-source SDK for building AI agents in Python and TypeScript. Point its OpenAI model provider at https://api.empiriolabs.ai/v1 with your EmpirioLabs AI key, and use any chat model ID from Models & Pricing. EmpirioLabs AI is listed in the Strands Agents integrations catalog.

pip install 'strands-agents[openai]'
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"

import os
from strands import Agent
from strands.models.openai import OpenAIModel
model = OpenAIModel(
    client_args={
        "api_key": os.environ["EMPIRIOLABS_API_KEY"],
        "base_url": "https://api.empiriolabs.ai/v1",
    },
    model_id="qwen3-8-flash",
)
agent = Agent(model=model)
agent("Explain tool calling in one sentence.")

In TypeScript:

npm install @strands-agents/sdk openai

import { Agent } from '@strands-agents/sdk';
import { OpenAIModel } from '@strands-agents/sdk/models/openai';
const model = new OpenAIModel({
  api: 'chat',
  apiKey: process.env.EMPIRIOLABS_API_KEY,
  clientConfig: { baseURL: 'https://api.empiriolabs.ai/v1' },
  modelId: 'qwen3-8-flash',
});
const agent = new Agent({ model });
const result = await agent.invoke('Explain tool calling in one sentence.');
console.log(String(result));

Streaming and @tool functions work the same way. To turn thinking off on a reasoning model, pass params={"reasoning_effort": "none"} to OpenAIModel. To give the agent EmpirioLabs AI tools for image, video, speech, and audio generation, connect the MCP server with the same key, for example at the end of agent.py:

from strands.tools.mcp import MCPClient
empiriolabs_mcp = MCPClient(
    url="https://mcp.empiriolabs.ai/mcp/media",
    headers={"Authorization": f"Bearer {os.environ['EMPIRIOLABS_API_KEY']}"},
)
with empiriolabs_mcp:
    agent = Agent(model=model, tools=empiriolabs_mcp.list_tools_sync())
    agent("Generate an image of a lighthouse at dawn and reply with the link.")

Agent Development Kit (ADK)

Agent Development Kit (ADK) is Google’s open-source framework for building AI agents. An ADK agent runs on an EmpirioLabs AI model through LiteLLM, which includes EmpirioLabs AI as a provider, and any ADK agent can use EmpirioLabs AI tools through the MCP server.

pip install "google-adk[extensions]" mcp
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"

import asyncio
from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types
def get_weather(city: str) -> dict:
    """Return a short weather report for a city."""
    return {"city": city, "forecast": "sunny, 22 C"}
root_agent = Agent(
    model=LiteLlm(model="empiriolabs/qwen3-8-flash"),
    name="assistant",
    instruction="You are a concise assistant.",
    tools=[get_weather],
)
async def main():
    session_service = InMemorySessionService()
    session = await session_service.create_session(app_name="demo", user_id="user_1")
    runner = Runner(agent=root_agent, app_name="demo", session_service=session_service)
    message = types.Content(role="user", parts=[types.Part(text="What is the weather in Lisbon?")])
    async for event in runner.run_async(user_id="user_1", session_id=session.id, new_message=message):
        if event.is_final_response():
            print("".join(part.text or "" for part in event.content.parts if not part.thought))
asyncio.run(main())

To give an ADK agent EmpirioLabs AI tools for image, video, speech, and audio generation, add the MCP server to its tools:

import os
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
empiriolabs_tools = McpToolset(
    connection_params=StreamableHTTPConnectionParams(
        url="https://mcp.empiriolabs.ai/mcp/media",
        headers={"Authorization": f"Bearer {os.environ['EMPIRIOLABS_API_KEY']}"},
    ),
)

The /mcp/media path selects the media tools; the MCP server page lists the other profiles.

Langflow

EmpirioLabs AI is a native Langflow integration delivered through Langflow’s official extension bundle system. It adds text and image generation components backed by the live EmpirioLabs model catalog. Follow the official Langflow documentation for installation and setup.

RAGFlow

RAGFlow is an open-source retrieval-augmented generation engine. EmpirioLabs AI is a built-in model provider in its main branch, with chat, embedding, and rerank models.

1. In RAGFlow, open Settings > Model providers, find EmpirioLabs AI, choose Add, and paste your API key.
2. Open Set default models and choose EmpirioLabs AI models, for example qwen3-8-flash for chat, text-embedding-v4 for embedding, and qwen3-rerank for rerank.

Dify

Dify can use EmpirioLabs AI through the EmpirioLabs AI model provider plugin in the Dify Marketplace. Install the plugin, then add your EmpirioLabs API key in the model provider settings.

After installing:

1. Go to Settings > Model Provider.
2. Choose the installed provider.
3. Enter your API key.
4. Select a predefined model, or add another model ID. The full list of model IDs is available from GET /v1/models.

Supabase

Store EmpirioLabs AI embeddings in Supabase, a Postgres development platform, and use the pgvector extension to find the rows closest in meaning to a search query. The examples use text-embedding-v4; any embedding model from Models & Pricing works.

create extension if not exists vector with schema extensions;
create table documents (
  id bigint primary key generated always as identity,
  content text not null,
  embedding extensions.vector(1024) not null
);
alter table documents enable row level security;
create index on documents using hnsw (embedding vector_cosine_ops);
create or replace function match_documents(
  query_embedding extensions.vector(1024),
  match_count int
)
returns table (id bigint, content text, similarity float)
language sql stable
as $$
  select
    documents.id,
    documents.content,
    1 - (documents.embedding <=> query_embedding) as similarity
  from documents
  order by documents.embedding <=> query_embedding
  limit match_count;
$$;
grant select, insert on documents to service_role;
grant execute on function match_documents to service_role;

pip install supabase openai
export SUPABASE_URL="https://your-project.supabase.co"
export SUPABASE_SECRET_KEY="sb_secret_..."
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"

import os
from openai import OpenAI
from supabase import create_client
MODEL = "text-embedding-v4"
empiriolabs = OpenAI(
    api_key=os.environ["EMPIRIOLABS_API_KEY"],
    base_url="https://api.empiriolabs.ai/v1",
)
supabase = create_client(os.environ["SUPABASE_URL"], os.environ["SUPABASE_SECRET_KEY"])
def embed(texts):
    response = empiriolabs.embeddings.create(model=MODEL, input=texts)
    return [item.embedding for item in response.data]
documents = [
    "To reset your password, choose Forgot password on the sign-in page.",
    "Invoices are emailed on the first day of each month.",
    "You can export your data as a CSV file from Settings.",
]
vectors = embed(documents)
supabase.table("documents").insert(
    [{"content": text, "embedding": vector} for text, vector in zip(documents, vectors)]
).execute()
query_embedding = embed(["I am locked out of my account"])[0]
matches = supabase.rpc(
    "match_documents", {"query_embedding": query_embedding, "match_count": 2}
).execute()
for match in matches.data:
    print(f"{match['similarity']:.3f}  {match['content']}")

npm install @supabase/supabase-js openai

import OpenAI from 'openai';
import { createClient } from '@supabase/supabase-js';
const MODEL = 'text-embedding-v4';
const empiriolabs = new OpenAI({
  apiKey: process.env.EMPIRIOLABS_API_KEY,
  baseURL: 'https://api.empiriolabs.ai/v1',
});
const supabase = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_SECRET_KEY);
async function embed(texts) {
  const response = await empiriolabs.embeddings.create({ model: MODEL, input: texts });
  return response.data.map((item) => item.embedding);
}
const documents = [
  'To reset your password, choose Forgot password on the sign-in page.',
  'Invoices are emailed on the first day of each month.',
  'You can export your data as a CSV file from Settings.',
];
const vectors = await embed(documents);
const { error } = await supabase
  .from('documents')
  .insert(documents.map((content, i) => ({ content, embedding: vectors[i] })));
if (error) throw error;
const [queryEmbedding] = await embed(['I am locked out of my account']);
const { data: matches, error: searchError } = await supabase.rpc('match_documents', {
  query_embedding: queryEmbedding,
  match_count: 2,
});
if (searchError) throw searchError;
for (const match of matches) {
  console.log(`${match.similarity.toFixed(3)}  ${match.content}`);
}

The vector size in the table and in match_documents must equal the length of the model’s embeddings: 1,024 for text-embedding-v4, or the size you request with the dimensions parameter. An HNSW index on a vector column supports up to 2,000 dimensions, so request 2,000 or fewer.

Embeddings from different models cannot be compared. If you might switch models, store the model ID with each row, for example in a model column that match_documents filters on.

Railway

Deploy the EmpirioLabs AI Agent on Railway from its template: Deploy on Railway. Railway builds the app from the EmpirioLabs-AI/empiriolabs-agent repository, checks its health before each deployment goes live, and gives it a public domain.

• Leave EMPIRIOLABS_API_KEY empty, and each visitor signs in with their own EmpirioLabs AI account or continues with their own API key.
• Set EMPIRIOLABS_API_KEY to use one key for every visitor, for a private deployment.

VS Code (GitHub Copilot Chat)

The EmpirioLabs AI for Copilot Chat extension adds EmpirioLabs AI as a model provider in GitHub Copilot Chat, with every chat model from the live catalog, streaming, agent mode for models with tool calling, and image input for vision models. It needs VS Code 1.109 or later and works with any Copilot plan; on Copilot Business and Enterprise, an administrator enables the Bring Your Own Language Model Key in VS Code policy.

1. Install EmpirioLabs AI for Copilot Chat from the Extensions view.
2. In the Chat view, open the model picker, select Manage Language Models, then Add Models and EmpirioLabs AI, and paste your API key.
3. Choose an EmpirioLabs AI model in the model picker.

The extension is also published on Open VSX. The source is in EmpirioLabs-AI/vscode-empiriolabs.

Claude Code

empirio claude

empirio claude starts Claude Code on EmpirioLabs AI with every model it can run in /model, and leaves ~/.claude unchanged. To set it up by hand: Claude Code is not an OpenAI-chat-completions client. It talks to LLM gateways through the Anthropic Messages shape, which EmpirioLabs exposes at /v1/messages.

export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
# Claude Code sends ANTHROPIC_AUTH_TOKEN as a Bearer token.
export ANTHROPIC_AUTH_TOKEN="$EMPIRIOLABS_API_KEY"
# Claude Code appends /v1/messages itself, so do not include /v1 here.
export ANTHROPIC_BASE_URL="https://api.empiriolabs.ai"
export ANTHROPIC_CUSTOM_MODEL_OPTION="qwen3-7-max"
export ANTHROPIC_CUSTOM_MODEL_OPTION_NAME="EmpirioLabs AI Qwen3-Max"
export ANTHROPIC_MODEL="qwen3-7-max"
claude

Persistent user-level setup:

{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "sk-empiriolabs-your_key_here",
    "ANTHROPIC_BASE_URL": "https://api.empiriolabs.ai",
    "ANTHROPIC_CUSTOM_MODEL_OPTION": "qwen3-7-max",
    "ANTHROPIC_CUSTOM_MODEL_OPTION_NAME": "EmpirioLabs AI Qwen3-Max",
    "ANTHROPIC_MODEL": "qwen3-7-max"
  }
}

Codex CLI

empirio codex

empirio codex starts Codex with EmpirioLabs AI as its provider for that session, without editing ~/.codex/config.toml. To set it up by hand, add EmpirioLabs AI as a custom model provider in ~/.codex/config.toml:

model = "qwen3-7-max"
model_provider = "empiriolabs"
[model_providers.empiriolabs]
name = "EmpirioLabs AI"
base_url = "https://api.empiriolabs.ai/v1"
env_key = "EMPIRIOLABS_API_KEY"
wire_api = "responses"

Then launch Codex with your key in the environment:

export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
codex

Use this path with EmpirioLabs models that support POST /v1/responses.

OpenCode

EmpirioLabs AI is a built-in provider in OpenCode, listed on models.dev. Run /connect, search for EmpirioLabs AI, and paste your API key, then run /models to choose a model.

empirio opencode starts OpenCode with every EmpirioLabs AI model it can run, without editing opencode.json:

empirio opencode

Manual setup with a file-backed key that survives restarts:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "empiriolabs": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "EmpirioLabs AI",
      "options": {
        "baseURL": "https://api.empiriolabs.ai/v1",
        "apiKey": "{file:.empiriolabs-api-key}"
      },
      "models": {
        "qwen3-7-plus": {
          "name": "EmpirioLabs AI Qwen3.7 Plus"
        },
        "qwen3-7-max": {
          "name": "EmpirioLabs AI Qwen3.7 Max",
          "reasoning": true
        }
      }
    }
  }
}

printf '%s' 'sk-empiriolabs-your_key_here' > .empiriolabs-api-key
printf '\n.empiriolabs-api-key\n' >> .gitignore
opencode

In OpenCode, run /models and choose the EmpirioLabs AI provider. The file-backed key keeps working after you close and reopen OpenCode.

Cline

In the Cline extension UI:

1. Open Cline settings.
2. Set API Provider to OpenAI Compatible.
3. Set Base URL to https://api.empiriolabs.ai/v1.
4. Paste your EmpirioLabs API key.
5. Enter a model ID such as qwen3-7-max.
6. Click Verify, then start a new task.

For Cline CLI:

npm install -g cline
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
cline auth \
  -p openai \
  -k "$EMPIRIOLABS_API_KEY" \
  -b "https://api.empiriolabs.ai/v1" \
  -m "qwen3-7-max"
cline "Inspect this repository and suggest the safest next refactor."

Zed

Zed supports OpenAI-compatible providers in the Agent Panel. Use the UI’s Add Provider flow, or edit settings:

{
  "language_models": {
    "openai_compatible": {
      "EmpirioLabs": {
        "api_url": "https://api.empiriolabs.ai/v1",
        "available_models": [
          {
            "name": "qwen3-7-max",
            "display_name": "EmpirioLabs AI Qwen3-Max",
            "max_tokens": 256000,
            "capabilities": {
              "tools": true,
              "images": false,
              "parallel_tool_calls": false,
              "prompt_cache_key": false
            }
          }
        ]
      }
    }
  }
}

Add the API key through the Agent Panel so Zed stores it in the OS credential store.

Continue

Continue’s OpenAI provider can target any OpenAI-compatible endpoint by setting apiBase. Put secrets in .env or Continue’s secret store rather than committing them into config.yaml.

name: EmpirioLabs
version: 0.0.1
schema: v1
models:
  - name: EmpirioLabs AI Qwen3-Max
    provider: openai
    model: qwen3-7-max
    apiBase: https://api.empiriolabs.ai/v1
    apiKey: ${{ secrets.EMPIRIOLABS_API_KEY }}
    capabilities:
      - tool_use

Add the secret in one of Continue’s supported .env locations:

EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

Aider

empirio aider

To set it up by hand: Aider uses the OpenAI-compatible environment variables. Prefix the model with openai/.

export OPENAI_API_BASE="https://api.empiriolabs.ai/v1"
export OPENAI_API_KEY="sk-empiriolabs-your_key_here"
aider --model openai/qwen3-7-max

Qwen Code

empirio qwen

To set it up by hand, launch Qwen Code directly with EmpirioLabs as the OpenAI-compatible provider:

export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
qwen \
  --auth-type openai \
  --openaiApiKey "$EMPIRIOLABS_API_KEY" \
  --openaiBaseUrl "https://api.empiriolabs.ai/v1" \
  --model "qwen3-7-max"

For persistent project setup:

{
  "model": {
    "name": "qwen3-7-max"
  },
  "security": {
    "auth": {
      "selectedType": "openai"
    }
  },
  "env": {
    "EMPIRIOLABS_API_KEY": "sk-empiriolabs-your_key_here"
  },
  "modelProviders": {
    "openai": [
      {
        "id": "qwen3-7-max",
        "name": "EmpirioLabs AI Qwen3-Max",
        "envKey": "EMPIRIOLABS_API_KEY",
        "baseUrl": "https://api.empiriolabs.ai/v1"
      }
    ]
  }
}

Add .qwen/settings.json to .gitignore if you store the key there.

OpenHands

empirio openhands

To set it up by hand: OpenHands exposes provider settings in the UI and passes them through to its LLM layer.

For the OpenHands CLI, set the three values in the environment and start it with --override-with-envs:

export LLM_MODEL="openai/qwen3-7-max"
export LLM_BASE_URL="https://api.empiriolabs.ai/v1"
export LLM_API_KEY="sk-empiriolabs-your_key_here"
openhands --override-with-envs

goose

EmpirioLabs AI is a built-in provider in goose, so you can pick it directly without writing any custom provider files. It is listed in the goose providers documentation.

Configure it from the goose CLI:

goose configure

1. Select Configure Providers.
2. Choose EmpirioLabs AI from the provider list.
3. Enter your API key when prompted. goose stores it as EMPIRIOLABS_API_KEY.
4. Select the EmpirioLabs AI model you want, for example qwen3-7-max.

Then start a session:

goose session

empirio goose does the same in one step, without goose configure:

empirio goose

Gemini CLI

empirio gemini

Gemini CLI speaks the Gemini API, which EmpirioLabs AI serves at https://api.empiriolabs.ai/v1beta. To set it up by hand, point it at EmpirioLabs AI and choose Use Gemini API Key when it asks how to sign in:

export GEMINI_API_KEY="sk-empiriolabs-your_key_here"
export GOOGLE_GEMINI_BASE_URL="https://api.empiriolabs.ai"
gemini --model <model-id>

Use a model whose page lists POST /v1beta/models/{model}:generateContent. Gemini CLI’s Google Search and web fetch tools do not work with EmpirioLabs AI models; empirio gemini turns them off for its sessions.

Crush

empirio crush

To set up Crush by hand, add EmpirioLabs AI as an OpenAI-compatible provider in crush.json:

{
  "$schema": "https://charm.land/crush.json",
  "providers": {
    "empiriolabs-ai": {
      "name": "EmpirioLabs AI",
      "type": "openai-compat",
      "base_url": "https://api.empiriolabs.ai/v1",
      "api_key": "$EMPIRIOLABS_API_KEY",
      "models": [
        { "id": "<model-id>", "name": "<model name>", "context_window": 256000, "default_max_tokens": 32000 }
      ]
    }
  }
}

Set context_window from the model’s page. empirio crush lists every model Crush can run, with prices, from the live catalog.

Kilo CLI

empirio kilo

empirio kilo starts Kilo CLI with every EmpirioLabs AI model it can run in its model picker. To set it up by hand, add an OpenAI-compatible provider with the connection values in Kilo CLI’s provider settings.

Factory Droid

empirio droid

To set up Factory Droid by hand, add EmpirioLabs AI models to customModels in ~/.factory/settings.json, then choose one with /model:

{
  "customModels": [
    {
      "model": "<model-id>",
      "displayName": "<model name> (EmpirioLabs AI)",
      "provider": "generic-chat-completion-api",
      "baseUrl": "https://api.empiriolabs.ai/v1",
      "apiKey": "${EMPIRIOLABS_API_KEY}",
      "maxOutputTokens": 32000
    }
  ]
}

Hermes Agent

Hermes Agent has an interactive model wizard. Choose Custom endpoint, then enter:

Manual config:

custom_providers:
  - name: empiriolabs
    base_url: https://api.empiriolabs.ai/v1
    key_env: EMPIRIOLABS_API_KEY
model:
  provider: custom:empiriolabs
  default: qwen3-7-max

EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

EmpirioLabs AI plugins for Hermes

Two plugins in the Hermes plugin catalog add EmpirioLabs AI as a built-in model provider, with the chat models that support tool calling (empiriolabs), and as the backend for the Hermes image generation, video generation, and text-to-speech tools (empiriolabs-media). Model lists come from the live catalog. Install them from their source, EmpirioLabs-AI/hermes-empiriolabs:

hermes plugins install EmpirioLabs-AI/hermes-empiriolabs/provider
hermes plugins install EmpirioLabs-AI/hermes-empiriolabs/media

The installer asks for EMPIRIOLABS_API_KEY. Then run hermes model and choose EmpirioLabs AI, and choose EmpirioLabs AI under Image Generation, Video Generation, or Text-to-Speech in hermes tools.

MCP server in Hermes

To use the MCP server tools in Hermes, add the server and sign in with your EmpirioLabs AI account. Remote MCP servers need Hermes’ optional MCP support, the hermes-agent[mcp] extra.

hermes mcp add empiriolabs --url https://mcp.empiriolabs.ai/mcp --auth oauth

Hermes opens your browser to approve the connection. Start a new session so the tools load. To sign in again later, run hermes mcp login empiriolabs.

To use an API key instead, for example on a server without a browser, configure the server with a header:

mcp_servers:
  empiriolabs:
    url: "https://mcp.empiriolabs.ai/mcp"
    headers:
      Authorization: "Bearer ${EMPIRIOLABS_API_KEY}"

OpenClaw

The safest setup is the OpenClaw wizard:

openclaw configure --section model

Choose a custom or OpenAI-compatible provider and use:

For manual JSON5 config, use this as a sidecar or merge it into OpenClaw’s config:

{
  secrets: {
    providers: {
      default: { source: "env" }
    },
    defaults: {
      env: "default"
    }
  },
  models: {
    mode: "merge",
    providers: {
      empiriolabs: {
        baseUrl: "https://api.empiriolabs.ai/v1",
        apiKey: { source: "env", provider: "default", id: "EMPIRIOLABS_API_KEY" },
        authHeader: true,
        api: "openai-completions",
        models: [
          {
            id: "qwen3-7-max",
            name: "EmpirioLabs AI Qwen3-Max",
            input: ["text"],
            contextWindow: 256000
          }
        ]
      }
    }
  },
  agents: {
    defaults: {
      model: {
        primary: "empiriolabs/qwen3-7-max"
      }
    }
  }
}

Run openclaw config validate after manual edits.

EmpirioLabs AI plugin for OpenClaw

The EmpirioLabs AI provider plugin on ClawHub adds the chat models with tool calling, plus image generation, video generation, text to speech, transcription, and embeddings, with every model list loaded from the live catalog. It needs OpenClaw 2026.9.33 or newer:

openclaw plugins install clawhub:@empiriolabs/openclaw-provider
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
openclaw onboard --non-interactive --accept-risk --skip-health --auth-choice empiriolabs-api-key --secret-input-mode ref
openclaw models set empiriolabs/qwen3-7-max

The onboarding step stores a reference to EMPIRIOLABS_API_KEY, not the key itself. The plugin is also on npm as @empiriolabs/openclaw-provider, and the source is in EmpirioLabs-AI/openclaw-provider.

MCP server in OpenClaw

To use the MCP server tools in OpenClaw:

openclaw mcp add empiriolabs --url https://mcp.empiriolabs.ai/mcp --transport streamable-http --header 'Authorization=Bearer ${EMPIRIOLABS_API_KEY}' --no-probe
openclaw mcp probe empiriolabs