LM Studio

https://lmstudio.ai/docs
Admin
LM Studio is a desktop application that allows users to run, experiment with, and chat with large...
Tokens:164,201
Snippets:1,468
Trust Score:10
Update:4 weeks ago
Show doc for...
Tokens:
Raw
### Start server and check status example

Source: https://lmstudio.ai/docs/cli/serve/server-status

Example usage showing starting the server with `lms server start` and then checking status with `lms server status`. The output shows the server starting and then confirming it is running on port 1234.

```console
➜  ~ lms server start
Starting server...
Waking up LM Studio service...
Success! Server is now running on port 1234

➜  ~ lms server status
The server is running on port 1234.
```

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

### Download qwen3-4b-2507 model with lms get

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

Download the qwen3-4b-2507 model required by the quick example. Uses the lms CLI command.

```bash
lms get qwen/qwen3-4b-2507
```

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

### Start daemon with JSON output and example response

Source: https://lmstudio.ai/docs/cli/daemon/daemon-up

Starts the daemon and outputs the result in JSON format for scripting or automation. The example output shows the status, PID, daemon flag, and version.

```shell
lms daemon up --json
```

```json
{ "status": "running", "pid": 26754, "isDaemon": true, "version": "0.4.4+1" }
```

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

### Enable and start lmstudio.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
```

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

### Prepare image and describe with convenience API

Source: https://lmstudio.ai/docs/python/llm-prediction/image-input

Uses the top-level lmstudio functions to prepare an image and get a model. Replace the image path with your own. The model 'qwen2-vl-2b-instruct' is used as an example.

```python
import lmstudio as lms

image_path = "/path/to/image.jpg" # Replace with the path to your image
image_handle = lms.prepare_image(image_path)
model = lms.llm("qwen2-vl-2b-instruct")
chat = lms.Chat()
chat.add_user_message("Describe this image please", images=[image_handle])
prediction = model.respond(chat)
```

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

### 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)
```

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

### Create a new Node.js project with lms create (JavaScript)

Source: https://lmstudio.ai/docs/typescript/project-setup

Use this command to start an interactive project setup for a JavaScript Node.js project.

```bash
lms create node-javascript
```

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

### Prepare image and describe with scoped resource API

Source: https://lmstudio.ai/docs/python/llm-prediction/image-input

Uses a client context manager to prepare an image and get a model. Replace the image path with your own. The model 'qwen2-vl-2b-instruct' is used as an example.

```python
import lmstudio as lms

with lms.Client() as client:
    image_path = "/path/to/image.jpg" # Replace with the path to your image
    image_handle = client.files.prepare_image(image_path)
    model = client.llm.model("qwen2-vl-2b-instruct")
    chat = lms.Chat()
    chat.add_user_message("Describe this image please", images=[image_handle])
    prediction = model.respond(chat)
```

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

### Install @lmstudio/sdk with pnpm

Source: https://lmstudio.ai/docs/typescript/project-setup

Install the SDK into an existing project using pnpm.

```bash
pnpm add @lmstudio/sdk
```

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

### Install @lmstudio/sdk with npm

Source: https://lmstudio.ai/docs/typescript/project-setup

Install the SDK into an existing project using npm.

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

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

### Create a new Node.js project with lms create (TypeScript)

Source: https://lmstudio.ai/docs/typescript/project-setup

Use this command to start an interactive project setup for a TypeScript Node.js project. This is the recommended option.

```bash
lms create node-typescript
```

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

### 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"
  }
}
```

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

### 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);
```

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

### Install @lmstudio/sdk with yarn

Source: https://lmstudio.ai/docs/typescript/project-setup

Install the SDK into an existing project using yarn.

```bash
yarn add @lmstudio/sdk
```

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

### 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!
```

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

### Run the dev plugin server with lms dev

Source: https://lmstudio.ai/docs/cli/develop-and-publish/dev

Starts a local dev server that verifies manifest.json, installs dependencies if needed, and watches for changes to rebuild the plugin. Supported runners: Node/ECMAScript and Deno.

```shell
lms dev
```

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

### Start and stop the local server

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

Start and stop the local server using the lms CLI.

```bash
lms server start
lms server stop
```

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

### Install lmstudio with pip

Source: https://lmstudio.ai/docs/python/getting-started/project-setup

Install the lmstudio package from PyPI using pip.

```bash
pip install lmstudio
```

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

### Example JSON output when daemon is running

Source: https://lmstudio.ai/docs/cli/daemon/daemon-status

Example JSON output when the daemon is running.

```json
{ "status": "running", "pid": 12345, "isDaemon": true }
```

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

### Run Hermes Agent setup interactively

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

Runs the interactive setup for Hermes Agent, allowing you to choose LM Studio as the model provider.

```bash
hermes setup
```

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

### Example Request: curl GET download status

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

Sends a GET request to the download status endpoint with a bearer token. The job_id is returned by the download endpoint when a download is initiated.

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

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

### 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"
}
```

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

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

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

