### Zsh Shell Completion Setup

Source: https://melious.ai/docs/cli/reference

Install Zsh completions by ensuring `compinit` is loaded in your ~/.zshrc, then directing the output of `melious completion zsh` to a file in your fpath.

```zsh
# Enable completions if not already
écho "autoload -U compinit; compinit" >> ~/.zshrc

# Install completion
melious completion zsh > "${fpath[1]}/_melious"
source ~/.zshrc
```

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

### Install uv

Source: https://melious.ai/docs/integrations/vibe

Troubleshoot `uv: command not found` by installing uv first using its official installer script.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

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

### Install OpenCode via npm

Source: https://melious.ai/docs/cli/launch

Install the OpenCode tool using npm. Requires Node.js and npm to be installed.

```bash
npm install -g opencode-ai
```

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

### Install OpenClaw on macOS, Linux, WSL2

Source: https://melious.ai/docs/integrations/openclaw

Use this command to install OpenClaw on macOS, Linux, or WSL2. It handles Node.js setup if necessary.

```bash
curl -fsSL https://openclaw.ai/install.sh | bash
```

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

### Get Tool Information

Source: https://melious.ai/docs/cli/tools

Displays detailed information about a specific tool, including its description, homepage, installation status, version, command, prerequisites, and configured model.

```bash
melious tools info opencode
```

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

### OpenCode Configuration File Example

Source: https://melious.ai/docs/integrations/opencode

Example of an `opencode.json` configuration file. This file specifies the model, provider, and API key for OpenCode.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "model": "melious/<MODEL_ID>",
  "small_model": "melious/<SMALL_MODEL_ID>",
  "provider": {
    "melious": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Melious",
      "options": {
        "baseURL": "https://api.melious.ai/v1",
        "apiKey": "{env:MELIOUS_API_KEY}"
      },
      "models": {
        "<MODEL_ID>": {
          "name": "<Display Name>",
          "limit": { "context": 128000, "output": 16384 }
        }
      }
    }
  }
}
```

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

### Install Claude Code using Melious CLI

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

Use the Melious CLI to install Claude Code and launch a session. This method handles environment variable setup automatically.

```bash
melious tools install claude-code
melious launch claude-code
```

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

### Install OpenCode

Source: https://melious.ai/docs/cli/launch

Install the OpenCode tool using a bash script. This is the recommended method for macOS and Linux.

```bash
curl -fsSL https://opencode.ai/install | bash
```

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

### Install Mistral Vibe with uv

Source: https://melious.ai/docs/cli/launch

Install Mistral Vibe using the 'uv' tool. This is an alternative installation method that requires 'uv' to be installed.

```bash
uv tool install mistral-vibe
```

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

### Install Vibe using Melious CLI

Source: https://melious.ai/docs/integrations/vibe

Use the Melious CLI to install Vibe and its prerequisites, and set up configuration files.

```bash
melious tools install vibe
melious launch vibe
```

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

### Install a Specific Tool

Source: https://melious.ai/docs/cli/tools

Installs a single specified tool, checking for and potentially fixing prerequisites like Node.js or uv.

```bash
melious tools install opencode
```

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

### Install Melious CLI (Windows CMD)

Source: https://melious.ai/docs/cli

Installs the Melious CLI using Command Prompt. The installation is added to your PATH and does not require admin privileges.

```cmd
curl -fsSL https://cdn.melious.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
```

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

### Install Pi Coding Agent

Source: https://melious.ai/docs/integrations/pi

Install the Pi coding agent globally using npm. This is the documented installation method and requires Node.js.

```bash
npm install -g @mariozechner/pi-coding-agent
```

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

### Install OpenCode with Melious CLI

Source: https://melious.ai/docs/integrations/opencode

Use the Melious CLI to install OpenCode, configure it with Melious as the provider, and launch it.

```bash
melious tools install opencode
melious launch opencode
```

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

### Install Vibe using pip

Source: https://melious.ai/docs/integrations/vibe

Install Vibe using the pip package manager.

```bash
pip install mistral-vibe
```

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

### Fish Shell Completion Setup

Source: https://melious.ai/docs/cli/reference

Set up Fish shell completions by redirecting the output of `melious completion fish` to the appropriate completions directory.

```fish
melious completion fish > ~/.config/fish/completions/melious.fish
```

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

### Install Vercel AI SDK and Dependencies

Source: https://melious.ai/docs/integrations/vercel-ai-sdk

Install the necessary packages for the Vercel AI SDK, OpenAI compatible provider, and Zod for validation.

```bash
npm install ai @ai-sdk/openai-compatible zod
```

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

### Install OpenCode with System Package Managers

Source: https://melious.ai/docs/integrations/opencode

Install OpenCode using Homebrew on macOS and Linux, or Chocolatey/Scoop on Windows.

```bash
brew install anomalyco/tap/opencode
```

```bash
choco install opencode
```

```bash
scoop install opencode
```

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

### Check Prerequisites

Source: https://melious.ai/docs/cli/tools

Verifies the installation and versions of essential prerequisites like Node.js, npm, uv, and all tool binaries. Provides hints for missing components.

```bash
melious tools check
```

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

### Python Transcription Example

Source: https://melious.ai/docs/reference/audio

Use the OpenAI Python client to transcribe an audio file. Ensure you have the client installed and replace placeholders with your API key and model ID.

```python
from openai import OpenAI

