Inception Labs API

https://docs.inceptionlabs.ai/
Admin
Inception Labs API is a platform providing access to advanced language models like Mercury 2 for...
Tokens:94,540
Snippets:608
Trust Score:9.5
Update:1 day ago
Show doc for...
Tokens:
Raw
### Run the coding agent with environment setup

Source: https://docs.inceptionlabs.ai/cookbooks/coding-agent-mercury-tool-calling

Set the INCEPTION_API_KEY environment variable and run the Python script to execute the coding agent example.

```bash
export INCEPTION_API_KEY="your_api_key_here"
python coding-agent.py
```

--------------------------------

### Install inceptionai TypeScript SDK

Source: https://docs.inceptionlabs.ai/capabilities/next-edit

Installs the official Inception TypeScript SDK via npm. Required for the TypeScript example.

```bash
npm install inceptionai
```

--------------------------------

### Install inceptionai Python SDK

Source: https://docs.inceptionlabs.ai/capabilities/next-edit

Installs the official Inception Python SDK via pip. Required for the Python example.

```bash
pip install inceptionai
```

--------------------------------

### Install dependencies for the search agent

Source: https://docs.inceptionlabs.ai/cookbooks/search-agent-mercury

Install the required Python packages: openai (>=1.0) and httpx. Run this in a Jupyter notebook or Colab environment.

```bash
%pip install -q "openai>=1.0" httpx
```

--------------------------------

### Launch Kilo Code CLI

Source: https://docs.inceptionlabs.ai/integrations/kilo-code

Starts the Kilo Code CLI after configuration.

```bash
kilo
```

--------------------------------

### Install langchain-openai

Source: https://docs.inceptionlabs.ai/integrations/langchain

Install the langchain-openai package, which is required because Mercury is OpenAI-compatible.

```bash
pip install -qU langchain-openai
```

--------------------------------

### Install Inception, ElevenLabs, and audio helper packages

Source: https://docs.inceptionlabs.ai/cookbooks/customer-support-agent-mercury

Installs the inceptionai, elevenlabs, numpy, scipy, and pydub packages via pip. Requires Python environment with pip support.

```bash
%pip install -q "inceptionai" "elevenlabs>=2.15.0" \
    "numpy>=1.26.0" "scipy>=1.16.2" "pydub>=0.25.1"
```

--------------------------------

### Install local LiteLLM bridge

Source: https://docs.inceptionlabs.ai/integrations/claude-code

Sets PYTHON_BIN to a Python 3.11+ executable, verifies the version, creates the mercury-cc directories, and installs the tested LiteLLM version in an isolated virtual environment.

```bash
PYTHON_BIN=python3
"$PYTHON_BIN" --version

mkdir -p "$HOME/.mercury-cc" "$HOME/.local/bin"
chmod 700 "$HOME/.mercury-cc"
"$PYTHON_BIN" -m venv "$HOME/.mercury-cc/.venv"
"$HOME/.mercury-cc/.venv/bin/pip" install 'litellm[proxy]==1.99.0'
```

--------------------------------

### Example state object

Source: https://docs.inceptionlabs.ai/api-reference/decisions/create-a-decision

Example value for the 'state' field in the request body. Contains a message describing the user request.

```json
{
  "message": "Please refund the duplicate charge on my account."
}
```

--------------------------------

### Return tool result in Python

Source: https://docs.inceptionlabs.ai/capabilities/tool-use

Python example using the inceptionai SDK. It defines a get_weather function, sends a user message, processes the model's tool call, executes the function, appends the assistant and tool messages, and calls the API again to get the final response. Requires the tools definition from the previous section.

```python
import json
from inceptionai import Inception

client = Inception()

def get_weather(location: str, unit: str) -> str:
    # Call your real weather API here.
    return json.dumps({"location": location, "unit": unit, "temperature": 18})

messages = [{"role": "user", "content": "What's the weather like in San Francisco?"}]

# First request — the model asks for a tool call.
completion = client.chat.completions.create(
    model="mercury-3",
    messages=messages,
    tools=tools,
)
message = completion.choices[0].message
tool_call = message.tool_calls[0]
args = json.loads(tool_call.function.arguments)

# Execute the function and send the result back.
result = get_weather(**args)
messages.append(message.model_dump(exclude_none=True))
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": result,
})

final = client.chat.completions.create(
    model="mercury-3",
    messages=messages,
    tools=tools,
)
print(final.choices[0].message.content)
```

