ローカルLLM用レシピ集

レシピ 1：個人用コーディングアシスタント（VRAM容量：8 GB、最低要件：10）

ハードウェア： 8 GB以上のVRAMを備えたGPU（RTX 3060や4060など同等品） 用途： エディタ内でのコード補完やチャット機能 バックエンド： OllamaとContinueまたはClineの組み合わせ

Ollamaをインストールし、7B用のコーディングモデルをダウンロードする

# Install Ollama (Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Pull a coding-optimized 7B model
ollama pull qwen2.5-coder:7b

モデルが正常に応答するか確認する

curl http://127.0.0.1:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-coder:7b",
    "messages": [{"role": "user", "content": "Write a Python hello world"}],
    "max_tokens": 100
  }'

Tokiosコネクターをインストールし、デプロイ設定を行う

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

In the dashboard, register a deployment named my-coder pointing at upstream qwen2.5-coder:7b. Create an API key.

ContinueまたはClineの設定を行う

{
  "baseURL": "https://api.tokios.com/v1",
  "apiKey": "sk-tok-YOUR_KEY",
  "model": "my-coder"
}

Expected performance: ~40 tok/s on an RTX 4060. Responsive tab completion and inline edits with 4K context.

レシピ 2：家族向けチャットボットサーバー（VRAMは16GB以上、最低要件は15分）

ハードウェア： 16 GBのVRAMを備えたGPU（RTX 4080や4070 Ti Superなど） 利用例： 家庭用に自己ホスティング可能なChatGPT風インターフェース バックエンド： Ollama、Open WebUI、そしてTokios

Ollamaを用いて14Bチャットモデルを起動します

ollama pull qwen2.5:14b

Dockerを利用してOpen WebUIを実行します

docker run -d \
  --name open-webui \
  -p 3000:8080 \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  -v open-webui:/app/backend/data \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Open http://localhost:3000 and create an admin account.

Tokiosを通じて外部からのアクセスを可能にします

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Register a deployment named family-chat pointing at qwen2.5:14b. Create an API key for each family member — scoped keys let you revoke access individually.

Expected performance: ~25 tok/s on an RTX 4080 with 8K context. Comfortable for multi-turn conversations.

各家族メンバーごとに別々のAPIキーを作成すれば、特定の人物のアクセス権のみを取り消すことも可能です

レシピ 3：チーム向けAPIエンドポイント（VRAMは48GB以上、最低要件は30分）

ハードウェア： 48ギガバイト以上のVRAMが必要です（A6000、2x RTX 4090、またはA100が対応機種です） 利用ケース： 開発チーム向けの共有モデルエンドポイント バックエンド： vLLMとTokiosを組み合わせて利用します

vLLMをインストールし、70Bモデルを起動する

pip install vllm

vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
  --host 127.0.0.1 \
  --port 8000 \
  --quantization awq \
  --gpu-memory-utilization 0.90 \
  --max-model-len 8192

vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
  --host 127.0.0.1 \
  --port 8000 \
  --quantization awq \
  --tensor-parallel-size 2 \
  --gpu-memory-utilization 0.90 \
  --max-model-len 8192

サーバーからの応答を確認する

curl http://127.0.0.1:8000/v1/models

Tokiosコネクターをインストールする

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

コネクターの接続先をhttp://127.0.0.1:8000/v1に設定する

デプロイを登録し、スコープ付きのAPIキーを作成する

Register a deployment named team-70b. In the Keys tab, create 1 key per teammate. Scope each key to the team-* pattern so teammates can only reach shared deployments.

想定される性能： AWQ量子化処理により、合計で約30トークン/秒のスループットが得られる。適切なレイテンシーで3から5件の同時リクエストにも対応可能だ。

With 2 GPUs, tensor parallelism gives better decode throughput than pipeline parallelism on a single node. See Tensor vs pipeline parallelism.

レシピ4：ドキュメントQ&Aパイプラインの構築（必要VRAM量：24GB、所要時間：約45分）

ハードウェア要件： 24GBのVRAMを備えたGPU（RTX 3090や4090など同等品） 利用例： PDFや各種文書に関する質問に答える際、データをクラウドに送信する必要がない バックエンド構成： Ollama（埋め込み処理およびチャット機能）＋独自開発のRAGスクリプト＋Tokios

埋め込み処理用モデルおよび32Bチャットモデルを取得する

ollama pull nomic-embed-text
ollama pull qwen2.5:32b

埋め込みモデル（約270 MB）は文書のベクトル表現を生成します。そして 32B モデルがこれらの埋め込み情報を基に質問に回答するのです。

シンプルなRAGパイプラインを構築する

import requests, json

EMBED_MODEL = "nomic-embed-text"
CHAT_MODEL  = "qwen2.5:32b"
OLLAMA_URL  = "http://127.0.0.1:11434"