client = OpenAI(
    api_key="sk-mel-<YOUR_API_KEY>",
    base_url="https://api.melious.ai/v1",
)

with open("meeting.mp3", "rb") as f:
    result = client.audio.transcriptions.create(
        model="<STT_MODEL_ID>",   # a transcription model from the hub
        file=f,
        language="de",
    )
print(result.text)
```

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

### Install OpenCode with Node.js Package Managers

Source: https://melious.ai/docs/integrations/opencode

Install OpenCode globally using npm, bun, pnpm, or yarn. This method requires Node.js to be installed on your system.

```bash
npm install -g opencode-ai
```

```bash
bun install -g opencode-ai
```

```bash
pnpm install -g opencode-ai
```

```bash
yarn global add opencode-ai
```

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

### Install All Missing Tools

Source: https://melious.ai/docs/cli/tools

Installs all tools that are currently missing from the system. It also checks for and offers to fix PATH issues if tools are found but not accessible.

```bash
melious tools install --all
```

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

### Run Vibe

Source: https://melious.ai/docs/integrations/vibe

Execute the Vibe command to start the coding agent after setting the API key.

```bash
vibe
```

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

### Install LangChain Dependencies (JavaScript/TypeScript)

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

Install the necessary LangChain packages for JavaScript or TypeScript.

```bash
npm install langchain @langchain/openai @langchain/core
```

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

### Install Melious CLI (Windows PowerShell)

Source: https://melious.ai/docs/cli

Installs the Melious CLI using PowerShell. The installation is added to your PATH and does not require admin privileges.

```powershell
irm https://cdn.melious.ai/install.ps1 | iex
```

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

### Install LlamaIndex and Melious-like packages

Source: https://melious.ai/docs/integrations/llamaindex

Install the necessary LlamaIndex packages for OpenAI-like LLMs and embeddings.

```bash
pip install llama-index llama-index-llms-openai-like llama-index-embeddings-openai-like
```

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

### Install LangChain Dependencies (Python)

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

Install the necessary LangChain packages for Python. Include `langchain-community` and `duckduckgo-search` if building an agent.

```bash
pip install langchain langchain-openai langchain-community duckduckgo-search
```

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

### Install Melious CLI (macOS/Linux)

Source: https://melious.ai/docs/cli

Installs the Melious CLI using a curl command. The installation is added to your PATH and does not require sudo.

```bash
curl -fsSL https://cdn.melious.ai/install.sh | bash
```

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

### Install OpenClaw via npm, pnpm, or bun

Source: https://melious.ai/docs/integrations/openclaw

Install OpenClaw globally using your preferred package manager and then onboard the user-level daemon.

```bash
npm install -g openclaw@latest && openclaw onboard --install-daemon
```

```bash
pnpm add -g openclaw@latest          # then: pnpm approve-builds -g
```

```bash
bun add -g openclaw@latest
```

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

### Run OpenCode with API Key

Source: https://melious.ai/docs/integrations/opencode

Set the MELIOUS_API_KEY environment variable and then run the opencode command to start the agent.

```bash
export MELIOUS_API_KEY=sk-mel-<YOUR_API_KEY>
opencode
```

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

### Install OpenClaw on Windows PowerShell

Source: https://melious.ai/docs/integrations/openclaw

Use this PowerShell command to install OpenClaw on Windows. It also manages Node.js installation.

```powershell
iwr -useb https://openclaw.ai/install.ps1 | iex
```

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

### Install OpenAI Node.js SDK

Source: https://melious.ai/docs/get-started/quickstart

Install the OpenAI Node.js package to interact with the Melious API. This package is compatible with the Melious API.

```bash
npm install openai
```

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

### Install Mistral Vibe

Source: https://melious.ai/docs/cli/launch

Install Mistral Vibe on macOS or Linux using a bash script. This command downloads and executes the installation script.

```bash
curl -LsSf https://mistral.ai/vibe/install.sh | bash
```

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

### Install OpenAI Python SDK

Source: https://melious.ai/docs/get-started/quickstart

Install the OpenAI Python package to interact with the Melious API. This package is compatible with the Melious API.

```bash
pip install openai
```

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

### Verify OpenClaw Installation

Source: https://melious.ai/docs/integrations/openclaw

Check the installed OpenClaw version and run a diagnostic to ensure the gateway is set up correctly.

```bash
openclaw --version
```

```bash
openclaw doctor
```

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

### Install Claude Code using Official Installer

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

Install Claude Code using the official script for macOS, Linux, or WSL, or using PowerShell for Windows.

```bash
curl -fsSL https://claude.ai/install.sh | bash
```

```powershell
irm https://claude.ai/install.ps1 | iex
```

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

### Check Tool Status

Source: https://melious.ai/docs/cli/tools

Displays a table showing the installation status, version, and model overrides for each supported tool.

```bash
melious tools
```

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

### Update All Installed Tools

Source: https://melious.ai/docs/cli/tools

Updates all tools that are currently installed on the system.

```bash
melious tools update
```

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

### Batch Job Response Example

Source: https://melious.ai/docs/reference/batches

This is an example of the response received after creating a batch job. It includes details like the job ID, status, input/output file IDs, and timestamps.

```json
{
  "id": "batch_abc123",
  "object": "batch",
  "endpoint": "/v1/chat/completions",
  "errors": null,
  "input_file_id": "file_abc123",
  "completion_window": "24h",
  "status": "queued",
  "output_file_id": null,
  "error_file_id": null,
  "created_at": 1699999999,
  "in_progress_at": null,
  "expires_at": 1700086399,
  "finalizing_at": null,
  "completed_at": null,
  "failed_at": null,
  "expired_at": null,
  "request_counts": { "processing": 0, "succeeded": 0, "errored": 0 },
  "metadata": {"run": "nightly-classifier-2026-04-22"}
}
```

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

### Bash Shell Completion Setup

Source: https://melious.ai/docs/cli/reference

Add persistent Bash completions by appending the output of `melious completion bash` to your ~/.bashrc file and sourcing it.

```bash
# Add to ~/.bashrc for persistent completions
melious completion bash >> ~/.bashrc
source ~/.bashrc
```

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

### PowerShell Shell Completion Setup

Source: https://melious.ai/docs/cli/reference

Configure persistent PowerShell completions by appending the output of `melious completion powershell` to your PowerShell profile.

```powershell
# Add to $PROFILE for persistent completions
melious completion powershell >> $PROFILE
```

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

### Full Batch Workflow Example in Python

Source: https://melious.ai/docs/guides/batch-workflow

This script demonstrates the complete batch workflow: building a JSONL file, uploading it, creating a batch job, polling for completion, and downloading results. It's suitable for non-critical tasks where cost-effectiveness and rate limit avoidance are priorities.

```python
import json
import time
import httpx