--------------------------------

### Example questions object

Source: https://docs.inceptionlabs.ai/api-reference/decisions/create-a-decision

Example value for the 'questions' field in the request body. Defines three questions: billing (noul), team (choice), and urgency (score).

```json
{
  "billing": {
    "type": "noul",
    "instructions": "Is this request about billing?"
  },
  "team": {
    "type": "choice",
    "criteria": {
      "billing": "Payments, charges, and refunds",
      "support": "Technical support and other requests"
    }
  },
  "urgency": {
    "type": "score",
    "instructions": "How urgent is this request?",
    "criteria": [
      "Can wait",
      "Needs attention soon",
      "Needs immediate attention"
    ]
  }
}
```

--------------------------------

### Example 200 response

Source: https://docs.inceptionlabs.ai/api-reference/decisions/create-a-decision

Example successful response from the Create a Decision endpoint. Contains the model, answers for each question, and usage token counts.

```json
{ "model": "mercury-decide", "answers": { "billing": { "type": "noul", "noul": 0.97 }, "team": { "type": "choice", "choice": "billing", "probabilities": { "billing": 0.96, "support": 0.04 }, "confidence": 0.96 }, "urgency": { "type": "score", "score": 1.1, "legend": { "0": "Can wait", "1": "Needs attention soon", "2": "Needs immediate attention" }, "probabilities": { "0": 0.1, "1": 0.7, "2": 0.2 }, "confidence": 0.7 } }, "usage": { "input_tokens": 120, "output_tokens": 3 } }
```

--------------------------------

### Install dependencies for Mercury 3 and ElevenLabs

Source: https://docs.inceptionlabs.ai/cookbooks/realtime-voice-assistant

Install the required packages: inceptionai, elevenlabs (>=2.15.0), and python-dotenv (>=1.0.0). Use %pip in a Jupyter notebook or Colab environment.

```bash
%pip install \
    "inceptionai" \
    "elevenlabs>=2.15.0" \
    "python-dotenv>=1.0.0"
```

--------------------------------

### Install dependencies for Mercury 3 SQL agent

Source: https://docs.inceptionlabs.ai/cookbooks/natural-language-sql-agent

Install the required packages: inceptionai and python-dotenv (>=1.0.0).

```bash
%pip install \
  "inceptionai" \
  "python-dotenv>=1.0.0"
```

--------------------------------

### Start Hermes Interactive Session

Source: https://docs.inceptionlabs.ai/integrations/hermes

Launch an interactive session with 'hermes'. The startup message should show 'mercury-3' with the 'custom' provider.

```bash
hermes
```

--------------------------------

### Go: GET /v1/models with net/http

Source: https://docs.inceptionlabs.ai/api-reference/models/list-available-models

Uses Go's net/http package to call the List Available Models endpoint. Replace <token> with your bearer token.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.inceptionlabs.ai/v1/models"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Make launcher executable and link it

Source: https://docs.inceptionlabs.ai/integrations/claude-code

Makes the launcher executable and creates a symbolic link in ~/.local/bin. If that directory is not on PATH, link into another user-writable directory.

```bash
chmod 700 "$HOME/.mercury-cc/mercury-cc"
ln -sf "$HOME/.mercury-cc/mercury-cc" "$HOME/.local/bin/mercury-cc"
```

--------------------------------

### Prompt your model with system and user prompts

Source: https://docs.inceptionlabs.ai/capabilities/tool-use

Sets up the system prompt instructing the model to use tools to explore the repo, and a user prompt asking for the definition of compute_average. Messages list is constructed for the API call.

```python
SYSTEM_PROMPT = (
    "You are a coding assistant with access to a small filesystem via two tools: "
    "`list_directory` and `read_file`. Use tools to explore the repo before answering. "
    "When you have enough information, reply in plain text with the answer."
)

USER_PROMPT = (
    "The repo lives at `/repo`. Find the definition of the function "
    "`compute_average` and quote its body back to me."
)

messages = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": USER_PROMPT},
]
```

--------------------------------

### Return tool result in TypeScript

Source: https://docs.inceptionlabs.ai/capabilities/tool-use

TypeScript example using the inceptionai SDK. It defines a getWeather function, sends a user message, processes the model's tool call, executes the function, appends the assistant and tool messages, and calls the API again to get the final response. Requires the tools definition from the previous section.