Systemd unit that starts llmster, loads the openai/gpt-oss-20b model, and starts the HTTP server on boot. Replace YOUR_USERNAME with your actual 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
```

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

### 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"
}
```

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

### Example Response: Download status object

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

Shows a completed download job with total and downloaded bytes, start and completion times. Response fields vary based on status; for example, bytes_per_second and estimated_completion appear when status is downloading.

```json
{
  "job_id": "job_493c7c9ded",
  "status": "completed",
  "total_size_bytes": 2279145003,
  "downloaded_bytes": 2279145003,
  "started_at": "2025-10-03T15:33:23.496Z",
  "completed_at": "2025-10-03T15:43:12.102Z"
}
```

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

### Download and serve a model with lms

Source: https://lmstudio.ai/docs/app/basics/lmstudio-vs-llmster-vs-lms

Example commands to download, load, and serve a model using lms. After running these, the server listens on http://localhost:1234 and supports OpenAI or Anthropic-compatible endpoints.

```bash
lms get openai/gpt-oss-20b
lms load openai/gpt-oss-20b
lms server start
```

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

### Example output - LlmInstanceInfo

Source: https://lmstudio.ai/docs/python/model-info/get-model-info

Shows the structure of the output from get_info(), containing fields like architecture, contextLength, displayName, and more. This is an example output, not actual code to run.

```python
LlmInstanceInfo.from_dict({
  "architecture": "qwen2",
  "contextLength": 4096,
  "displayName": "Qwen2.5 7B Instruct 1M",
  "format": "gguf",
  "identifier": "qwen2.5-7b-instruct",
  "instanceReference": "lpFZPBQhjSZPrFevGyY6Leq8",
  "maxContextLength": 1010000,
  "modelKey": "qwen2.5-7b-instruct-1m",
  "paramsString": "7B",
  "path": "lmstudio-community/Qwen2.5-7B-Instruct-1M-GGUF/Qwen2.5-7B-Instruct-1M-Q4_K_M.gguf",
  "sizeBytes": 4683073888,
  "trainedForToolUse": true,
  "type": "llm",
  "vision": false
})
```

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

### 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"
}
```

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

### Example output of lms load --estimate-only

Source: https://lmstudio.ai/docs/cli/local-models/load

Example output showing the estimated GPU and total memory for a model, and a note about resource guardrails.

```bash
$ lms load --estimate-only gpt-oss-120b
Model: openai/gpt-oss-120b
Estimated GPU Memory:   65.68 GB
Estimated Total Memory: 65.68 GB

Estimate: This model may be loaded based on your resource guardrails settings.
```

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

### 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!
```

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

### 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|>
```

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

### 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: Multiple Tools with .act()

Source: https://lmstudio.ai/docs/typescript/agent/act

TypeScript example demonstrating how to provide multiple tools (addition and isPrime) in a single `.act()` call. The model is 'qwen2.5-7b-instruct' and messages are logged to console.

```typescript
import { LMStudioClient, tool } from "@lmstudio/sdk";
import { z } from "zod";

const client = new LMStudioClient();

const additionTool = tool({
  name: "add",
  description: "Given two numbers a and b. Returns the sum of them.",
  parameters: { a: z.number(), b: z.number() },
  implementation: ({ a, b }) => a + b,
});

const isPrimeTool = tool({
  name: "isPrime",
  description: "Given a number n. Returns true if n is a prime number.",
  parameters: { n: z.number() },
  implementation: ({ n }) => {
    if (n < 2) return false;
    const sqrt = Math.sqrt(n);
    for (let i = 2; i <= sqrt; i++) {
      if (n % i === 0) return false;
    }
    return true;
  },
});

const model = await client.llm.model("qwen2.5-7b-instruct");
await model.act(
  "Is the result of 12345 + 45668 a prime? Think step by step.",
  [additionTool, isPrimeTool],
  { onMessage: (message) => console.info(message.toString()) },
);
```

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

### 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,
        }
```

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

