LM Studio Developer Docs

https://lmstudio.ai/docs/developer
Admin
LM Studio Developer Docs provide documentation for building applications using LM Studio's local...
Tokens:65,327
Snippets:415
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install and use lmstudio-python

Source: https://lmstudio.ai/docs/developer

Install the Python SDK and use it to initialize a client, load a model, and print a response.

```bash
pip install lmstudio
```

```python
import lmstudio as lms

with lms.Client() as client:
    model = client.llm.model("openai/gpt-oss-20b")
    result = model.respond("Who are you, and what can you do?")
    print(result)
```

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

### Example Event Data for reasoning.start

Source: https://lmstudio.ai/docs/developer/rest/streaming-events

Event emitted when the model starts streaming reasoning content.

```json
{
  "type": "reasoning.start"
}
```

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

### Enable and start the systemd service

Source: https://lmstudio.ai/docs/developer/core/headless_llmster

Reloads systemd, enables the service to start on boot, and starts it immediately.

```bash
sudo systemctl daemon-reload
sudo systemctl enable lmstudio.service
sudo systemctl start lmstudio.service
```

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

### Example Event Data for tool_call.start

Source: https://lmstudio.ai/docs/developer/rest/streaming-events

Event emitted when the model starts a tool call. Includes tool name and provider info, which is a discriminated union on provider type.

```json
{
  "type": "tool_call.start",
  "tool": "model_search",
  "provider_info": {
    "type": "ephemeral_mcp",
    "server_label": "huggingface"
  }
}
```

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

### Bash: Running the Python example

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Command to run the single-turn Python example from the console, showing the expected output.

```bash
-> % python single-turn-example.py
Hello, Bob the Builder!
```

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

### Install and use lmstudio-js

Source: https://lmstudio.ai/docs/developer

Install the TypeScript SDK and use it to initialize a client, load a model, and generate a response.

```bash
npm install @lmstudio/sdk
```

```ts
import { LMStudioClient } from "@lmstudio/sdk";

const client = new LMStudioClient();
const model = await client.llm.model("openai/gpt-oss-20b");
const result = await model.respond("Who are you, and what can you do?");

console.info(result.content);
```

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

### prompt_processing.start event data

Source: https://lmstudio.ai/docs/developer/rest/streaming-events

Example data for the prompt_processing.start event, signaling the start of the model processing a prompt.

```json
{
  "type": "prompt_processing.start"
}
```

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

### Create systemd service unit file /etc/systemd/system/lmstudio.service

Source: https://lmstudio.ai/docs/developer/core/headless_llmster

Systemd unit file that starts llmster, loads the openai/gpt-oss-20b model, and starts the server on boot. Replace YOUR_USERNAME with your username. Uses Type=oneshot and RemainAfterExit=yes.

```ini
[Unit]
Description=LM Studio Server

[Service]
Type=oneshot
RemainAfterExit=yes
User=YOUR_USERNAME
Environment="HOME=/home/YOUR_USERNAME"
ExecStartPre=/home/YOUR_USERNAME/.lmstudio/bin/lms daemon up
ExecStartPre=/home/YOUR_USERNAME/.lmstudio/bin/lms load openai/gpt-oss-20b --yes
ExecStart=/home/YOUR_USERNAME/.lmstudio/bin/lms server start
ExecStop=/home/YOUR_USERNAME/.lmstudio/bin/lms daemon down

[Install]
WantedBy=multi-user.target
```

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

### Start LM Studio server with lms CLI

Source: https://lmstudio.ai/docs/developer/core/server

Starts the LM Studio API server from the terminal using the lms CLI. This is an alternative to toggling the "Start server" switch in the Developer tab.

```bash
lms server start
```

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

### Advanced agent example (agent-chat-example.py)

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Python script for an agent that uses the OpenAI client to interact with a local LM Studio server. It defines functions to safely open URLs, get the current time, and analyze directories, with a safe domain allowlist.