API = "https://api.melious.ai/v1"
KEY = "sk-mel-<YOUR_API_KEY>"
HEAD = {"Authorization": f"Bearer {KEY}"}


def run_batch(prompts: dict[str, str], model: str = "<MODEL_ID>:batch") -> dict[str, str]:
    # 1. Build JSONL — one request per line, with a custom_id we'll use to match results
    lines = [
        json.dumps({
            "custom_id": cid,
            "method": "POST",
            "url": "/v1/chat/completions",
            "body": {"model": model, "messages": [{"role": "user", "content": prompt}]},
        })
        for cid, prompt in prompts.items()
    ]
    jsonl = "\n".join(lines).encode()

    # 2. Upload as a file with purpose=batch
    upload = httpx.post(
        f"{API}/files",
        headers=HEAD,
        files={"file": ("requests.jsonl", jsonl, "application/jsonl")},
        data={"purpose": "batch"},
    ).json()
    input_file_id = upload["id"]

    # 3. Create the batch
    batch = httpx.post(
        f"{API}/batches",
        headers={**HEAD, "Content-Type": "application/json"},
        json={
            "input_file_id": input_file_id,
            "endpoint": "/v1/chat/completions",
            "completion_window": "24h",
        },
    ).json()
    batch_id = batch["id"]
    print(f"batch {batch_id} queued")

    # 4. Poll until done
    while True:
        time.sleep(30)
        status = httpx.get(f"{API}/batches/{batch_id}", headers=HEAD).json()
        print(f"  status: {status['status']} "
              f"({status['request_counts']['succeeded']}/{sum(status['request_counts'].values())})")
        if status["status"] in ("succeeded", "failed", "expired", "cancelled"):
            break

    if status["status"] != "succeeded":
        raise RuntimeError(f"batch ended in status {status['status']}")

    # 5. Download the output JSONL and parse
    output_file_id = status["output_file_id"]
    body = httpx.get(f"{API}/files/{output_file_id}/content", headers=HEAD).text

    results = {}
    for line in body.strip().splitlines():
        entry = json.loads(line)
        if entry["error"]:
            results[entry["custom_id"]] = f"ERROR: {entry['error']['message']}"
        else:
            choice = entry["response"]["body"]["choices"][0]
            results[entry["custom_id"]] = choice["message"]["content"]
    return results