```typescript
import Inception from 'inceptionai';

const client = new Inception();

function getWeather(location: string, unit: string): string {
  // Call your real weather API here.
  return JSON.stringify({ location, unit, temperature: 18 });
}

const messages = [
  { role: 'user' as const, content: "What's the weather like in San Francisco?" },
];

// First request — the model asks for a tool call.
const completion = await client.chat.completions.create({
  model: 'mercury-3',
  messages,
  tools,
});
const message = completion.choices[0].message;
const toolCall = message.tool_calls![0];
const args = JSON.parse(toolCall.function.arguments);

// Execute the function and send the result back.
const result = getWeather(args.location, args.unit);
const finalMessages = [
  ...messages,
  message,
  {
    role: 'tool' as const,
    tool_call_id: toolCall.id,
    content: result,
  },
];

const final = await client.chat.completions.create({
  model: 'mercury-3',
  messages: finalMessages,
  tools,
});
console.log(final.choices[0]?.message.content);
```

--------------------------------

### Initialize ElevenLabs client and define synthesis helper

Source: https://docs.inceptionlabs.ai/cookbooks/customer-support-agent-mercury

Sets up the ElevenLabs client with the API key from environment variables and defines a synth function to convert text to speech using the eleven_turbo_v2_5 model. The function writes the audio to an mp3 file and returns the raw bytes.

```python
from elevenlabs import ElevenLabs
from IPython.display import Audio, display

eleven = ElevenLabs(api_key=os.environ["ELEVENLABS_API_KEY"],
                    base_url="https://api.elevenlabs.io")

CALLER_VOICE = "21m00Tcm4TlvDq8ikWAM"   # Rachel  - stands in for the caller
AGENT_VOICE  = "IKne3meq5aSn9XLyUdCD"   # Charlie - the clinic receptionist
TTS_MODEL    = "eleven_turbo_v2_5"
STT_MODEL    = "scribe_v1"

def synth(text, voice_id, path):
    """Synthesize `text` to an mp3 file and return the raw bytes."""
    audio = eleven.text_to_speech.convert(
        voice_id=voice_id,
        model_id=TTS_MODEL,
        text=text,
        output_format="mp3_44100_128",
    )
    data = b"".join(audio)
    with open(path, "wb") as f:
        f.write(data)
    return data

print("ElevenLabs client ready.")
```

--------------------------------

### Install Hermes Agent

Source: https://docs.inceptionlabs.ai/integrations/hermes

Install Hermes Agent on macOS, Linux, or WSL2 using the provided curl command. Open a new terminal after installation to use the 'hermes' command.

```bash
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
```

--------------------------------

### Set up API keys and initialize Inception client

Source: https://docs.inceptionlabs.ai/cookbooks/customer-support-agent-mercury

Reads INCEPTION_API_KEY and ELEVENLABS_API_KEY from environment variables, prompting for missing ones via getpass. Initializes the Inception client with the mercury-3 model. Nothing is written to disk.

```python
import os
import json
import getpass
import time
import sqlite3
from datetime import datetime, timedelta

from inceptionai import Inception

for var in ("INCEPTION_API_KEY", "ELEVENLABS_API_KEY"):
    if not os.environ.get(var):
        os.environ[var] = getpass.getpass(f"{var}: ")

client = Inception(api_key=os.environ["INCEPTION_API_KEY"])
MERCURY_MODEL = "mercury-3"

print("Inception client ready. Model:", MERCURY_MODEL)
```

--------------------------------

### Configure API keys and model settings

Source: https://docs.inceptionlabs.ai/cookbooks/search-agent-mercury

Set the search backend (exa or parallel), define backend key environment variables, prompt for missing API keys, and set the Inception base URL and model. Only the key for the selected backend is prompted for.

```python
SEARCH_BACKEND = "exa"        # "exa" or "parallel"

BACKEND_KEYS = {"exa": "EXA_API_KEY", "parallel": "PARALLEL_API_KEY"}

for var in ("INCEPTION_API_KEY", BACKEND_KEYS[SEARCH_BACKEND]):
    if not os.environ.get(var):
        os.environ[var] = getpass.getpass(f"{var}: ")

INCEPTION_BASE_URL = "https://api.inceptionlabs.ai/v1"   # OpenAI-compatible
MODEL = "mercury-3"
```