```python
import json
from urllib.parse import urlparse
import webbrowser
from datetime import datetime
import os
from openai import OpenAI

# Point to the local server
client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")
model = "lmstudio-community/qwen2.5-7b-instruct"


def is_valid_url(url: str) -> bool:

    try:
        result = urlparse(url)
        return bool(result.netloc)  # Returns True if there's a valid network location
    except Exception:
        return False


def open_safe_url(url: str) -> dict:
    # List of allowed domains (expand as needed)
    SAFE_DOMAINS = {
        "lmstudio.ai",
        "huggingface.co",
        "github.com",
        "google.com",
        "wikipedia.org",
        "weather.com",
        "stackoverflow.com",
        "python.org",
        "docs.python.org",
    }

    try:
        # Add http:// if no scheme is present
        if not url.startswith(('http://', 'https://')):
            url = 'http://' + url

        # Validate URL format
        if not is_valid_url(url):
            return {"status": "error", "message": f"Invalid URL format: {url}"}

        # Parse the URL and check domain
        parsed_url = urlparse(url)
        domain = parsed_url.netloc.lower()
        base_domain = ".".join(domain.split(".")[-2:])

        if base_domain in SAFE_DOMAINS:
            webbrowser.open(url)
            return {"status": "success", "message": f"Opened {url} in browser"}
        else:
            return {
                "status": "error",
                "message": f"Domain {domain} not in allowed list",
            }
        }
    except Exception as e:
        return {"status": "error", "message": str(e)}


def get_current_time() -> dict:
    """Get the current system time with timezone"""
    try:
        current_time = datetime.now()
        timezone = datetime.now().astimezone().tzinfo
        formatted_time = current_time.strftime("%Y-%m-%d %H:%M:%S %Z")
        return {
            "status": "success",
            "time": formatted_time,
            "timezone": str(timezone),
            "timestamp": current_time.timestamp(),
        }
    except Exception as e:
        return {"status": "error", "message": str(e)}


def analyze_directory(path: str = ".") -> dict:
    """Count and categorize files in a directory"""
    try:
        stats = {
            "total_files": 0,
            "total_dirs": 0,
            "file_types": {},
            "total_size_bytes": 0,
        }
```

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

### GET /api/v0/models - List all models

Source: https://lmstudio.ai/docs/developer/rest/endpoints

Example curl request to list all loaded and downloaded models. Uses the LM_API_TOKEN environment variable for authorization.

```bash
curl -H "Authorization: Bearer $LM_API_TOKEN" http://localhost:1234/api/v0/models
```

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

### Example Response Content

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Example of the response content after the tool call, showing the delivery date.

```xml
Your order #123 will be delivered on March 15th, 2024
```

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

### model_load.start event data

Source: https://lmstudio.ai/docs/developer/rest/streaming-events

Example data for the model_load.start event, signaling the start of a model being loaded. Not emitted if the requested model is already loaded.

```json
{
  "type": "model_load.start",
  "model_instance_id": "openai/gpt-oss-20b"
}
```

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

### Simple tool call example

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

A minimal example showing how to set up a messages list for a tool call. The model is asked to say hello to Bob the Builder, and the tool call is expected to be invoked.

```python
messages=[{"role": "user", "content": "Can you say hello to Bob the Builder?"}]
```

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

### Start local server and query via REST API

Source: https://lmstudio.ai/docs/developer

Start the LM Studio server on a specific port and send a chat request using curl.

```bash
lms server start --port 1234
```

```bash
curl http://localhost:1234/api/v1/chat \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $LM_API_TOKEN" \
  -d '{
    "model": "openai/gpt-oss-20b",
    "input": "Who are you, and what can you do?"
  }'
```

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

### Example using curl

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

This example demonstrates a model requesting a tool call using the curl utility. To run on Mac or Linux, use any terminal; on Windows, use Git Bash.

```bash
curl ...
```

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

### Install llmster on Windows

Source: https://lmstudio.ai/docs/developer/core/headless

Install the llmster daemon on Windows using the provided PowerShell command.

```bash
irm https://lmstudio.ai/install.ps1 | iex
```

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

### Multi-turn tool calling example output

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Shows the output of running a multi-turn example script. It displays the model's response requesting a tool call, the function's return value, and the final model response incorporating the tool result.