if __name__ == "__main__":
    prompts = {
        f"q{i}": f"In one sentence, why did Hanseatic city #{i} matter?"
        for i in range(10)
    }
    answers = run_batch(prompts)
    for cid, text in answers.items():
        print(f"{cid}: {text[:80]}")

```

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

### Launch Default Coding Tool

Source: https://melious.ai/docs/cli/launch

Run your default coding tool with a simple command. Ensure your default tool is configured in Melious.

```bash
melious launch
```

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

### Install Claude Code

Source: https://melious.ai/docs/cli/launch

Install Claude Code on macOS or Linux using a bash script. This command downloads and executes the installation script.

```bash
curl -fsSL https://claude.ai/install.sh | bash
```

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

### Install Claude Code on Windows

Source: https://melious.ai/docs/cli/launch

Install Claude Code on Windows using PowerShell. This command bypasses execution policies to run the installation script.

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://claude.ai/install.ps1 | iex"
```

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

### Show All Melious CLI Configuration

Source: https://melious.ai/docs/cli/configuration

Displays all current configuration settings. Add `--json` for a machine-readable output.

```bash
melious config show
```

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

### Install Claude Code using Package Managers

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

Install Claude Code using Homebrew, Winget, or npm. Ensure Node.js 18+ is installed for the npm option.