--------------------------------

### Results: Step 1 tool call and output

Source: https://docs.inceptionlabs.ai/capabilities/tool-use

First tool call from the model: list_directory on /repo. The output shows the directory entries.

```plaintext
{'name': 'list_directory', 'arguments': '{"path": "/repo"}'}
```

```plaintext
{"path": "/repo", "entries": ["main.py", "stats.py", "README.md"]}
```

--------------------------------

### Create in-memory SQLite database with sample e-commerce tables

Source: https://docs.inceptionlabs.ai/cookbooks/natural-language-sql-agent

Creates an in-memory SQLite database with customers, products, and orders tables, and populates them with sample data. To use your own database, replace the connection line with sqlite3.connect('your_file.db').

```python
# To use your own SQLite database instead, replace this cell with:
#   db = sqlite3.connect("path/to/your/database.db")

db = sqlite3.connect(":memory:")
cursor = db.cursor()
cursor.executescript("""
CREATE TABLE customers (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT NOT NULL,
    signup_date TEXT NOT NULL
);

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    category TEXT NOT NULL,
    price REAL NOT NULL,
    stock INTEGER NOT NULL
);

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer_id INTEGER NOT NULL,
    product_id INTEGER NOT NULL,
    quantity INTEGER NOT NULL,
    total_amount REAL NOT NULL,
    status TEXT NOT NULL,
    order_date TEXT NOT NULL,
    FOREIGN KEY (customer_id) REFERENCES customers(id),
    FOREIGN KEY (product_id) REFERENCES products(id)
);

INSERT INTO customers VALUES (1, 'Alice Johnson', '[email protected]', '2024-01-15');
INSERT INTO customers VALUES (2, 'Bob Smith', '[email protected]', '2024-02-20');
INSERT INTO customers VALUES (3, 'Sarah Lee', '[email protected]', '2024-03-10');
INSERT INTO customers VALUES (4, 'Mike Chen', '[email protected]', '2024-04-05');
INSERT INTO customers VALUES (5, 'Emma Wilson', '[email protected]', '2024-05-12');

INSERT INTO products VALUES (1, 'Wireless Headphones', 'Electronics', 79.99, 45);
INSERT INTO products VALUES (2, 'Running Shoes', 'Sports', 129.99, 30);
INSERT INTO products VALUES (3, 'Coffee Maker', 'Home & Kitchen', 49.99, 60);
INSERT INTO products VALUES (4, 'Backpack', 'Accessories', 59.99, 25);
INSERT INTO products VALUES (5, 'Yoga Mat', 'Sports', 29.99, 80);
INSERT INTO products VALUES (6, 'Desk Lamp', 'Home & Kitchen', 34.99, 55);
INSERT INTO products VALUES (7, 'Water Bottle', 'Accessories', 19.99, 100);
INSERT INTO products VALUES (8, 'Bluetooth Speaker', 'Electronics', 99.99, 35);

INSERT INTO orders VALUES (1, 1, 1, 1, 79.99, 'delivered', '2025-01-10');
INSERT INTO orders VALUES (2, 1, 3, 2, 99.98, 'delivered', '2025-01-15');
INSERT INTO orders VALUES (3, 2, 2, 1, 129.99, 'shipped', '2025-02-01');
INSERT INTO orders VALUES (4, 3, 5, 2, 59.98, 'delivered', '2025-02-10');
INSERT INTO orders VALUES (5, 3, 1, 1, 79.99, 'delivered', '2025-02-14');
INSERT INTO orders VALUES (6, 4, 8, 1, 99.99, 'pending', '2025-03-01');
INSERT INTO orders VALUES (7, 4, 4, 1, 59.99, 'pending', '2025-03-05');
INSERT INTO orders VALUES (8, 5, 6, 2, 69.98, 'shipped', '2025-03-08');
INSERT INTO orders VALUES (9, 2, 7, 3, 59.97, 'delivered', '2025-03-10');
INSERT INTO orders VALUES (10, 1, 8, 1, 99.99, 'pending', '2025-03-12');
INSERT INTO orders VALUES (11, 5, 3, 1, 49.99, 'delivered', '2025-01-20');
INSERT INTO orders VALUES (12, 3, 7, 2, 39.98, 'shipped', '2025-03-14');
""")
db.commit()
```

--------------------------------