```text
-> % python multi-turn-example.py

Model response requesting tool call:

ChatCompletion(id='chatcmpl-wwpstqqu94go4hvclqnpwn', choices=[Choice(finish_reason='tool_calls', index=0, logprobs=None, message=ChatCompletionMessage(content=None, refusal=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='377278620', function=Function(arguments='{"order_id":"1017"}', name='get_delivery_date'), type='function')]))], created=1730916196, model='lmstudio-community/qwen2.5-7b-instruct', object='chat.completion', service_tier=None, system_fingerprint='lmstudio-community/qwen2.5-7b-instruct', usage=CompletionUsage(completion_tokens=24, prompt_tokens=223, total_tokens=247, completion_tokens_details=None, prompt_tokens_details=None))

get_delivery_date function returns delivery date:

2024-11-19 13:03:17.773298

Final model response with knowledge of the tool call result:

Your order number 1017 is scheduled for delivery on November 19, 2024, at 13:03 PM.
```

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

### curl: Example response with tool_calls

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Example JSON response to the curl request. Shows the model requesting a call to search_products with arguments for query, category, and max_price. The finish_reason is "tool_calls".

```bash
{
  "id": "chatcmpl-gb1t1uqzefudice8ntxd9i",
  "object": "chat.completion",
  "created": 1730913210,
  "model": "lmstudio-community/qwen2.5-7b-instruct",
  "choices": [
    {
      "index": 0,
      "logprobs": null,
      "finish_reason": "tool_calls",
      "message": {
        "role": "assistant",
        "tool_calls": [
          {
            "id": "365174485",
            "type": "function",
            "function": {
              "name": "search_products",
              "arguments": "{\"query\":\"dell\",\"category\":\"electronics\",\"max_price\":50}"
            }
          }
        ]
      }
    }
  ],
  "usage": {
    "prompt_tokens": 263,
    "completion_tokens": 34,
    "total_tokens": 297
  },
  "system_fingerprint": "lmstudio-community/qwen2.5-7b-instruct"
}
```

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

### Normal Response Example

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Example of a model responding normally without tool calls.

```xml
User: Hi
Model: Hello! How can I assist you today?
```

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

### Manual test: load model, start server, verify API, stop server

Source: https://lmstudio.ai/docs/developer/core/headless_llmster

Sequence of commands to manually verify llmster works before configuring systemd. Loads the model, starts the server, checks the API, and stops the server.

```bash
lms load openai/gpt-oss-20b
```

```bash
lms server start
```

```bash
curl http://localhost:1234/v1/models
```

```bash
lms server stop
```

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

### Tool Call Request Example

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Example of a model requesting a tool call in XML format. The model outputs a tool_call with name and arguments.

```xml
User: Get me the delivery date for order 123
Model: <tool_call>
{"name": "get_delivery_date", "arguments": {"order_id": "123"}}
</tool_call>
```

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

### Start llmster daemon

Source: https://lmstudio.ai/docs/developer/core/headless

Start the llmster daemon with the `lms daemon up` command. See the daemon CLI docs for full reference.

```bash
lms daemon up
```

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

### Example Messages for Tool Call

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Example of messages array with tool call and tool result, and creating a chat completion with the model.

```python
# Example messages
messages = [
    {"role": "user", "content": "When will order 123 be delivered?"},
    {"role": "assistant", "function_call": {
        "name": "get_delivery_date",
        "arguments": {"order_id": "123"}
    }},
    {"role": "tool", "content": "2024-03-15"},
]
response = client.chat.completions.create(
    model="lmstudio-community/qwen2.5-7b-instruct",
    messages=messages
)
```

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

### reasoning.start

Source: https://lmstudio.ai/docs/developer/rest/streaming-events

Signals the model is starting to stream reasoning content.

```APIDOC
## reasoning.start

### Description
Signals the model is starting to stream reasoning content.

### Event Data
- **type** ('"reasoning.start"') - Required - The type of the event. Always `reasoning.start`.

### Example Event Data
```json
{
  "type": "reasoning.start"
}
```
```

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

### POST /api/v0/completions example request and response

Source: https://lmstudio.ai/docs/developer/rest/endpoints

Example request to the completions endpoint using curl with a Bearer token and JSON body, followed by the JSON response format. The response includes choices, usage, stats, model_info, and runtime fields.

```bash
curl http://localhost:1234/api/v0/completions \
  -H "Authorization: Bearer $LM_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "granite-3.0-2b-instruct",
    "prompt": "the meaning of life is",
    "temperature": 0.7,
    "max_tokens": 10,
    "stream": false,
    "stop": "\n"
  }'
```