```bash
brew install --cask claude-code            # macOS, Linux
```

```bash
winget install Anthropic.ClaudeCode        # Windows
```

```bash
npm install -g @anthropic-ai/claude-code   # any platform, requires Node 18+
```

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

### Create a Vector Store with Python

Source: https://melious.ai/docs/reference/vector_stores

Use this Python snippet to create a new vector store and attach a file. Ensure you have the OpenAI SDK installed and your API key and base URL are correctly configured.

```python
from openai import OpenAI

client = OpenAI(api_key="sk-mel-<YOUR_API_KEY>", base_url="https://api.melious.ai/v1")

vs = client.vector_stores.create(name="Company Handbook")
client.vector_stores.files.create_and_poll(vector_store_id=vs.id, file_id="file-abc123")
```

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

### Build a Tool-Calling Agent with LangChain

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

This snippet demonstrates how to create and execute a tool-calling agent using LangChain. It utilizes DuckDuckGoSearchRun as a tool and a custom prompt template. Ensure you have LangChain and the necessary community integrations installed.

```python
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.tools import DuckDuckGoSearchRun

tools = [DuckDuckGoSearchRun()]
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a careful researcher."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, max_iterations=6)

result = executor.invoke({
    "input": "What's the historical capital of the Hanseatic League?"
})
print(result["output"])
```

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

### Verify Melious CLI Installation

Source: https://melious.ai/docs/cli

Checks if the Melious CLI has been installed correctly by displaying its version.

```bash
melious version
```

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

### Ask about a codebase with file context

Source: https://melious.ai/docs/cli/run

Use the '-f' flag with a glob pattern to provide all Python files in a 'src' directory for analysis.

```bash
melious run -f "src/**/*.py" "What does this project do?"
```

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

### List and Set OpenClaw Models

Source: https://melious.ai/docs/integrations/openclaw

List all available provider/model combinations and set the default model for your OpenClaw gateway.

```bash
openclaw models list
```

```bash
openclaw models set melious/<MODEL_ID>
```

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

### JSON Response Example

Source: https://melious.ai/docs/reference/audio

Example of a successful JSON response from the transcription API, including the transcribed text, detected language, and audio duration.

```json
{
  "text": "Hamburg, Lübeck, Bremen.",
  "language": "de",
  "duration": 2.1
}
```

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

### Load a system prompt from a file

Source: https://melious.ai/docs/cli/run

Specify a file from which to load the system prompt. This is useful for longer or version-controlled prompts.

```bash
melious run --system-file rules.md "Refactor the auth module"
```

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

### Initialize Anthropic SDK Client in Python

Source: https://melious.ai/docs/get-started/anthropic-sdk

Instantiate the Anthropic client in Python, providing your Melious API key and base URL. This client will then communicate with Melious.

```python
from anthropic import Anthropic

client = Anthropic(
    api_key="sk-mel-<YOUR_API_KEY>",
    base_url="https://api.melious.ai",
)

response = client.messages.create(
    model="claude-sonnet-4",
    max_tokens=256,
    messages=[{"role": "user", "content": "Name three Hanseatic cities."}]
)
print(response.content[0].text)
```

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

### List and Retrieve Models

Source: https://melious.ai/docs/tools

Get a list of available models and their capabilities.

```APIDOC
## GET /v1/models

### Description
List and retrieve available models with their capabilities.

### Method
GET

### Endpoint
/v1/models
```

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

### Initialize Anthropic SDK Client in Node.js

Source: https://melious.ai/docs/get-started/anthropic-sdk

Instantiate the Anthropic client in Node.js, providing your Melious API key and base URL. This client will then communicate with Melious.

```javascript
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: "sk-mel-<YOUR_API_KEY>",
  baseURL: "https://api.melious.ai",
});

const response = await client.messages.create({
  model: "claude-sonnet-4",
  max_tokens: 256,
  messages: [{ role: "user", content: "Name three Hanseatic cities." }],
});
console.log(response.content[0].text);
```

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