### Import libraries for the search agent

Source: https://docs.inceptionlabs.ai/cookbooks/search-agent-mercury

Import the necessary Python modules: asyncio, getpass, json, os, re, time, httpx, AsyncOpenAI, and IPython display utilities. This is the standard setup for the agent.

```python
import asyncio, getpass, json, os, re, time

import httpx
from openai import AsyncOpenAI
from IPython.display import Markdown, display
```

--------------------------------

### Make first request with Python SDK

Source: https://docs.inceptionlabs.ai/get-started/sdks

Create a chat completion using the Python client with the mercury-3 model and print the response content.

```python
from inceptionai import Inception

client = Inception()

completion = client.chat.completions.create(
    model="mercury-3",
    messages=[{"role": "user", "content": "What is a diffusion model?"}],
)
print(completion.choices[0].message.content)
```

--------------------------------

### Initialize clients and define Mercury completion functions

Source: https://docs.inceptionlabs.ai/cookbooks/realtime-voice-assistant

Sets up the Inception and ElevenLabs clients after asserting API keys exist. Defines mercury_completion for non-streaming and mercury_stream for streaming responses, both using the mercury-3 model with low reasoning effort.

```python
assert INCEPTION_API_KEY is not None, (
    "ERROR: INCEPTION_API_KEY not found. Please copy .env.example to .env and add your API keys."
)
assert ELEVENLABS_API_KEY is not None, (
    "ERROR: ELEVENLABS_API_KEY not found. Please copy .env.example to .env and add your API keys."
)

mercury_client = Inception(api_key=INCEPTION_API_KEY)
elevenlabs_client = elevenlabs.ElevenLabs(
    api_key=ELEVENLABS_API_KEY, base_url="https://api.elevenlabs.io"
)

MERCURY_MODEL = "mercury-3"
VOICE_ID = "21m00Tcm4TlvDq8ikWAM"  # Rachel

def mercury_completion(user_text, max_completion_tokens=1000, temperature=0.75):
    return mercury_client.chat.completions.create(
        model=MERCURY_MODEL,
        messages=[{"role": "user", "content": user_text}],
        max_completion_tokens=max_completion_tokens,
        temperature=temperature,
        reasoning_effort="low",
    )


def mercury_stream(user_text, max_completion_tokens=1000, temperature=0.75):
    stream = mercury_client.chat.completions.create(
        model=MERCURY_MODEL,
        messages=[{"role": "user", "content": user_text}],
        max_completion_tokens=max_completion_tokens,
        temperature=temperature,
        reasoning_effort="low",
        stream=True,
    )

    for chunk in stream:
        if not chunk.choices:
            continue
        text = chunk.choices[0].delta.content
        if text:
            yield text
```

--------------------------------

### GET /v1/models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-available-models

Lists the models currently available through the API. Requires authentication via bearer token.

```APIDOC
## GET /v1/models

### Description
List the models currently available through the API.

### Method
GET

### Endpoint
/v1/models

### Authentication
Bearer token required. Use `Authorization: Bearer <token>` header.

### Request Example
No request body required.

### Response
#### Success Response (200)
Returns a list of available models.

#### Response Example
(No example provided in source)

### Error Responses
- **401** - Unauthorized
- **500** - Internal Server Error
```

--------------------------------

### GET /v1/chat/completions/models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-chat-models

Lists all models available for chat completions. This endpoint requires authentication via a bearer token.

```APIDOC
## GET /v1/chat/completions/models

### Description
List models available for chat completions.

### Method
GET

### Endpoint
https://api.inceptionlabs.ai/v1/chat/completions/models

### Authentication
- **Authorization** (string) - Required - Bearer token for authentication.

### Request Example
```
curl --request GET \
  --url https://api.inceptionlabs.ai/v1/chat/completions/models \
  --header 'Authorization: Bearer <token>'
```

### Response
#### Success Response (200)
Returns a list of chat models.

#### Error Responses
- **401** - Unauthorized
- **500** - Internal Server Error

```

--------------------------------

### GET /v1/chat/completions/models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-chat-models

Retrieves a list of available chat models. This endpoint requires authentication via a bearer token.