```json
{
  "id": "cmpl-p9rtxv6fky2v9k8jrd8cc",
  "object": "text_completion",
  "created": 1731990488,
  "model": "granite-3.0-2b-instruct",
  "choices": [
    {
      "index": 0,
      "text": " to find your purpose, and once you have",
      "logprobs": null,
      "finish_reason": "length"
    }
  ],
  "usage": {
    "prompt_tokens": 5,
    "completion_tokens": 9,
    "total_tokens": 14
  },
  "stats": {
    "tokens_per_second": 57.69230769230769,
    "time_to_first_token": 0.299,
    "generation_time": 0.156,
    "stop_reason": "maxPredictedTokensReached"
  },
  "model_info": {
    "arch": "granite",
    "quant": "Q4_K_M",
    "format": "gguf",
    "context_length": 4096
  },
  "runtime": {
    "name": "llama.cpp-mac-arm64-apple-metal-advsimd",
    "version": "1.3.0",
    "supported_formats": ["gguf"]
  }
}
```

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

### GET /api/v0/models/{model} - Get specific model info

Source: https://lmstudio.ai/docs/developer/rest/endpoints

Example curl request to get info about a specific model, using the model ID in the URL path.

```bash
curl -H "Authorization: Bearer $LM_API_TOKEN" http://localhost:1234/api/v0/models/qwen2-vl-7b-instruct
```

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

### GET /api/v0/models/{model} - Response format

Source: https://lmstudio.ai/docs/developer/rest/endpoints

Example JSON response for the GET /api/v0/models/{model} endpoint, showing details for a single model.

```json
{
  "id": "qwen2-vl-7b-instruct",
  "object": "model",
  "type": "vlm",
  "publisher": "mlx-community",
  "arch": "qwen2_vl",
  "compatibility_type": "mlx",
  "quantization": "4bit",
  "state": "not-loaded",
  "max_context_length": 32768
}
```

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

### Python: Single-turn tool call example (say_hello)

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Python script that connects to LM Studio, defines a say_hello function, tells the model about it via tools, and handles the model's tool call. Assumes the model requests a tool call and prints the greeting.

```python
from openai import OpenAI

# Connect to LM Studio
client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")

# Define a simple function
def say_hello(name: str) -> str:
    print(f"Hello, {name}!")

# Tell the AI about our function
tools = [
    {
        "type": "function",
        "function": {
            "name": "say_hello",
            "description": "Says hello to someone",
            "parameters": {
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "The person's name"
                    }
                },
                "required": ["name"]
            }
        }
    }
]

# Ask the AI to use our function
response = client.chat.completions.create(
    model="lmstudio-community/qwen2.5-7b-instruct",
    messages=[{"role": "user", "content": "Can you say hello to Bob the Builder?"}],
    tools=tools
)

# Get the name the AI wants to use a tool to say hello to
# (Assumes the AI has requested a tool call and that tool call is say_hello)
tool_call = response.choices[0].message.tool_calls[0]
name = eval(tool_call.function.arguments)["name"]

# Actually call the say_hello function
say_hello(name) # Prints: Hello, Bob the Builder!
```

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

### GET /api/v0/models - Response format

Source: https://lmstudio.ai/docs/developer/rest/endpoints

Example JSON response for the GET /api/v0/models endpoint, showing a list of models with details like type, quantization, state, and max context length.

```json
{
  "object": "list",
  "data": [
    {
      "id": "qwen2-vl-7b-instruct",
      "object": "model",
      "type": "vlm",
      "publisher": "mlx-community",
      "arch": "qwen2_vl",
      "compatibility_type": "mlx",
      "quantization": "4bit",
      "state": "not-loaded",
      "max_context_length": 32768
    },
    {
      "id": "meta-llama-3.1-8b-instruct",
      "object": "model",
      "type": "llm",
      "publisher": "lmstudio-community",
      "arch": "llama",
      "compatibility_type": "gguf",
      "quantization": "Q4_K_M",
      "state": "not-loaded",
      "max_context_length": 131072
    },
    {
      "id": "text-embedding-nomic-embed-text-v1.5",
      "object": "model",
      "type": "embeddings",
      "publisher": "nomic-ai",
      "arch": "nomic-bert",
      "compatibility_type": "gguf",
      "quantization": "Q4_0",
      "state": "not-loaded",
      "max_context_length": 2048
    }
  ]
}
```

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