def embed(text: str) -> list[float]:
    r = requests.post(f"{OLLAMA_URL}/api/embeddings",
                       json={"model": EMBED_MODEL, "prompt": text})
    return r.json()["embedding"]

def ask(question: str, context: str) -> str:
    prompt = f"Answer based on this context:\n\n{context}\n\nQuestion: {question}"
    r = requests.post(f"{OLLAMA_URL}/v1/chat/completions",
                       json={"model": CHAT_MODEL,
                             "messages": [{"role": "user", "content": prompt}],
                             "max_tokens": 512})
    return r.json()["choices"][0]["message"]["content"]

Tokiosを通じてチャットモデルを公開する

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Register a deployment named doc-qa pointing at qwen2.5:32b. Your RAG script can now call the model through https://api.tokios.com/v1 from any machine, while embeddings stay local.

Expected performance: ~15 tok/s for the 32B model on an RTX 4090. Embedding is near-instant for short passages.

埋め込みモデルはローカルに維持し（高速かつ小型なため）、チャットモデルのみをTokios経由で利用します。こうすることで、文書テキストをネットワーク経由で送信する必要がなくなります。

レシピ 5：DGX Sparkにおける最大スループット（128ギガバイト、20分間）

ハードウェア： NVIDIA DGX Spark（統合メモリ容量は128ギガバイト） 利用例： 大規模なMoEモデルにおける最大スループットの実現 バックエンド： vLLMおよびTokios

Launch a 120B MoE model at FP8

vllm serve Qwen/Qwen3-235B-A22B-FP8 \
  --host 127.0.0.1 \
  --port 8000 \
  --quantization fp8 \
  --gpu-memory-utilization 0.85 \
  --max-model-len 16384 \
  --trust-remote-code

DGX Sparkが備える128ギガバイトの統合メモリは、2から3程度の消費電力を持つ一般向けGPUで動作可能なモデルに対応します。Qwen3-235B-A22BのようなMoEモデルでは各トークン処理時に約22B個のパラメータのみが有効化されるため、全体のパラメータ数が多いにもかかわらず推論速度は速くなります。

動作確認およびベンチマークを実施する

curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-235B-A22B-FP8",
    "messages": [{"role": "user", "content": "Explain quantum entanglement"}],
    "max_tokens": 256
  }'

Tokios経由でモデルを公開する

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

想定されるパフォーマンス： 現在のパラメータ設定下では、DGX Spark上で約35トークン/秒の速度が得られる見込みです。16Kトークン分のコンテキストも統合メモリ内に問題なく収まります。

詳細な設定オプションについては、DGX Spark上のvLLMおよびDGX Sparkのメモリチューニングをご参照ください。

レシピ 6：ノートパソコンでも利用可能なオフラインAI（必要メモリ量は16GB、動作に必要な最小メモリは5GBです）

ハードウェア： RAM容量が16ギガバイト以上のノートパソコンであればどれでも構いません（専用GPUは不要です） 利用例： インターネット接続なしでも動作するプライベートなAIアシスタント バックエンド： Ollama（CPUモード）

Ollamaをインストールし、量子化済みの7Bモデルをダウンロードしてください。

# macOS
curl -fsSL https://ollama.com/install.sh | sh

# Or download from https://ollama.com for Windows/Linux
ollama pull qwen2.5:7b-instruct-q4_K_M

Q4_K_M量子化方式によりモデルサイズは5GB未満に抑えられ、16GBのRAMしかないCPU環境でも問題なく動作します。

インターネット接続なしでもローカルでチャットが可能です。

ollama run qwen2.5:7b-instruct-q4_K_M

以上です。モデルはすべてご自身のノートパソコン内で動作します。ネットワーク通信やテレメトリ、APIキーの使用も一切ありません。

オンライン時にはTokios経由でモデルを外部に公開することも可能です。

インターネットに接続可能な環境で他のデバイスからモデルにアクセスしたい場合は：

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Register a deployment named laptop-offline. The connector only dials out when the network is available — offline, your model keeps working locally.

想定されるパフォーマンス： 最新のノートパソコンのCPU上で約5トークン/秒の速度が得られる見込みです。チャットや文章作成には適していますが、リアルタイムなコーディング支援には向きません。

ご使用のノートパソコンにApple製のシリコンチップが搭載されている場合、Ollamaは自動的にニューラルエンジンおよびMetalを利用する。Mシリーズチップでは20から30トークン/秒の速度が見込まれる。

レシピ7：複数モデルのルーティング機能（24GB以上のVRAM、最低30分の稼働時間が必要）

Hardware: 24 GB+ VRAM GPU Use case: Serve 3 models of different sizes through 1 Tokios endpoint Backend: Ollama or vLLM + Tokios with config file

サイズの異なる3種類のモデルを取得する

ollama pull qwen2.5:3b     # fast-small: quick classification
ollama pull qwen2.5:14b    # medium: general chat
ollama pull qwen2.5:32b    # large: complex reasoning

