Instructions to use miutti/intel-mac-local-llm with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Notebooks
Google Colab
Kaggle
Local Apps Settings

How to use miutti/intel-mac-local-llm with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf miutti/intel-mac-local-llm:UD-Q2_K_XL
# Run inference directly in the terminal:
llama cli -hf miutti/intel-mac-local-llm:UD-Q2_K_XL

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf miutti/intel-mac-local-llm:UD-Q2_K_XL
# Run inference directly in the terminal:
llama cli -hf miutti/intel-mac-local-llm:UD-Q2_K_XL

Build from source code

git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-app
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama serve -hf miutti/intel-mac-local-llm:UD-Q2_K_XL
# Run inference directly in the terminal:
./build/bin/llama cli -hf miutti/intel-mac-local-llm:UD-Q2_K_XL

Use Docker

docker model run hf.co/miutti/intel-mac-local-llm:UD-Q2_K_XL

Llama new
LM Studio
Jan

vLLM

How to use miutti/intel-mac-local-llm with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "miutti/intel-mac-local-llm"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "miutti/intel-mac-local-llm",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/miutti/intel-mac-local-llm:UD-Q2_K_XL

Ollama
How to use miutti/intel-mac-local-llm with Ollama:
```
ollama run hf.co/miutti/intel-mac-local-llm:UD-Q2_K_XL
```
Unsloth Desktop

How to use miutti/intel-mac-local-llm with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf miutti/intel-mac-local-llm:UD-Q2_K_XL

Configure the model in Pi

# Install Pi:
npm install -g @earendil-works/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "miutti/intel-mac-local-llm:UD-Q2_K_XL"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use miutti/intel-mac-local-llm with Docker Model Runner:
```
docker model run hf.co/miutti/intel-mac-local-llm:UD-Q2_K_XL
```

Lemonade

How to use miutti/intel-mac-local-llm with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull miutti/intel-mac-local-llm:UD-Q2_K_XL

Run and chat with the model

lemonade run user.intel-mac-local-llm-UD-Q2_K_XL

List all available models

lemonade list

Hermes Agent

How to use miutti/intel-mac-local-llm with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf miutti/intel-mac-local-llm:UD-Q2_K_XL

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default miutti/intel-mac-local-llm:UD-Q2_K_XL

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use miutti/intel-mac-local-llm with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf miutti/intel-mac-local-llm:UD-Q2_K_XL

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "miutti/intel-mac-local-llm:UD-Q2_K_XL" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

intel-mac-local-llm / source /lib /rotate.py

miutti

Source: kernel, desktop app, tools (snapshot of the GitHub repo)

df41178 verified about 1 month ago

Raw History Blame Contribute Delete

2.42 kB

"""アダマール回転（インコヒーレンス処理）。
重み行列は少数の巨大な値と大量の小さい値で出来ていて、これが量子化に最悪。
直交行列で回転すると値が均されて「全部そこそこの大きさ」になり、
同じビット数でも表現しやすくなる。
肝は **回転行列を保存しなくていい** こと。アダマール行列は構造で決まり、
符号反転はシード1個で再現できるので、オーバーヘッドは実質ゼロ。
推論時は入力 x 側も同じ回転をかける（O(n log n)で安い）。
"""
import numpy as np