### System prompt injection for Qwen2.5-Instruct

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Shows how the tool list is injected into the system prompt for Qwen2.5-Instruct, including the XML tags and tool call format.

```json
<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.

# Tools

You may call one or more functions to assist with the user query.

You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {"name": "get_delivery_date", "description": "Get the delivery date for a customer's order", "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}}, "required": ["order_id"]}}}
</tools>

For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
```

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

### Start LM Studio API server on local network with --bind 0.0.0.0

Source: https://lmstudio.ai/docs/developer/core/server/serve-on-network

Use this CLI command to make the LM Studio API server accessible on the local network by binding to 0.0.0.0. This exposes the server beyond localhost, so authentication is recommended.

```bash
lms server start --bind 0.0.0.0
```

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

### chat.start event data

Source: https://lmstudio.ai/docs/developer/rest/streaming-events

Example data for the chat.start event, emitted at the start of a chat response stream. Contains the type and the model_instance_id of the loaded model that will generate the response.

```json
{
  "type": "chat.start",
  "model_instance_id": "openai/gpt-oss-20b"
}
```

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

### Example Request: curl GET download status

Source: https://lmstudio.ai/docs/developer/rest/download-status

Use this curl command to check the status of a download job. Replace $LM_API_TOKEN with your API token and the job ID in the URL with the actual job ID returned by the download endpoint.

```bash
curl -H "Authorization: Bearer $LM_API_TOKEN" \
  http://localhost:1234/api/v1/models/download/status/job_493c7c9ded
```

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

### Download a model with lms get

Source: https://lmstudio.ai/docs/developer/rest/quickstart

Downloads the ibm/granite-4-micro model if you don't have it yet.

```bash
lms get ibm/granite-4-micro
```

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

### GET /api/v1/models/download/status

Source: https://lmstudio.ai/docs/developer/rest

Get download status for a model.

```APIDOC
## GET /api/v1/models/download/status

### Description
Get download status for a model.

### Method
GET

### Endpoint
/api/v1/models/download/status

### Parameters
#### Query Parameters
- **id** (string) - Required - Download ID.

### Request Example
GET /api/v1/models/download/status?id=download-id

### Response
#### Success Response (200)
- **id** (string) - Download ID.
- **status** (string) - Download status.
- **progress** (number) - Download progress percentage.

#### Response Example
{
  "id": "download-id",
  "status": "completed",
  "progress": 100
}
```

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

### Download a model with lms get

Source: https://lmstudio.ai/docs/developer/core/headless_llmster

Downloads the openai/gpt-oss-20b model. The output shows the model path needed for the systemd configuration.

```bash
lms get openai/gpt-oss-20b
```

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

### Install llmster on Linux/Mac

Source: https://lmstudio.ai/docs/developer/core/headless

Install the llmster daemon on Linux or macOS using the provided curl command.

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

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

### Basic lms CLI usage

Source: https://lmstudio.ai/docs/developer

Common commands for managing the daemon, downloading models, starting the server, and initiating chat sessions.

```bash
lms daemon up          # Start the daemon
lms get <model>        # Download a model
lms server start       # Start the local server
lms chat               # Open an interactive session
```

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

### Improperly Formatted Tool Call Example

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

Example of an improperly formatted tool call from a smaller model, showing incorrect brackets and format.

```xml
<tool_call>
["name": "get_delivery_date", function: "date"]
</tool_call>
```

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

### Multi-turn tool call example with get_delivery_date

Source: https://lmstudio.ai/docs/developer/openai-compat/tools

A more complex example that enables the model to call a `get_delivery_date` function, then hands the result back to the model to fulfill the user's request. It includes setting up the client, defining the tool, making the initial request, extracting the tool call, calling the function, and sending the result back.