### Count Tokens Response Example

Source: https://melious.ai/docs/reference/count-tokens

The response indicates the estimated number of input tokens for the request.

```json
{ "input_tokens": 18 }
```

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

### Get Tool Details and Schema

Source: https://melious.ai/docs/tools

Retrieves the full metadata for a specific tool or just its parameter schema.

```APIDOC
## Get a tool's details and schema
GET /v1/tools/{slug}
GET /v1/tools/{slug}/schema

The first returns the full metadata object (same shape as a list entry). The second returns just the `parameters_schema` — the JSON Schema your `execute` call has to satisfy. Fetch the schema before executing if you're building the request dynamically.

### Example Request (Schema)
```bash
curl https://api.melious.ai/v1/tools/web-search/schema \
  -H "Authorization: Bearer sk-mel-<YOUR_API_KEY>"
```

### Parameters
#### Path Parameters
- **slug** (string) - Required - The unique identifier for the tool.
```

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

### Anthropic Tool Calling Example

Source: https://melious.ai/docs/guides/tool-calling

Demonstrates a multi-turn conversation with an Anthropic model, including tool use and tool result processing. Requires setting up the Anthropic client with your API key and base URL.

```python
from anthropic import Anthropic

client = Anthropic(
    api_key="sk-mel-<YOUR_API_KEY>",
    base_url="https://api.melious.ai",
)

tools = [
    {
        "name": "get_weather",
        "description": "Current weather for a city",
        "input_schema": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
]

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

# Turn 1
response = client.messages.create(
    model="claude-sonnet-4",
    max_tokens=512,
    tools=tools,
    messages=messages,
)
messages.append({"role": "assistant", "content": response.content})

# Turn 2: run the tool_use blocks
if response.stop_reason == "tool_use":
    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            result = {"city": block.input["city"], "temp_c": 14}
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": str(result),
            })
    messages.append({"role": "user", "content": tool_results})

    # Turn 3
    final = client.messages.create(
        model="claude-sonnet-4",
        max_tokens=512,
        tools=tools,
        messages=messages,
    )
    print(final.content[0].text)
```

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

### Get Model Metadata

Source: https://melious.ai/docs/concepts/models

Retrieve detailed metadata for a specific model, including its context length.

```APIDOC
## GET /v1/models/{id}

### Description
Retrieve detailed metadata for a specific model.

### Method
GET

### Endpoint
/v1/models/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the model.

### Query Parameters
- **include_meta** (boolean) - Optional - If true, includes detailed metadata about the model's capabilities and context length. The `_meta.context_length` field provides the exact context window size for the model.
```

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

### REST: Initialize Connection

Source: https://melious.ai/docs/tools/mcp

Use this `curl` command to initialize the connection via REST. Note the snake_case fields for 'protocol_version', 'capabilities', and 'client_info'.

```bash
curl https://api.melious.ai/v1/mcp/initialize \
  -H "Authorization: Bearer sk-mel-<YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "protocol_version": "2024-11-05",
    "capabilities": { "tools": {} },
    "client_info": { "name": "my-agent", "version": "1.0.0" }
  }'
```

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

### MCP REST Transport - Initialize Session

Source: https://melious.ai/docs/tools/mcp

A convenience REST endpoint to start an MCP session.

```APIDOC
## POST /v1/mcp/initialize

### Description
Initializes an MCP session. This is part of the convenience REST surface for clients that do not use JSON-RPC.

### Method
POST

### Endpoint
/v1/mcp/initialize

### Request Body
- **sessionId** (string) - Optional - An existing session ID to resume.

### Request Example
```json
{
  "sessionId": "existing-session-id"
}
```

### Response
#### Success Response (200)
- **sessionId** (string) - The ID of the newly created or resumed session.

#### Response Example
```json
{
  "sessionId": "new-session-id"
}
```
```

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

### Run with specific model and preset

Source: https://melious.ai/docs/cli/run