マルチルート用のコネクター設定を作成する

Create tokios-connector.json:

{
  "Routes": [
    { "Deployment": "fast-small", "Upstream": "local-ollama" },
    { "Deployment": "medium",     "Upstream": "local-ollama" },
    { "Deployment": "large",      "Upstream": "local-ollama" }
  ],
  "Upstreams": {
    "local-ollama": {
      "BaseUrl": "http://127.0.0.1:11434/v1"
    }
  }
}

ダッシュボード内に3個のデプロイをすべて登録する

In the Models tab, register:

デプロイ名	アップストリームモデルID
`fast-small`	`qwen2.5:3b`
`medium`	`qwen2.5:14b`
`large`	`qwen2.5:32b`

modelフィールドを送信することでルーティングを行う

from openai import OpenAI

client = OpenAI(
    base_url="https://api.tokios.com/v1",
    api_key="sk-tok-YOUR_KEY",
)

# Fast classification
client.chat.completions.create(
    model="fast-small",
    messages=[{"role": "user", "content": "Is this email spam? ..."}],
)

# Complex reasoning
client.chat.completions.create(
    model="large",
    messages=[{"role": "user", "content": "Analyze this contract clause..."}],
)

Expected performance: The 3B model responds in under 1 second. The 32B model takes 2–3 seconds for the first token but produces higher-quality output. Same endpoint, same key, different model field.

デフォルト設定ではOllamaは一度にVRAM内に 1個のモデルのみを保持し、必要に応じてモデルを入れ替えます。全ての 3個のモデルを同時に読み込む必要がある場合は、個別のバックエンドを起動するか、LoRAアダプター付きのvLLMを利用してください。詳細はモデルルーティングをご覧ください。

レシピ 8：ご使用環境のベンチマーク（どのようなハードウェアでも可、所要時間は最低 10分）

ハードウェア： ローカルモデルを実行可能な任意のGPUまたはCPU 利用例： 異なるモデルや量子化レベル、ハードウェア間でのスループットやレイテンシーを比較する バックエンド： 任意のもの＋Tokios

モデルサーバーを起動します

Ollama、vLLM、llama.cpp、LM Studioなど任意のバックエンドを使用して構いません。その /v1エンドポイントから正しく応答が返ってくることを確認してください。

スループットのベンチマークを実行します

# Simple throughput test with curl and timing
for i in 1 2 3 4 5; do
  time curl -s http://127.0.0.1:11434/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
      "model": "qwen2.5:7b",
      "messages": [{"role": "user", "content": "Write a 200-word essay about recursion"}],
      "max_tokens": 256,
      "stream": false
    }' | python3 -c "
import sys, json
r = json.load(sys.stdin)
u = r['usage']
print(f\"Tokens: {u['completion_tokens']}, Time: check wall clock\")
"
done

Tokios経由でベンチマークを行い、エンドツーエンドのレイテンシーを測定します

# Same test through the Tokios endpoint
time curl -s https://api.tokios.com/v1/chat/completions \
  -H "Authorization: Bearer sk-tok-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "my-deployment",
    "messages": [{"role": "user", "content": "Write a 200-word essay about recursion"}],
    "max_tokens": 256,
    "stream": false
  }' | python3 -c "
import sys, json
r = json.load(sys.stdin)
u = r['usage']
print(f\"Tokens: {u['completion_tokens']}\")
"

各量子化レベルを比較します

同じモデルを異なる量子化レベルで取得し、それぞれについてベンチマークを行います

ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:7b-instruct-q5_K_M
ollama pull qwen2.5:7b-instruct-q8_0

Run the same prompt against each and compare tokens per second. Q5_K_M typically gives the best quality-to-speed trade-off at 7B.

予想される結果： このトンネル機能により、各リクエストごとに 50～150ミリ秒のレイテンシーが増加します（Tokiosゲートウェイへの往復で 1ミリ秒）。ストリーミング時のスループットはローカル実行時とほぼ同等で、トンネル側でSSEデータがバッファリングされることはありません

より体系的なベンチマークを行いたい場合はデプロイ環境のベンチマークをご参照ください

事例紹介

ローカルモデルを利用しているチームや個人による実際のデプロイパターン

ローカルモデルの選定

ご使用のハードウェアやワークフローに最適なモデルおよび量子化方式を選ぶ

モデルルーティング

複数のデプロイを登録し、モデルフィールドの値を変更するだけでモデルを切り替えられる

クイックスタート

ゼロから始めて、動作するコネクター、デプロイ、およびAPIキーを作成する手順

はじめに

モデル

概念

リファレンス

ローカルLLM用レシピ集

次に行うべき手順

事例紹介

ローカルモデルの選定

モデルルーティング

クイックスタート

​次に行うべき手順

事例紹介

ローカルモデルの選定

モデルルーティング

クイックスタート

次に行うべき手順