```python
from datetime import datetime, timedelta
import json
import random
from openai import OpenAI

# Point to the local server
client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")
model = "lmstudio-community/qwen2.5-7b-instruct"


def get_delivery_date(order_id: str) -> datetime:
    # Generate a random delivery date between today and 14 days from now
    # in a real-world scenario, this function would query a database or API
    today = datetime.now()
    random_days = random.randint(1, 14)
    delivery_date = today + timedelta(days=random_days)
    print(
        f"\nget_delivery_date function returns delivery date:\n\n{delivery_date}",
        flush=True,
    )
    return delivery_date


tools = [
    {
        "type": "function",
        "function": {
            "name": "get_delivery_date",
            "description": "Get the delivery date for a customer's order. Call this whenever you need to know the delivery date, for example when a customer asks 'Where is my package'",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {
                        "type": "string",
                        "description": "The customer's order ID.",
                    },
                },
                "required": ["order_id"],
                "additionalProperties": False,
            },
        },
    }
]

messages = [
    {
        "role": "system",
        "content": "You are a helpful customer support assistant. Use the supplied tools to assist the user.",
    },
    {
        "role": "user",
        "content": "Give me the delivery date and time for order number 1017",
    },
]

# LM Studio
response = client.chat.completions.create(
    model=model,
    messages=messages,
    tools=tools,
)

print("\nModel response requesting tool call:\n", flush=True)
print(response, flush=True)

# Extract the arguments for get_delivery_date
# Note this code assumes we have already determined that the model generated a function call.
tool_call = response.choices[0].message.tool_calls[0]
arguments = json.loads(tool_call.function.arguments)

order_id = arguments.get("order_id")

# Call the get_delivery_date function with the extracted order_id
delivery_date = get_delivery_date(order_id)

assistant_tool_call_request_message = {
    "role": "assistant",
    "tool_calls": [
        {
            "id": response.choices[0].message.tool_calls[0].id,
            "type": response.choices[0].message.tool_calls[0].type,
            "function": response.choices[0].message.tool_calls[0].function,
        }
    ],
}

# Create a message containing the result of the function call
function_call_result_message = {
    "role": "tool",
    "content": json.dumps(
        {
            "order_id": order_id,
            "delivery_date": delivery_date.strftime("%Y-%m-%d %H:%M:%S"),
        }
    ),
    "tool_call_id": response.choices[0].message.tool_calls[0].id,
}

# Prepare the chat completion call payload
completion_messages_payload = [
    messages[0],
    messages[1],
    assistant_tool_call_request_message,
    function_call_result_message,
]

# Call the OpenAI API's chat completions endpoint to send the tool call result back to the model
# LM Studio
response = client.chat.completions.create(
    model=model,
    messages=completion_messages_payload,
)

print("\nFinal model response with knowledge of the tool call result:\n", flush=True)
print(response.choices[0].message.content, flush=True)
```

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

### Verify llmster installation with lms --help

Source: https://lmstudio.ai/docs/developer/core/headless_llmster

Checks that the lms CLI is available and displays help information.

```bash
lms --help
```

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

### POST /api/v1/chat - Start a new conversation

Source: https://lmstudio.ai/docs/developer/rest/stateful-chats

Sends a chat request to start a new conversation. The response includes a response_id that can be used to continue the conversation.

```APIDOC
## POST /api/v1/chat

### Description
Starts a new stateful chat conversation. The response includes a `response_id` that can be used to continue the conversation in subsequent requests.

### Method
POST

### Endpoint
/api/v1/chat

### Parameters
#### Request Body
- **model** (string) - Required - The model identifier to use for the chat.
- **input** (string) - Required - The user input message.
- **store** (boolean) - Optional - Set to `false` to disable stateful storage. Defaults to `true`.
- **previous_response_id** (string) - Optional - The `response_id` from a previous response to continue the conversation.

### Request Example
```bash
curl http://localhost:1234/api/v1/chat \
  -H "Authorization: Bearer $LM_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ibm/granite-4-micro",
    "input": "My favorite color is blue."
  }'
```

### Response
#### Success Response (200)
- **model_instance_id** (string) - The model instance identifier.
- **output** (array) - Array of output messages.
  - **type** (string) - The type of output, e.g., "message".
  - **content** (string) - The content of the message.
- **response_id** (string) - Unique identifier for this response, used to continue the conversation.

#### Response Example
```json
{
  "model_instance_id": "ibm/granite-4-micro",
  "output": [
    {
      "type": "message",
      "content": "That's great! Blue is a beautiful color..."
    }
  ],
  "response_id": "resp_abc123xyz..."
}
```
```
Tokens:
Raw