Override the default model and use the 'speed' preset for a faster response when solving a mathematical problem.

```bash
melious run --model deepseek-r1-0528 --preset speed "Solve this: 2^10 + 3^7"
```

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

### Create ChatOpenAI LLM Instance (Python)

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

Instantiate `ChatOpenAI` from `langchain-openai` pointing to the Melious API. This allows using LangChain features like runnables, chains, and tool calling with Melious.

```python
import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://api.melious.ai/v1",         
    api_key=os.environ["MELIOUS_API_KEY"],
    model="glm-5.1",
)

response = llm.invoke("Name three Hanseatic cities.")
print(response.content)
```

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

### Create a store

Source: https://melious.ai/docs/reference/vector_stores

Creates a new vector store. You can optionally provide a name, files to attach, chunking strategy, and metadata.

```APIDOC
## POST /v1/vector_stores

### Description
Creates a new vector store. This managed retrieval layer allows you to upload files, which Melious then chunks, embeds, and indexes for semantic search. It is OpenAI-compatible.

### Method
POST

### Endpoint
/v1/vector_stores

### Parameters
#### Request Body
- **name** (string) - Optional - Display name for the vector store.
- **file_ids** (string[]) - Optional - An array of file IDs to attach to the store upon creation.
- **expires_after** (object) - Optional - Configuration for automatic expiration. Example: `{ "anchor": "last_active_at", "days": <positive int> }`.
- **chunking_strategy** (object) - Optional - Defines how files are chunked. Can be `{ "type": "auto" }` or `{ "type": "static", "static": { "max_chunk_size_tokens", "chunk_overlap_tokens" } }`.
- **metadata** (object) - Optional - Up to 16 key-value pairs for custom metadata.

### Request Example
```json
{
  "name": "Company Handbook",
  "file_ids": ["file-abc123"]
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the vector store (UUID).
- **object** (string) - The type of object, always "vector_store".
- **created_at** (integer) - Timestamp of creation.
- **name** (string) - The display name of the vector store.
- **usage_bytes** (integer) - The amount of storage used in bytes.
- **file_counts** (object) - Counts of files in different states (in_progress, completed, failed, cancelled, total).
- **status** (string) - The current status of the vector store (e.g., "completed").
- **expires_after** (object) - The expiration configuration, if set.
- **expires_at** (integer) - Timestamp when the vector store will expire.
- **metadata** (object) - Any metadata associated with the vector store.

#### Response Example
```json
{
  "id": "9195f348-323e-47a4-ae32-95489a1b2c3d",
  "object": "vector_store",
  "created_at": 1699999999,
  "name": "Company Handbook",
  "usage_bytes": 0,
  "file_counts": { "in_progress": 0, "completed": 1, "failed": 0, "cancelled": 0, "total": 1 },
  "status": "completed",
  "expires_after": { "anchor": "last_active_at", "days": 30 },
  "expires_at": 1702591999,
  "metadata": {}
}
```
```

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

### Display Account Usage Summary

Source: https://melious.ai/docs/cli/usage

Shows totals for the current period including requests, tokens, credits, environmental impact, product breakdown, and most-used models. You can specify a period of 'day', 'week', or 'month'.

```bash
melious usage
```

```bash
melious usage --period day
```

```bash
melious usage --period week
```

```bash
melious usage --period month
```

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

### Get Parsed Content of a Vector Store File

Source: https://melious.ai/docs/reference/vector_stores

Retrieves the parsed text content of a specific file in a vector store.

```shell
GET    /v1/vector_stores/{id}/files/{file_id}/content # parsed chunk text
```

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

### Get a Specific Melious CLI Configuration Key

Source: https://melious.ai/docs/cli/configuration

Retrieves the value of a specific configuration key using dot notation.

```bash
melious config get models.main
```

```bash
melious config get run.temperature
```

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

### Run Claude Code Session

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

Start a Claude Code session. Verify the configuration by checking the status within the session.

```bash
claude
```