```APIDOC
## GET /v1/chat/completions/models

### Description
Retrieves a list of available chat models.

### Method
GET

### Endpoint
https://api.inceptionlabs.ai/v1/chat/completions/models

### Parameters
#### Headers
- **Authorization** (string) - Required - Bearer token for authentication.

### Request Example
No request body required.

### Response
#### Success Response (200)
Returns a list of chat models.

#### Error Responses
- **401** - Unauthorized - Invalid or missing authentication token.
- **500** - Internal Server Error - An unexpected error occurred.

### Response Example
No example response body provided in the source.
```

--------------------------------

### Run your agent loop

Source: https://docs.inceptionlabs.ai/capabilities/tool-use

Sets up API URL, model, and headers, then runs a loop for up to 3 turns. The payload includes model, messages, and tools. The loop comments indicate steps to parse tool calls, execute them, and append results.

```python
# setup
API_URL = "https://api.inceptionlabs.ai/v1/chat/completions"
MODEL = "mercury-3"
HEADERS = {
    "Authorization": f"Bearer {os.environ['INCEPTION_API_KEY']}",
    "Content-Type": "application/json",
}

# agent loop
for turn in range(3):
    payload = {
        "model": MODEL,
        "messages": messages,
        "tools": TOOLS,
    }
    body = requests.post(API_URL, headers=HEADERS, json=payload).json()
    # 1. parse body for content and tool_calls.
    # 2. execute tools in tool_calls.
    # 3. append model output and tool call results to messages.
```

--------------------------------

### Success response: List edit models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-edit-models

Example 200 response containing a list of edit models. Shows the model metadata including id, name, context_length, pricing, and supported_endpoints.

```json
{
  "data": [
    {
      "id": "mercury-edit-2",
      "name": "Inception: Mercury Edit 2",
      "created": 1745798400,
      "description": "Mercury Edit 2 for code edit completions and fill-in-the-middle code completions.",
      "input_modalities": [
        "text"
      ],
      "output_modalities": [
        "text"
      ],
      "context_length": 128000,
      "max_output_length": 32000,
      "pricing": {
        "prompt": "0.00000025",
        "completion": "0.00000075",
        "input_cache_reads": "0.000000025",
        "input_cache_writes": "0"
      },
      "supported_sampling_parameters": [
        "temperature",
        "stop"
      ],
      "supported_features": [],
      "supported_endpoints": [
        "edit.completions",
        "fim.completions"
      ],
      "openrouter": {
        "slug": "inception/mercury-edit-2"
      },
      "datacenters": [
        {
          "country_code": "US"
        }
      ]
    }
  ]
}
```

--------------------------------

### Go: List edit models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-edit-models

Uses net/http to GET the edit models endpoint. Replace <token> with your API key.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.inceptionlabs.ai/v1/edit/completions/models"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Verify OpenClaw setup

Source: https://docs.inceptionlabs.ai/integrations/open-claw

Checks that the Inception provider and model appear, and confirms primary model, auth status, and provider endpoint. Expect to see inception/mercury-3 listed as primary with valid auth.

```bash
# Check that the Inception provider and model appear
openclaw models list

# Confirm primary model, auth status, and provider endpoint
openclaw models status
```

--------------------------------

### Create mercury-cc launcher script

Source: https://docs.inceptionlabs.ai/integrations/claude-code

Creates the ~/.mercury-cc/mercury-cc launcher script. It starts a local LiteLLM proxy, sets the required environment variables, and executes claude with the passed arguments. Supports --stop to stop the bridge.