def fwht(a):
    """高速ウォルシュ・アダマール変換（最終軸に対して、正規化なし）。"""
    a = a.copy()
    n = a.shape[-1]
    assert n & (n - 1) == 0, "長さは2のべき乗が必要"
    h = 1
    while h < n:
        a = a.reshape(*a.shape[:-1], n // (2 * h), 2, h)
        x = a[..., 0, :].copy()
        y = a[..., 1, :].copy()
        a[..., 0, :] = x + y
        a[..., 1, :] = x - y
        a = a.reshape(*a.shape[:-3], n)
        h *= 2
    return a


def signs(n, seed):
    rng = np.random.default_rng(seed)
    return rng.choice(np.array([-1.0, 1.0], np.float32), size=n)


def rotate_rows(A, d, inverse=False):
    """A の最終軸に Q = H·diag(d)/√n を掛ける。inverse=True で Qᵀ。"""
    n = A.shape[-1]
    s = 1.0 / np.sqrt(n)
    # ★ 2026-09-07 訂正: ここの説明が逆だった。実測で確かめた事実は:
    #     inverse=False  →  A @ Qᵀ
    #     inverse=True   →  A @ Q      （Q = H·diag(d)/√n）
    #   上の docstring は逆に書いてあった。**直したのは説明であって計算ではない。**
    #   往復（False→True）で元に戻ることは確認済みなので、
    #   これまでの実験結果は1ビットも変わらない。
    if not inverse:
        return fwht(A * d) * s          # A Q^T 相当（Hは対称）
    return fwht(A) * d * s


def make(n, seed=0):
    """(重み用の回転関数, 活性化用の回転関数) を返す。両者は必ず打ち消し合う。"""
    d = signs(n, seed)

    def rot_W(W):                      # W' = W Q
        return rotate_rows(W, d, inverse=False)

    def rot_x(X):                      # x' = Qᵀ x   (X は (n, sample))
        return rotate_rows(X.T, d, inverse=False).T

    return rot_W, rot_x, d

	"""アダマール回転（インコヒーレンス処理）。

	重み行列は少数の巨大な値と大量の小さい値で出来ていて、これが量子化に最悪。
	直交行列で回転すると値が均されて「全部そこそこの大きさ」になり、
	同じビット数でも表現しやすくなる。

	肝は回転行列を保存しなくていいこと。アダマール行列は構造で決まり、
	符号反転はシード1個で再現できるので、オーバーヘッドは実質ゼロ。
	推論時は入力 x 側も同じ回転をかける（O(n log n)で安い）。
	"""
	import numpy as np


	def fwht(a):
	"""高速ウォルシュ・アダマール変換（最終軸に対して、正規化なし）。"""
	a = a.copy()
	n = a.shape[-1]
	assert n & (n - 1) == 0, "長さは2のべき乗が必要"
	h = 1
	while h < n:
	a = a.reshape(a.shape[:-1], n // (2 h), 2, h)
	x = a[..., 0, :].copy()
	y = a[..., 1, :].copy()
	a[..., 0, :] = x + y
	a[..., 1, :] = x - y
	a = a.reshape(*a.shape[:-3], n)
	h *= 2
	return a


	def signs(n, seed):
	rng = np.random.default_rng(seed)
	return rng.choice(np.array([-1.0, 1.0], np.float32), size=n)


	def rotate_rows(A, d, inverse=False):
	"""A の最終軸に Q = H·diag(d)/√n を掛ける。inverse=True で Qᵀ。"""
	n = A.shape[-1]
	s = 1.0 / np.sqrt(n)
	# ★ 2026-09-07 訂正: ここの説明が逆だった。実測で確かめた事実は:
	# inverse=False → A @ Qᵀ
	# inverse=True → A @ Q （Q = H·diag(d)/√n）
	# 上の docstring は逆に書いてあった。直したのは説明であって計算ではない。
	# 往復（False→True）で元に戻ることは確認済みなので、
	# これまでの実験結果は1ビットも変わらない。
	if not inverse:
	return fwht(A * d) * s # A Q^T 相当（Hは対称）
	return fwht(A) * d * s


	def make(n, seed=0):
	"""(重み用の回転関数, 活性化用の回転関数) を返す。両者は必ず打ち消し合う。"""
	d = signs(n, seed)

	def rot_W(W): # W' = W Q
	return rotate_rows(W, d, inverse=False)

	def rot_x(X): # x' = Qᵀ x (X は (n, sample))
	return rotate_rows(X.T, d, inverse=False).T

	return rot_W, rot_x, d