### 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
```

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

### Obtain a Model with lmstudio Python SDK

Source: https://lmstudio.ai/docs/python/llm-prediction/chat-completion

Shows how to get a model handle using the top-level 'llm' convenience API or the 'model' method in the 'llm' namespace when using the scoped resource API. The example uses the Qwen2.5 7B Instruct model. Three API variants are provided: convenience API, scoped resource API, and asynchronous API.

```python
import lmstudio as lms

model = lms.llm("qwen2.5-7b-instruct")
```

```python
import lmstudio as lms

with lms.Client() as client:
    model = client.llm.model("qwen2.5-7b-instruct")
```

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

### Install the plugin with lms dev --install

Source: https://lmstudio.ai/docs/cli/develop-and-publish/dev

Installs the plugin into LM Studio instead of running the dev server.

```shell
lms dev --install
```

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

### Prepare an image with prepare_image()

Source: https://lmstudio.ai/docs/python/llm-prediction/image-input

Get a handle to an image file to pass to the model. Use `lms.prepare_image()` (convenience), `client.files.prepare_image()` (scoped), or `await client.files.prepare_image()` (async). Raw bytes and binary IO objects are also accepted; binary filesystem paths are not supported. The server supports JPEG, PNG, and WebP.

```python
import lmstudio as lms

image_path = "/path/to/image.jpg" # Replace with the path to your image
image_handle = lms.prepare_image(image_path)
```

```python
import lmstudio as lms

with lms.Client() as client:
    image_path = "/path/to/image.jpg" # Replace with the path to your image
    image_handle = client.files.prepare_image(image_path)
```

```python
# Note: assumes use of an async function or the "python -m asyncio" asynchronous REPL
# Requires Python SDK version 1.5.0 or later
import lmstudio as lms

async with lms.AsyncClient() as client:
    image_path = "/path/to/image.jpg" # Replace with the path to your image
    image_handle = await client.files.prepare_image(image_path)
```

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

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

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

Gets the download status of a model.

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

### Description
Gets the download status of a model.

### Method
GET

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

### Parameters
#### Query Parameters
- **model** (string) - Required - Model identifier.

### Request Example
None

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

#### Response Example
{
  "status": "downloading",
  "progress": 50
}
```

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

### Example: Chat Loop with Create File Tool

Source: https://lmstudio.ai/docs/typescript/agent/act

TypeScript example creating a conversation loop with an LLM agent that can create files. The code is incomplete in the source; only the introductory part is shown.

```typescript
// The following code creates a conversation loop with an LLM agent that can create files.
```

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

### Start LLM server programmatically

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

Starts the LLM server to achieve auto server start programmatically. Your last server state will be saved and restored on app or service launch.

```bash
lms server start
```

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

### 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?"}]
```

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

### Quick Example: Single Tool with .act()

Source: https://lmstudio.ai/docs/typescript/agent/act

TypeScript example using the `.act()` API with a single multiply tool. Requires zod v3. The model is 'qwen2.5-7b-instruct' and messages are logged to console.

```typescript
import { LMStudioClient, tool } from "@lmstudio/sdk";
import { z } from "zod";

const client = new LMStudioClient();

const multiplyTool = tool({
  name: "multiply",
  description: "Given two numbers a and b. Returns the product of them.",
  parameters: { a: z.number(), b: z.number() },
  implementation: ({ a, b }) => a * b,
});

const model = await client.llm.model("qwen2.5-7b-instruct");
await model.act("What is the result of 12345 multiplied by 54321?", [multiplyTool], {
  onMessage: (message) => console.info(message.toString()),
});
```

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

### 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.
```

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

### Install llmster on Windows

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

Installs llmster, the standalone daemon, on Windows. Run in PowerShell.

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

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

### List installed runtimes with lms runtime ls

Source: https://lmstudio.ai/docs/cli/runtime/runtime

Lists all installed inference runtimes.

```shell
lms runtime ls
```

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

### 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 output of listing downloaded models

Source: https://lmstudio.ai/docs/python/manage-models/list-downloaded

Shows the format of the output when listing downloaded models, including model keys, display names, architectures, and vision support.

```python
DownloadedLlm(model_key='qwen2.5-7b-instruct-1m', display_name='Qwen2.5 7B Instruct 1M', architecture='qwen2', vision=False)
DownloadedEmbeddingModel(model_key='text-embedding-nomic-embed-text-v1.5', display_name='Nomic Embed Text v1.5', architecture='nomic-bert')
```

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

### 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?
```
Tokens:
Raw