```bash
#!/usr/bin/env bash
set -euo pipefail

mercury_home="$HOME/.mercury-cc"
key_file="${mercury_home}/api-key"
pid_file="${mercury_home}/proxy.pid"
port="${MERCURY_CC_PORT:-4000}"
proxy_url="http://127.0.0.1:${port}"

proxy_ready() {
  curl -fsS "${proxy_url}/v1/models" 2>/dev/null \
    | grep -q 'inception/mercury-3'
}

if [[ "${1:-}" == "--stop" ]]; then
  if [[ ! -f "$pid_file" ]]; then
    echo "Mercury bridge is not running."
    exit 0
  fi

  read -r pid < "$pid_file"
  if kill -0 "$pid" 2>/dev/null; then
    kill "$pid" 2>/dev/null || true
    echo "Mercury bridge stopped."
  else
    echo "Mercury bridge is already stopped."
  fi
  rm -f "$pid_file"
  exit 0
fi

if [[ ! -s "$key_file" ]]; then
  echo "Inception API key not found at ${key_file}" >&2
  exit 1
fi

if ! proxy_ready; then
  INCEPTION_API_KEY="$(<"$key_file")" \
    nohup "${mercury_home}/.venv/bin/litellm" \
      --model inception/mercury-3 \
      --alias mercury \
      --drop_params \
      --host 127.0.0.1 \
      --port "$port" \
      >"${mercury_home}/proxy.log" 2>&1 &
  echo "$!" > "$pid_file"

  for _ in {1..60}; do
    proxy_ready && break
    sleep 0.25
  done
fi

if ! proxy_ready; then
  echo "Mercury bridge failed to start. See ${mercury_home}/proxy.log" >&2
  exit 1
fi

export ANTHROPIC_BASE_URL="$proxy_url"
export ANTHROPIC_AUTH_TOKEN="mercury-local"
unset ANTHROPIC_API_KEY

export ANTHROPIC_MODEL="mercury"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="mercury"
export ANTHROPIC_DEFAULT_SONNET_MODEL="mercury"
export ANTHROPIC_DEFAULT_OPUS_MODEL="mercury"
export CLAUDE_CODE_SUBAGENT_MODEL="mercury"
export CLAUDE_CODE_MAX_CONTEXT_TOKENS=1000000

exec claude "$@"
```

--------------------------------

### cURL: List edit models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-edit-models

Sends a GET request to the edit models endpoint. Replace <token> with your API key.

```bash
curl --request GET \
  --url https://api.inceptionlabs.ai/v1/edit/completions/models \
  --header 'Authorization: Bearer <token>'
```

--------------------------------

### cURL: GET /v1/models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-available-models

Direct HTTP request to the List Available Models endpoint. Replace <token> with your bearer token.

```bash
curl --request GET \
  --url https://api.inceptionlabs.ai/v1/models \
  --header 'Authorization: Bearer <token>'
```

--------------------------------

### ask_database: Full Tool-Calling Loop for Natural Language SQL

Source: https://docs.inceptionlabs.ai/cookbooks/natural-language-sql-agent

Implements the complete tool-calling loop: sends the user's question to Mercury 3 with the tool definition, executes the generated SQL, sends the result back to Mercury 3, and returns a natural language answer. Times each step to provide a latency breakdown. Requires a configured client, MERCURY_MODEL, tools, and tool_functions.

```python
def ask_database(question: str) -> dict:
    """
    Full tool-calling loop: question -> Mercury 3 tool call -> SQL exec -> Mercury 3 answer.
    Returns timing breakdown and the final answer.
    """
    messages = [{"role": "user", "content": question}]

    # Step 1: Mercury 3 generates a tool call
    t0 = time.time()
    response = client.chat.completions.create(
        model=MERCURY_MODEL,
        messages=messages,
        tools=tools,
    )
    t1 = time.time()

    assistant_message = response.choices[0].message
    tool_call = assistant_message.tool_calls[0]
    function_name = tool_call.function.name
    function_args = json.loads(tool_call.function.arguments)

    print(f"Generated SQL: {function_args['query']}")

    # Step 2: Execute the SQL
    t2 = time.time()
    result = tool_functions[function_name](**function_args)
    t3 = time.time()

    print(f"Query result:\n{result}")

    # Step 3: Send tool result back to Mercury 3 for a natural language answer
    messages.append(assistant_message.model_dump(exclude_none=True))
    messages.append(
        {
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result,
        }
    )

    t4 = time.time()
    response = client.chat.completions.create(
        model=MERCURY_MODEL,
        messages=messages,
    )
    t5 = time.time()

    final_answer = response.choices[0].message.content

    timing = {
        "tool_call_generation": round(t1 - t0, 3),
        "sql_execution": round(t3 - t2, 3),
        "answer_generation": round(t5 - t4, 3),
        "total": round(t5 - t0, 3),
    }

    return {"answer": final_answer, "sql": function_args["query"], "timing": timing}
```

--------------------------------

### Error response: 500 server_error

Source: https://docs.inceptionlabs.ai/api-reference/models/list-edit-models

Example 500 response when the server encounters an error. The error type is server_error and code is server_error.

```json
{
  "error": {
    "message": "The server had an error while processing your request.",
    "type": "server_error",
    "param": null,
    "code": "server_error"
  }
}
```

--------------------------------

### GET /v1/edit/completions/models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-edit-models

Lists all available edit completion models. This endpoint is used to discover which models are available for edit and fill-in-the-middle completions.

```APIDOC
## GET /v1/edit/completions/models

### Description
Retrieves a list of available edit completion models.

### Method
GET

### Endpoint
https://api.inceptionlabs.ai/v1/edit/completions/models

### Authentication
Bearer token required. Provide your API key in the Authorization header.

### Request Example
No request body required.

### Response
#### Success Response (200)
Returns a JSON object with a `data` array containing model objects. Each model object includes:
- **id** (string) - The model identifier.
- **name** (string) - The display name of the model.
- **created** (integer) - Unix timestamp of model creation.
- **description** (string) - Description of the model's capabilities.
- **input_modalities** (array of strings) - Input types supported (e.g., "text").
- **output_modalities** (array of strings) - Output types supported (e.g., "text").
- **context_length** (integer) - Maximum context length in tokens.
- **max_output_length** (integer) - Maximum output length in tokens.
- **pricing** (object) - Pricing details with fields: `prompt`, `completion`, `input_cache_reads`, `input_cache_writes`.
- **supported_sampling_parameters** (array of strings) - Sampling parameters supported (e.g., "temperature", "stop").
- **supported_features** (array) - Additional supported features.
- **supported_endpoints** (array of strings) - Endpoints the model supports (e.g., "edit.completions", "fim.completions").
- **openrouter** (object) - OpenRouter integration details, including `slug`.
- **datacenters** (array of objects) - Datacenter locations, each with `country_code`.

#### Response Example
```json
{
  "data": [
    {
      "id": "mercury-edit-2",
      "name": "Inception: Mercury Edit 2",
      "created": 1745798400,
      "description": "Mercury Edit 2 for code edit completions and fill-in-the-middle code completions.",
      "input_modalities": ["text"],
      "output_modalities": ["text"],
      "context_length": 128000,
      "max_output_length": 32000,
      "pricing": {
        "prompt": "0.00000025",
        "completion": "0.00000075",
        "input_cache_reads": "0.000000025",
        "input_cache_writes": "0"
      },
      "supported_sampling_parameters": ["temperature", "stop"],
      "supported_features": [],
      "supported_endpoints": ["edit.completions", "fim.completions"],
      "openrouter": {
        "slug": "inception/mercury-edit-2"
      },
      "datacenters": [
        {
          "country_code": "US"
        }
      ]
    }
  ]
}
```

#### Error Responses
- **401 Unauthorized**: Invalid API key.
  ```json
  {
    "error": {
      "message": "Incorrect API key provided",
      "type": "authentication_error",
      "param": null,
      "code": "invalid_api_key"
    }
  }
  ```
- **500 Internal Server Error**: Server error.
  ```json
  {
    "error": {
      "message": "The server had an error while processing your request.",
      "type": "server_error",
      "param": null,
      "code": "server_error"
    }
  }
  ```
```

--------------------------------

### Ruby: List edit models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-edit-models

Uses Net::HTTP to GET the edit models endpoint. Replace <token> with your API key.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.inceptionlabs.ai/v1/edit/completions/models")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

--------------------------------

### Initialize Inception (Mercury 3) client

Source: https://docs.inceptionlabs.ai/cookbooks/natural-language-sql-agent

Initializes the Inception client with the API key from environment variables. Requires INCEPTION_API_KEY to be set, otherwise raises an error. Sets the model to 'mercury-3'.

```python
assert INCEPTION_API_KEY is not None, (
    "ERROR: INCEPTION_API_KEY not found. Please create a .env file and add your API key."
)

client = Inception(api_key=INCEPTION_API_KEY)
MERCURY_MODEL = "mercury-3"
```

--------------------------------

### Java Unirest: List edit models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-edit-models

Uses Unirest to GET the edit models endpoint. Replace <token> with your API key.

```java
HttpResponse<String> response = Unirest.get("https://api.inceptionlabs.ai/v1/edit/completions/models")
  .header("Authorization", "Bearer <token>")
  .asString();
```

--------------------------------

### JavaScript fetch: List edit models

Source: https://docs.inceptionlabs.ai/api-reference/models/list-edit-models

Uses fetch to GET the edit models endpoint. Replace <token> with your API key.

```javascript
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.inceptionlabs.ai/v1/edit/completions/models', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```
Tokens:
Raw