third-party-mirrors/ollama
1
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge 76c310898404e407405b321a96b7905842d8e1d3 into d7eb05b9361febead29a74e71ddffc2ebeff5302

Browse Source
This commit is contained in:
Jesse C. Lin 2024-11-14 13:58:20 +08:00 committed by GitHub
commit 349c69ccbe
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
16 changed files with 2820 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

357
README_ja.md Normal file
View File

@ -0,0 +1,357 @@
<div align="center">
<img alt="ollama" height="200px" src="https://github.com/jmorganca/ollama/assets/3325447/0d0b44e2-8f4a-4e99-9b52-a5c1c741c8f7">
</div>
# Ollama
[![Discord](https://dcbadge.vercel.app/api/server/ollama?style=flat&compact=true)](https://discord.gg/ollama)
大規模な言語モデルをローカルでセットアップし、実行しましょう。
### macOS
[Download](https://ollama.com/download/Ollama-darwin.zip)
### Windows プレビュー
[Download](https://ollama.com/download/OllamaSetup.exe)
### Linux
```
curl -fsSL https://ollama.com/install.sh | sh
```
[手動インストール手順](./docs/ja/linux.md)
### Docker
公式の [Ollama Docker イメージ](https://hub.docker.com/r/ollama/ollama) である `ollama/ollama` は Docker Hub で利用可能です。
### ライブラリー
- [ollama-python](https://github.com/ollama/ollama-python)
- [ollama-js](https://github.com/ollama/ollama-js)
## クイックスタート
[Llama 2](https://ollama.com/library/llama2) を実行してチャットするには：
```
ollama run llama2
```
## モデルライブラリ
Ollama は、[ollama.com/library](https://ollama.com/library 'ollama model library')で利用可能なモデルのリストをサポートしています。
以下は、ダウンロード可能ないくつかのモデルの例です：
| モデル | パラメーター | サイズ | ダウンロード |
| ------------------ | ----------- | ------- | ------------------------------ |
| Llama 2 | 7B | 3.8GB | `ollama run llama2` |
| Mistral | 7B | 4.1GB | `ollama run mistral` |
| Dolphin Phi | 2.7B | 1.6GB | `ollama run dolphin-phi` |
| Phi-2 | 2.7B | 1.7GB | `ollama run phi` |
| Neural Chat | 7B | 4.1GB | `ollama run neural-chat` |
| Starling | 7B | 4.1GB | `ollama run starling-lm` |
| Code Llama | 7B | 3.8GB | `ollama run codellama` |
| Llama 2 Uncensored | 7B | 3.8GB | `ollama run llama2-uncensored` |
| Llama 2 13B | 13B | 7.3GB | `ollama run llama2:13b` |
| Llama 2 70B | 70B | 39GB | `ollama run llama2:70b` |
| Orca Mini | 3B | 1.9GB | `ollama run orca-mini` |
| Vicuna | 7B | 3.8GB | `ollama run vicuna` |
| LLaVA | 7B | 4.5GB | `ollama run llava` |
| Gemma | 2B | 1.4GB | `ollama run gemma:2b` |
| Gemma | 7B | 4.8GB | `ollama run gemma:7b` |
>注意: 7Bモデルを実行するには少なくとも8 GBのRAMが必要であり、13Bモデルを実行するには16 GB、33Bモデルを実行するには32 GBが必要です。
## モデルをカスタマイズする
### GGUF からインポート
Ollama は Modelfile での GGUF モデルのインポートをサポートしています。
1. `Modelfile` という名前のファイルを作成し、インポートしたいモデルのローカルファイルパスを指定する `FROM` 命令を記述します。
```
FROM ./vicuna-33b.Q4_0.gguf
```
2. Ollama でモデルを作成します。
```
ollama create example -f Modelfile
```
3. モデルを実行します。
```
ollama run example
```
### PyTorch または Safetensor からのインポート
詳細については、[ガイド](docs/ja/import.md)を参照してください。
### プロンプトをカスタマイズする
Ollama ライブラリのモデルは、プロンプトでカスタマイズできます。たとえば、`llama2` モデルをカスタマイズするには、次のようにします：
```
ollama pull llama2
```
`Modelfile`を作成してください：
```
FROM llama2
# 温度を1に設定してください（高いほど創造的、低いほど論理的）。
PARAMETER temperature 1
# システムメッセージを設定してください。
SYSTEM """
あなたはスーパーマリオブラザーズのマリオです。マリオ、アシスタントとしてのみお答えください。
"""
```
次に、モデルを作成して実行してください：
```
ollama create mario -f ./Modelfile
ollama run mario
>>> こんにちは！
マリオだよ。
```
さらなる例については、[examples](examples) ディレクトリを参照してください。Modelfileの操作に関する詳細は、[Modelfile](docs/ja/modelfile.md) のドキュメントをご覧ください。
## CLI リファレンス
### モデルを作成する
`ollama create` は、Modelfile からモデルを作成するために使用されます。
```
ollama create mymodel -f ./Modelfile
```
### モデルを引っ張る
```
ollama pull llama2
```
> このコマンドは、ローカルのモデルを更新するためにも使用できます。
差分のみが取得されます。
### モデルを削除する
```
ollama rm llama2
```
### モデルをコピーする
```
ollama cp llama2 my-llama2
```
### 複数行入力
複数行の入力の場合、テキストを `"""` で囲むことができます：
```
>>> """こんにちは、
... 世界！
... """
私は基本的なプログラムで、コンソールに有名な「こんにちは、世界！」のメッセージを表示します。
```
### マルチモーダルモデル
```
>>> この画像には何がありますか？ /Users/jmorgan/Desktop/smile.png
画像には黄色い笑顔の絵文字があり、おそらく画像の中心的な焦点です。
```
### プロンプトを引数として渡します
```
$ ollama run llama2 "このファイルを要約してください：$(cat README_ja.md)"
Ollama は、ローカルマシン上で言語モデルを構築および実行するための軽量で拡張可能なフレームワークです。モデルの作成、実行、および管理のためのシンプルな API を提供し、さらにさまざまなアプリケーションで簡単に使用できる事前に構築されたモデルのライブラリも提供しています。
```
### コンピュータ上のモデルをリストする
```
ollama list
```
### オラマを開始
`ollama serve` は、デスクトップアプリケーションを実行せずにOllama を起動したい場合に使用します。
## ビルディング
`cmake`と`go`をインストールしてください:
```
brew install cmake go
```
その後、依存関係を生成してください:
```
go generate ./...
```
その後、バイナリをビルドしてください:
```
go build .
```
より詳細な手順は[開発者ガイド](./docs/ja/development.md)に記載されています。
### ローカルビルドの実行
次に、サーバーを起動しますL
```
./ollama serve
```
最後に、別のシェルでモデルを実行します:
```
./ollama run llama2
```
## REST API
Ollama にはモデルの実行と管理のための REST API があります。
### 応答を生成する
```
curl http://localhost:11434/api/generate -d '{
"model": "llama2",
"prompt":"空はなぜ青いのでしょうか？"
}'
```
### モデルとチャットする
```
curl http://localhost:11434/api/chat -d '{
"model": "mistral",
"messages": [
{ "role": "user", "content": "空はなぜ青いのでしょうか？" }
]
}'
```
すべてのエンドポイントについては、[APIドキュメント](./docs/ja/api.md)を参照してください。
## コミュニティの統合
### ウェブとデスクトップ
- [Bionic GPT](https://github.com/bionic-gpt/bionic-gpt)
- [Enchanted (macOS native)](https://github.com/AugustDev/enchanted)
- [HTML UI](https://github.com/rtcfirefly/ollama-ui)
- [Chatbot UI](https://github.com/ivanfioravanti/chatbot-ollama)
- [Typescript UI](https://github.com/ollama-interface/Ollama-Gui?tab=readme-ov-file)
- [Minimalistic React UI for Ollama Models](https://github.com/richawo/minimal-llm-ui)
- [Open WebUI](https://github.com/open-webui/open-webui)
- [Ollamac](https://github.com/kevinhermawan/Ollamac)
- [big-AGI](https://github.com/enricoros/big-AGI/blob/main/docs/config-local-ollama.md)
- [Cheshire Cat assistant framework](https://github.com/cheshire-cat-ai/core)
- [Amica](https://github.com/semperai/amica)
- [chatd](https://github.com/BruceMacD/chatd)
- [Ollama-SwiftUI](https://github.com/kghandour/Ollama-SwiftUI)
- [MindMac](https://mindmac.app)
- [NextJS Web Interface for Ollama](https://github.com/jakobhoeg/nextjs-ollama-llm-ui)
- [Msty](https://msty.app)
- [Chatbox](https://github.com/Bin-Huang/Chatbox)
- [WinForm Ollama Copilot](https://github.com/tgraupmann/WinForm_Ollama_Copilot)
- [NextChat](https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web) with [Get Started Doc](https://docs.nextchat.dev/models/ollama)
- [Odin Runes](https://github.com/leonid20000/OdinRunes)
- [LLM-X: Progressive Web App](https://github.com/mrdjohnson/llm-x)
### ターミナル
- [oterm](https://github.com/ggozad/oterm)
- [Ellama Emacs client](https://github.com/s-kostyaev/ellama)
- [Emacs client](https://github.com/zweifisch/ollama)
- [gen.nvim](https://github.com/David-Kunz/gen.nvim)
- [ollama.nvim](https://github.com/nomnivore/ollama.nvim)
- [ollama-chat.nvim](https://github.com/gerazov/ollama-chat.nvim)
- [ogpt.nvim](https://github.com/huynle/ogpt.nvim)
- [gptel Emacs client](https://github.com/karthink/gptel)
- [Oatmeal](https://github.com/dustinblackman/oatmeal)
- [cmdh](https://github.com/pgibler/cmdh)
- [tenere](https://github.com/pythops/tenere)
- [llm-ollama](https://github.com/taketwo/llm-ollama) for [Datasette's LLM CLI](https://llm.datasette.io/en/stable/).
- [ShellOracle](https://github.com/djcopley/ShellOracle)
### データベース
- [MindsDB](https://github.com/mindsdb/mindsdb/blob/staging/mindsdb/integrations/handlers/ollama_handler/README.md)
### パッケージマネージャー
- [Pacman](https://archlinux.org/packages/extra/x86_64/ollama/)
- [Helm Chart](https://artifacthub.io/packages/helm/ollama-helm/ollama)
### ライブラリー
- [LangChain](https://python.langchain.com/docs/integrations/llms/ollama) and [LangChain.js](https://js.langchain.com/docs/modules/model_io/models/llms/integrations/ollama) with [example](https://js.langchain.com/docs/use_cases/question_answering/local_retrieval_qa)
- [LangChainGo](https://github.com/tmc/langchaingo/) with [example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example)
- [LangChain4j](https://github.com/langchain4j/langchain4j) with [example](https://github.com/langchain4j/langchain4j-examples/tree/main/ollama-examples/src/main/java)
- [LlamaIndex](https://gpt-index.readthedocs.io/en/stable/examples/llm/ollama.html)
- [LangChain4j](https://github.com/langchain4j/langchain4j/tree/main/langchain4j-ollama)
- [LiteLLM](https://github.com/BerriAI/litellm)
- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp)
- [Ollama for Ruby](https://github.com/gbaptista/ollama-ai)
- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs)
- [Ollama4j for Java](https://github.com/amithkoujalgi/ollama4j)
- [ModelFusion Typescript Library](https://modelfusion.dev/integration/model-provider/ollama)
- [OllamaKit for Swift](https://github.com/kevinhermawan/OllamaKit)
- [Ollama for Dart](https://github.com/breitburg/dart-ollama)
- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel)
- [LangChainDart](https://github.com/davidmigloz/langchain_dart)
- [Semantic Kernel - Python](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/ai/ollama)
- [Haystack](https://github.com/deepset-ai/haystack-integrations/blob/main/integrations/ollama.md)
- [Elixir LangChain](https://github.com/brainlid/langchain)
- [Ollama for R - rollama](https://github.com/JBGruber/rollama)
- [Ollama-ex for Elixir](https://github.com/lebrunel/ollama-ex)
- [Ollama Connector for SAP ABAP](https://github.com/b-tocs/abap_btocs_ollama)
### 携帯
- [Enchanted](https://github.com/AugustDev/enchanted)
- [Maid](https://github.com/Mobile-Artificial-Intelligence/maid)
### 拡張機能とプラグイン
- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama)
- [Discollama](https://github.com/mxyng/discollama) (Discord bot inside the Ollama discord channel)
- [Continue](https://github.com/continuedev/continue)
- [Obsidian Ollama plugin](https://github.com/hinterdupfinger/obsidian-ollama)
- [Logseq Ollama plugin](https://github.com/omagdy7/ollama-logseq)
- [NotesOllama](https://github.com/andersrex/notesollama) (Apple Notes Ollama plugin)
- [Dagger Chatbot](https://github.com/samalba/dagger-chatbot)
- [Discord AI Bot](https://github.com/mekb-turtle/discord-ai-bot)
- [Ollama Telegram Bot](https://github.com/ruecat/ollama-telegram)
- [Hass Ollama Conversation](https://github.com/ej52/hass-ollama-conversation)
- [Rivet plugin](https://github.com/abrenneke/rivet-plugin-ollama)
- [Llama Coder](https://github.com/ex3ndr/llama-coder) (Copilot alternative using Ollama)
- [Obsidian BMO Chatbot plugin](https://github.com/longy2k/obsidian-bmo-chatbot)
- [Copilot for Obsidian plugin](https://github.com/logancyang/obsidian-copilot)
- [Obsidian Local GPT plugin](https://github.com/pfrankov/obsidian-local-gpt)
- [Open Interpreter](https://docs.openinterpreter.com/language-model-setup/local-models/ollama)
- [twinny](https://github.com/rjmacarthy/twinny) (Copilot and Copilot chat alternative using Ollama)
- [Wingman-AI](https://github.com/RussellCanfield/wingman-ai) (Copilot code and chat alternative using Ollama and HuggingFace)
- [Page Assist](https://github.com/n4ze3m/page-assist) (Chrome Extension)

21
docs/ja/README.md Normal file
View File

@ -0,0 +1,21 @@
# ドキュメンテーション
### はじめに
* [クイックスタート](../../README_ja.md#クイックスタート)
* [例](../../examples)
* GGUF、Pytorch、Safetensors からのモデルの[インポート](./import.md)
* [Linux ドキュメント](./linux.md)
* [Windows ドキュメント](./windows.md)
* [Docker ドキュメント](https://hub.docker.com/r/ollama/ollama)
### 参照
* [API リファレンス](./api.md)
* [モデルファイルリファレンス](./modelfile.md)
* [OpenAI の互換性](./openai.md)
### リソース
* [トラブルシューティングガイド](./troubleshooting.md)
* [よくある質問](./faq.md)
* [開発ガイド](./development.md)

1049
docs/ja/api.md Normal file
View File

File diff suppressed because it is too large Load Diff

129
docs/ja/development.md Normal file
View File

@ -0,0 +1,129 @@
# 開発
必要なツールをインストールしてください：
- cmake バージョン 3.24 以上
- go バージョン 1.22 以上
- gcc バージョン 11.4.0 以上
```bash
brew install go cmake gcc
```
オプションでデバッグおよび詳細なログを有効にする:
```bash
# ビルド時
export CGO_CFLAGS="-g"
# 実行時
export OLLAMA_DEBUG=1
```
必要なライブラリを取得し、ネイティブ LLM コードをビルドしてください:
```bash
go generate ./...
```
次に、Ollama をビルドしてください:
```bash
go build .
```
これで、`ollama` を実行できます:
```bash
./ollama
```
### Linux
#### Linux CUDA (NVIDIA)
_お使いのオペレーティングシステムディストリビューションには、既に NVIDIA CUDA 用のパッケージが含まれているかもしれません。ディストリビューションパッケージは通常好ましいですが、手順はディストリビューションに依存します。可能であれば、ディストリビューション固有のドキュメントを確認して、依存関係に関する情報を参照してください。_
`cmake` および `golang` をインストールし、[NVIDIA CUDA](https://developer.nvidia.com/cuda-downloads) の開発およびランタイムパッケージもインストールしてください。
通常、ビルドスクリプトは CUDA を自動検出しますが、Linux ディストリビューションやインストールアプローチが異常なパスを使用する場合は、環境変数 `CUDA_LIB_DIR` を共有ライブラリの場所に、`CUDACXX` を nvcc コンパイラの場所に指定することができます。また、`CMAKE_CUDA_ARCHITECTURES` を設定して、対象の CUDA アーキテクチャをカスタマイズできます（例："50;60;70"）。
その後、依存関係を生成してください:
```
go generate ./...
```
その後、バイナリをビルドしてください:
```
go build .
```
#### Linux ROCm (AMD)
_お使いのオペレーティングシステムディストリビューションには、すでに AMD ROCm および CLBlast 用のパッケージが含まれているかもしれません。ディストリビューションパッケージは通常好ましいですが、手順はディストリビューションに依存します。可能であれば、ディストリビューション固有のドキュメントを確認して、依存関係に関する情報を参照してください。_
まず、[CLBlast](https://github.com/CNugteren/CLBlast/blob/master/doc/installation.md)と[ROCm](https://rocm.docs.amd.com/en/latest/deploy/linux/quick_start.html)の開発パッケージ、および `cmake` と `golang` をインストールしてください。
通常、ビルドスクリプトは ROCm を自動検出しますが、Linux ディストリビューションやインストールアプローチが異常なパスを使用する場合は、環境変数 `ROCM_PATH` を ROCm のインストール場所に（通常は `/opt/rocm`）、`CLBlast_DIR` を CLBlast のインストール場所に（通常は `/usr/lib/cmake/CLBlast`）指定することができます。また、`AMDGPU_TARGETS` を設定して AMD GPU の対象をカスタマイズすることもできます（例：`AMDGPU_TARGETS="gfx1101;gfx1102"`）。
```
go generate ./...
```
その後、バイナリをビルドしてください:
```
go build .
```
ROCm は実行時に GPU にアクセスするために特権が必要です。ほとんどのディストリビューションでは、ユーザーアカウントを `render` グループに追加するか、root として実行することができます。
#### 高度なCPU設定
デフォルトでは、`go generate ./...` を実行すると、一般的な CPU ファミリとベクトル数学の機能に基づいて、いくつかの異なる LLM ライブラリのバリエーションがコンパイルされます。これには、ほとんどの 64 ビット CPU で動作する最も一般的なバージョンも含まれますが、やや遅くなります。実行時に、Ollama は最適なバリエーションを自動検出してロードします。プロセッサにカスタマイズされた CPU ベースのビルドを作成したい場合は、`OLLAMA_CUSTOM_CPU_DEFS` を使用する llama.cpp フラグに設定できます。例えば、Intel i9-9880H 向けに最適化されたバイナリをコンパイルする場合は、次のようにします：
```
OLLAMA_CUSTOM_CPU_DEFS="-DLLAMA_AVX=on -DLLAMA_AVX2=on -DLLAMA_F16C=on -DLLAMA_FMA=on" go generate ./...
go build .
```
#### コンテナ化された Linux ビルド
Docker が利用可能な場合、CUDA および ROCm の依存関係が含まれている `./scripts/build_linux.sh` を使用して Linux 用のバイナリをビルドできます。生成されたバイナリは `./dist` に配置されます。
### Windows
注意：Ollama の Windows ビルドはまだ開発中です。
必要なツールをインストールしてください：
- MSVC ツールチェーン - C/C++ および cmake を最小の要件として - 環境変数を設定した "Developer Shell" からビルドする必要があります
- go のバージョン 1.22 以上
- GCC を搭載した MinGW（いずれかを選択）
- <https://www.mingw-w64.org/>
- <https://www.msys2.org/>
```powershell
$env:CGO_ENABLED="1"
go generate ./...
go build .
```
#### Windows CUDA (NVIDIA)
上記で説明した一般的な Windows 開発ツールに加えて、MSVC をインストールした**後**に CUDA をインストールしてください。
- [NVIDIA CUDA](https://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html)
#### Windows ROCm (AMD Radeon)
上記で説明した一般的な Windows 開発ツールに加えて、MSVC をインストールした**後**に AMD の HIP パッケージをインストールしてください。
- [AMD HIP](https://www.amd.com/en/developer/resources/rocm-hub/hip-sdk.html)

192
docs/ja/faq.md Normal file
View File

@ -0,0 +1,192 @@
# FAQ
## Ollama をアップグレードする方法はどのようになりますか？
macOS と Windows 上の Ollama は自動的にアップデートをダウンロードします。タスクバーまたはメニューバーのアイテムをクリックして、"Restart to update" をクリックすると、アップデートが適用されます。また、最新バージョンを [手動でダウンロード](https://ollama.com/download/) してインストールすることもできます。
Linux では、インストールスクリプトを再実行します：
```
curl -fsSL https://ollama.com/install.sh | sh
```
## ログを表示する方法は？
ログの使用についての詳細については、[トラブルシューティング](./troubleshooting.md)のドキュメントを参照してください。
## コンテキストウィンドウサイズを指定する方法は？
デフォルトでは、Ollama は 2048 トークンのコンテキストウィンドウサイズを使用します。
`ollama run` を使用する場合は、`/set parameter` を使用してこれを変更します：
```
/set parameter num_ctx 4096
```
API を使用する場合は、`num_ctx` パラメータを指定します：
```
curl http://localhost:11434/api/generate -d '{
"model": "llama2",
"prompt": "Why is the sky blue?",
"options": {
"num_ctx": 4096
}
}'
```
<div id="how-do-i-configure-ollama-server">
<h2>Ollama サーバーの設定方法は？</h2>
</div>
### Mac での環境変数の設定
Ollama が macOS アプリケーションとして実行される場合、環境変数は `launchctl` を使用して設定する必要があります：
1. 各環境変数に対して、`launchctl setenv` を呼び出します。
```bash
launchctl setenv OLLAMA_HOST "0.0.0.0"
```
2. Ollama アプリケーションを再起動します。
### Linux での環境変数の設定
Ollama が systemd サービスとして実行される場合、環境変数は`systemctl` を使用して設定する必要があります：
1. `systemctl edit ollama.service` を呼び出して、systemd サービスを編集します。これによりエディタが開きます。
2. 各環境変数に対して、`[Service]` セクションの下に `Environment` という行を追加します：
```ini
[Service]
Environment="OLLAMA_HOST=0.0.0.0"
```
3. 保存して終了します。
4. `systemd` をリロードし、Ollama を再起動します：
```bash
systemctl daemon-reload
systemctl restart ollama
```
### Windows での環境変数の設定方法
Windows では、Ollama はユーザーとシステムの環境変数を継承します。
1. 最初に、タスクバーで Ollama をクリックして終了します。
2. コントロールパネルからシステムの環境変数を編集します。
3. ユーザーアカウントのために `OLLAMA_HOST`、 `OLLAMA_MODELS` などの変数を編集または新しく作成します。
4. 保存するために OK/Apply をクリックします。
5. 新しいターミナルウィンドウから `ollama` を実行します。
## Ollama をネットワークで公開する方法は？
Ollama はデフォルトで 127.0.0.1 ポート 11434 にバインドされます。バインドアドレスを変更するには、`OLLAMA_HOST` 環境変数を使用してください。
環境変数の設定方法については、[上記](#how-do-i-configure-ollama-server)のセクションを参照してください。
## 追加の web origins が Ollama にアクセスできるようにする方法は？
Ollama はデフォルトで `127.0.0.1` および `0.0.0.0` からのクロスオリジンリクエストを許可します。追加の origins は `OLLAMA_ORIGINS`で構成できます。
環境変数の設定方法については、[上記](#how-do-i-configure-ollama-server)のセクションを参照してください。
## モデルはどこに保存されていますか？
- macOS: `~/.ollama/models`
- Linux: `/usr/share/ollama/.ollama/models`
- Windows: `C:\Users\<username>\.ollama\models`
### それらを異なる場所に設定するにはどうすればよいですか？
別のディレクトリを使用する必要がある場合は、環境変数 `OLLAMA_MODELS` を選択したディレクトリに設定してください。
環境変数の設定方法については、[上記](#how-do-i-configure-ollama-server)のセクションを参照してください。
## Ollama は、プロンプトや回答を ollama.com に送信しますか？
いいえ。Ollama はローカルで実行され、会話データはあなたのマシンから出ません。
## Visual Studio Code で Ollama を使用する方法は？
既に VSCode や他のエディタで Ollama を活用するための多くのプラグインが利用可能です。メインリポジトリの末尾にある[拡張機能とプラグイン](https://github.com/jmorganca/ollama#extensions--plugins)のリストをご覧ください。
## プロキシを使用する方法は？
`HTTP_PROXY` または `HTTPS_PROXY` が構成されている場合、Ollama はプロキシサーバーと互換性があります。これらの変数を使用する場合は、`ollama serve` が値にアクセスできるように設定されていることを確認してください。`HTTPS_PROXY` を使用する場合は、プロキシ証明書がシステム証明書としてインストールされていることを確認してください。環境変数の設定方法については、上記のセクションを参照してください。
### Docker 内でプロキシを使用する方法は？
Ollama Docker コンテナイメージは、コンテナを起動する際に `-e HTTPS_PROXY=https://proxy.example.com` を渡すことでプロキシを使用するように構成できます。
代替として、Docker デーモン自体をプロキシを使用するように構成することもできます。Docker Desktop の[macOS](https://docs.docker.com/desktop/settings/mac/#proxies)、[Windows](https://docs.docker.com/desktop/settings/windows/#proxies)、[Linux](https://docs.docker.com/desktop/settings/linux/#proxies) に関する手順が利用可能であり、またDocker [daemon with systemd](https://docs.docker.com/config/daemon/systemd/#httphttps-proxy) についても指示があります。
HTTPS を使用する場合は、証明書がシステム証明書としてインストールされていることを確認してください。これには、自己署名証明書を使用する場合には新しい Docker イメージが必要となるかもしれません。
```dockerfile
FROM ollama/ollama
COPY my-ca.pem /usr/local/share/ca-certificates/my-ca.crt
RUN update-ca-certificates
```
このイメージをビルドして実行します：
```shell
docker build -t ollama-with-ca .
docker run -d -e HTTPS_PROXY=https://my.proxy.example.com -p 11434:11434 ollama-with-ca
```
## Docker 内で GPU アクセラレーションを使用する方法は？
Ollama Docker コンテナは、Linux または Windows（WSL2を使用する場合）で GPU アクセラレーションを構成することができます。これには [nvidia-container-toolkit](https://github.com/NVIDIA/nvidia-container-toolkit) が必要です。詳細については、[ollama/ollama](https://hub.docker.com/r/ollama/ollama) を参照してください。
GPU アクセラレーションは、macOS の Docker Desktop では GPU のパススルーやエミュレーションの不足のため利用できません。
## Windows 10 の WSL2 でネットワーキングが遅いのはなぜですか？
これは Ollama のインストールやモデルのダウンロードに影響する可能性があります。
`Control Panel > Networking and Internet > View network status and tasks` を開き、左パネルで `Change adapter settings` をクリックします。`vEthernel (WSL)` アダプターを見つけ、右クリックして `Properties` を選択します。
`Configure` をクリックし、`Advanced` タブを開きます。各プロパティを検索し、`Large Send Offload Version 2 (IPv4)` および `Large Send Offload Version 2 (IPv6)` を見つけるまで調べてください。これらのプロパティは *無効* にしてください。
## モデルを事前にロードして応答時間を短縮する方法は？
API を使用している場合、空のリクエストを Ollama サーバーに送信することで、モデルを事前にロードすることができます。これは、`/api/generate` および `/api/chat` API エンドポイントの両方で機能します。
ジェネレートエンドポイントを使用して mistral モデルを事前にロードするには、次のコマンドを使用します：
```shell
curl http://localhost:11434/api/generate -d '{"model": "mistral"}'
```
チャット補完エンドポイントを使用する場合は、次のコマンドを使用します：
```shell
curl http://localhost:11434/api/chat -d '{"model": "mistral"}'
```
## モデルをメモリにロードしたままにする方法、または即時にアンロードする方法は？
デフォルトでは、モデルはメモリに 5分間保持された後にアンロードされます。これにより、LLM に対して多数のリクエストを行う場合に応答時間を短縮できます。ただし、5分が経過する前にメモリを解放したい場合や、モデルを無期限にロードしたい場合があります。モデルがメモリに残る時間を制御するために、`/api/generate` および `/api/chat` API エンドポイントの `keep_alive` パラメーターを使用します。
`keep_alive` パラメーターには、次のような値を設定できます：
* 持続時間文字列（"10m" や "24h" など）
* 秒数での数値（3600 など）
* 負の数値は、モデルをメモリにロードしたままにします（例：-1 または "-1m"）。
* レスポンスの生成後すぐにモデルをアンロードするための '0'
例えば、モデルを事前にロードしてメモリに残す場合は、次のコマンドを使用します：
```shell
curl http://localhost:11434/api/generate -d '{"model": "llama2", "keep_alive": -1}'
```
モデルをアンロードしてメモリを解放するには、次のコマンドを使用します：
```shell
curl http://localhost:11434/api/generate -d '{"model": "llama2", "keep_alive": 0}'
```

169
docs/ja/import.md Normal file
View File

@ -0,0 +1,169 @@
# Import a model
このガイドでは、GGUF、PyTorch、または Safetensors モデルのインポート手順について説明します。
## インポート（GGUF）
### Step 1：`Modelfile` を作成します
`Modelfile` を作成して始めましょう。このファイルは、モデルの設計図であり、重み、パラメータ、プロンプトテンプレートなどが指定されています。
```
FROM ./mistral-7b-v0.1.Q4_0.gguf
```
（オプション）多くのチャットモデルは、正しく回答するためにプロンプトテンプレートが必要です。`Modelfile` 内の `TEMPLATE` 指示でデフォルトのプロンプトテンプレートを指定できます:
```
FROM ./mistral-7b-v0.1.Q4_0.gguf
TEMPLATE "[INST] {{ .Prompt }} [/INST]"
```
### Step 2：Ollama モデルを作成します。
最後に、あなたの `Modelfile` からモデルを作成してください:
```
ollama create example -f Modelfile
```
### Step 3：モデルを実行します。
次に、`ollama run` でモデルをテストします。
```
ollama run example "あなたのお気に入りの調味料は何ですか？"
```
## インポート（PyTorch＆Safetensors）
> PyTorch および Safetensors からのインポートは、GGUF からのインポートよりも時間がかかります。これをより簡単にする改善策は進行中です。
### Step 1：セットアップ
まず、`ollama/ollama` リポジトリをクローンします：
```
git clone git@github.com:ollama/ollama.git ollama
cd ollama
```
次に、`llama.cpp` サブモジュールを取得します：
```shell
git submodule init
git submodule update llm/llama.cpp
```
次に、Python の依存関係をインストールします：
```
python3 -m venv llm/llama.cpp/.venv
source llm/llama.cpp/.venv/bin/activate
pip install -r llm/llama.cpp/requirements.txt
```
その後、 `quantize` ツールをビルドします：
```
make -C llm/llama.cpp quantize
```
### Step 2：HuggingFace リポジトリのクローン（オプション）
もしモデルが現在 HuggingFace リポジトリにホストされている場合、まずそのリポジトリをクローンして生のモデルをダウンロードしてください。
[Git LFS](https://docs.github.com/ja/repositories/working-with-files/managing-large-files/installing-git-large-file-storage) をインストールし、正常にインストールされていることを確認した後、モデルのリポジトリをクローンしてください。
```
git lfs install
git clone https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.1 model
```
### Step 3：モデルの変換
> 注：一部のモデルアーキテクチャでは、特定の変換スクリプトを使用する必要があります。たとえば、Qwen モデルの場合は、`convert.py`の代わりに `convert-hf-to-gguf.py` を実行する必要があります。
```
python llm/llama.cpp/convert.py ./model --outtype f16 --outfile converted.bin
```
### Step 4：モデルの量子化
```
llm/llama.cpp/quantize converted.bin quantized.bin q4_0
```
### Step 5: `Modelfile` の作成
次に、あなたのモデルに対する `Modelfile` を作成してください:
```
FROM quantized.bin
TEMPLATE "[INST] {{ .Prompt }} [/INST]"
```
### Step 6: Ollama モデルを作成します
最後に、`Modelfile` からモデルを作成します:
```
ollama create example -f Modelfile
```
### Step 7: モデルを実行する
次に、`ollama run` コマンドを使ってモデルをテストします:
```
ollama run example "What is your favourite condiment?"
```
## モデルの公開 (オプション – アーリーアルファ段階)
モデルの公開はアーリーアルファ段階にあります。他の人と共有するためにモデルを公開したい場合は、以下の手順に従ってください：
1. [アカウント](https://ollama.com/signup)を作成します。
2. Ollama の公開鍵をコピーします：
- macOS：`cat ~/.ollama/id_ed25519.pub`
- Windows：`type %USERPROFILE%\.ollama\id_ed25519.pub`
- Linux：`cat /usr/share/ollama/.ollama/id_ed25519.pub`
3. あなたの公開鍵を [Ollamaアカウント](https://ollama.com/settings/keys) に追加します。
次に、モデルをあなたのユーザー名の名前空間にコピーしてください:
```
ollama cp example <your username>/example
```
その後、モデルをプッシュしてください:
```
ollama push <your username>/example
```
公開後、あなたのモデルは `https://ollama.com/<あなたのユーザー名>/example` で利用可能になります。
## 量子化リファレンス
量子化オプションは以下の通りです（最高から最も低い量子化レベルまで）。注意：Falcon など一部のアーキテクチャは K quants をサポートしていません。
- `q2_K`
- `q3_K`
- `q3_K_S`
- `q3_K_M`
- `q3_K_L`
- `q4_0` (推奨)
- `q4_1`
- `q4_K`
- `q4_K_S`
- `q4_K_M`
- `q5_0`
- `q5_1`
- `q5_K`
- `q5_K_S`
- `q5_K_M`
- `q6_K`
- `q8_0`
- `f16`

128
docs/ja/linux.md Normal file
View File

@ -0,0 +1,128 @@
# Linux上のOllama
## インストール
Ollama をインストールするには、次のワンライナーを実行してください:
>
```bash
curl -fsSL https://ollama.com/install.sh | sh
```
## AMD Radeon GPU サポート
AMD は `amdgpu` ドライバーを公式の Linux カーネルソースにアップストリームで提供していますが、そのバージョンは古く、すべての ROCm 機能をサポートしていない可能性があります。Radeon GPU を最良にサポートするために、最新のドライバーを以下からインストールすることをお勧めします：[https://www.amd.com/en/support/linux-drivers](https://www.amd.com/en/support/linux-drivers)。
## 手動インストール
### `ollama` バイナリをダウンロードしてください
Ollama は自己完結型のバイナリとして配布されています。以下の手順で、ダウンロードして PATH に含まれるディレクトリに保存してください。
```bash
sudo curl -L https://ollama.com/download/ollama-linux-amd64 -o /usr/bin/ollama
sudo chmod +x /usr/bin/ollama
```
### Ollama を起動時サービスに追加する（推奨）
Ollama 用のユーザーを作成してください:
```bash
sudo useradd -r -s /bin/false -m -d /usr/share/ollama ollama
```
`/etc/systemd/system/ollama.service` にサービスファイルを作成してください:
```ini
[Unit]
Description=Ollama Service
After=network-online.target
[Service]
ExecStart=/usr/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
[Install]
WantedBy=default.target
```
次に、サービスを起動してください:
```bash
sudo systemctl daemon-reload
sudo systemctl enable ollama
```
### CUDA ドライバのインストール（オプション - Nvidia GPU 用）
[CUDA をダウンロードしてインストール](https://developer.nvidia.com/cuda-downloads) してください。
ドライバーがインストールされているか確認するために、以下のコマンドを実行してください。これにより、GPU に関する詳細が表示されるはずです:
```bash
nvidia-smi
```
### ROCm のインストール（オプション - Radeon GPU 用）
[ダウンロードしてインストール](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/tutorial/quick-start.html)
ROCm v6 をインストールしてください。
### Ollama を起動
`systemd` を使用して Ollama を起動します。
```bash
sudo systemctl start ollama
```
## アップデート
再びインストールスクリプトを実行して、Ollama をアップデートします:
```bash
curl -fsSL https://ollama.com/install.sh | sh
```
または、Ollama のバイナリをダウンロードすることもできます:
```bash
sudo curl -L https://ollama.com/download/ollama-linux-amd64 -o /usr/bin/ollama
sudo chmod +x /usr/bin/ollama
```
## ログの表示
Ollama が起動サービスとして実行されている際のログを表示するには、次のコマンドを実行してください:
```bash
journalctl -u ollama
```
## アンインストール
Ollama サービスを削除するには:
```bash
sudo systemctl stop ollama
sudo systemctl disable ollama
sudo rm /etc/systemd/system/ollama.service
```
Ollama バイナリを bin ディレクトリから削除してください（`/usr/local/bin`、`/usr/bin`、または `/bin` のいずれか）:
```bash
sudo rm $(which ollama)
```
ダウンロードしたモデルと Ollama サービスのユーザーおよびグループを削除してください：
```bash
sudo rm -r /usr/share/ollama
sudo userdel ollama
sudo groupdel ollama
```

220
docs/ja/modelfile.md Normal file
View File

@ -0,0 +1,220 @@
# Ollama Model File
> 注意: `Modelfile` の構文は開発中です
モデルファイルは、Ollama でモデルを作成し共有するための設計図です。
## 目次
- [フォーマット](#フォーマット)
- [例](#例)
- [手順](#手順)
- [FROM (必須)](#from-必須)
- [llama2 からビルド](#llama2-からビルド)
- [バイナリ ファイルからビルド](#バイナリ-ファイルからビルド)
- [PARAMETER](#パラメータ)
- [有効なパラメータと値](#有効なパラメータと値)
- [TEMPLATE](#テンプレート)
- [テンプレート変数](#テンプレート変数)
- [SYSTEM](#システム)
- [ADAPTER](#アダプタ)
- [LICENSE](#ライセンス)
- [MESSAGE](#メッセージ)
- [ノート](#ノート)
## フォーマット
`Modelfile` のフォーマット:
```modelfile
# comment
指示 引数
```
| 指示 | 説明 |
| ----------------------------------- | -------------------------------------------------------------- |
| [`FROM`](#from-必須) (必須) | ベースとするモデルを定義します。 |
| [`PARAMETER`](#パラメータ) | Ollama がモデルを実行する方法のパラメータを設定します。 |
| [`TEMPLATE`](#テンプレート) | モデルに 送信される完全なプロンプトテンプレート。 |
| [`SYSTEM`](#システム) | テンプレートに設定されるシステムメッセージを指定します。 |
| [`ADAPTER`](#アダプタ) | モデルに適用する (Q)LoRA アダプタを定義します。 |
| [`LICENSE`](#ライセンス) | 法的なライセンスを指定します。 |
| [`MESSAGE`](#メッセージ) | メッセージの履歴を指定します。 |
## 例
### Basic `Modelfile`
`Modelfile` でマリオのブループリントを作成する例:
```modelfile
FROM llama2
# 温度を1に設定します [高いほど創造的、低いほど一貫性があります]
PARAMETER temperature 1
# コンテキストウィンドウサイズを 4096 に設定します。これは、LLMが次のトークンを生成するためのコンテキストとして使用できるトークンの数を制御します。
PARAMETER num_ctx 4096
# チャットアシスタントの挙動を指定するためのカスタムシステムメッセージを設定します。
SYSTEM You are Mario from super mario bros, acting as an assistant.
```
To use this:
1. それをファイル（例: `Modelfile`）として保存してください。
2. `ollama create choose-a-model-name -f <ファイルの場所、例: ./Modelfile>'`
3. `ollama run choose-a-model-name`
4. モデルの使用を開始してください！
より多くの例は [examples ディレクトリ](../../examples) にあります。
### `Modelfile`s in [ollama.com/library][1]
[ollama.com/library][1] で提供されているモデルのベースとなっている `Modelfile` を見る方法は2つあります。
- オプション1：モデルのタグページから詳細ページを表示：
1. 特定のモデルのタグページに移動します（例：https://ollama.com/library/llama2/tags）
2. タグをクリックします（例：https://ollama.com/library/llama2:13b）
3. "Layers" までスクロールします
- 注意：[`FROM` 指示](#from-必須)が存在しない場合、
それはモデルがローカルファイルから作成されたことを意味します。
- オプション2：`ollama show` を使用して、次のようにローカルモデルの `Modelfile` を表示します：
```bash
> ollama show --modelfile llama2:13b
# "ollama show" によって生成された Modelfile
# 新しい Modelfile をこのものを基に作成するには、FROM行を次のように置き換えます：
# FROM llama2:13b
FROM /root/.ollama/models/blobs/sha256:123abc
TEMPLATE """[INST] {{ if .System }}<<SYS>>{{ .System }}<</SYS>>
{{ end }}{{ .Prompt }} [/INST] """
SYSTEM """"""
PARAMETER stop [INST]
PARAMETER stop [/INST]
PARAMETER stop <<SYS>>
PARAMETER stop <</SYS>>
```
## 手順
### FROM (必須)
`FROM` 指示は、モデルを作成する際に使用する基本モデルを定義します。
```modelfile
FROM <model name>:<tag>
```
#### llama2 からビルド
```modelfile
FROM llama2
```
利用可能なベースモデルの一覧:
<https://github.com/jmorganca/ollama#model-library>
#### `バイナリ` ファイルからビルド
```modelfile
FROM ./ollama-model.bin
```
この bin ファイルの場所は、絶対パスまたは `Modelfile` の場所からの相対パスとして指定する必要があります。
### パラメータ
`PARAMETER` 命令は、モデルの実行時に設定できるパラメータを定義します。
```modelfile
PARAMETER <parameter> <parametervalue>
```
### 有効なパラメータと値
| パラメータ | 説明 | 値のタイプ | 使用例 |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- | -------------------- |
| mirostat | Perplexity を制御するために Mirostat サンプリングを有効にします。（デフォルト：0、0 = 無効、1 = Mirostat、2 = Mirostat 2.0） | int | mirostat 0 |
| mirostat_eta | アルゴリズムが生成されたテキストのフィードバックにどれくらい速く反応するかに影響を与えます。学習率が低いと調整が遅くなり、高い学習率はアルゴリズムをより敏感にします。（デフォルト：0.1） | float | mirostat_eta 0.1 |
| mirostat_tau | 出力の一貫性と多様性のバランスを制御します。低い値では、より焦点を当て、一貫したテキストが生成されます。（デフォルト：5.0） | float | mirostat_tau 5.0 |
| num_ctx | 次のトークンを生成するために使用されるコンテキストウィンドウのサイズを設定します。（デフォルト：2048） | int | num_ctx 4096 |
| num_gqa | トランスフォーマーレイヤー内の GQA（Grouped Quantized Attention） グループの数。一部のモデルでは必須です。例えば、llama2:70b の場合、これは8です。 | int | num_gqa 1 |
| num_gpu | GPU に送信するレイヤーの数。macOS では、Metal サポートを有効にするためにデフォルトで 1に設定され、無効にする場合は 0になります。 | int | num_gpu 50 |
| num_thread | 計算中に使用するスレッドの数を設定します。デフォルトでは、Ollama はこれを最適なパフォーマンスのために検出します。お使いのシステムが持つ物理的な CPU コアの数にこの値を設定することが推奨されています（論理的なコアの数ではなく）。 | int | num_thread 8 |
| repeat_last_n | モデルが繰り返しを防ぐために遡る範囲を設定します。 (デフォルト: 64、0 = 無効、-1 = num_ctx) | int | repeat_last_n 64 |
| repeat_penalty | 繰り返しをどれだけ厳しく罰するかを設定します。より高い値（例: 1.5）は、繰り返しをより強く罰しますが、より低い値（例: 0.9）は寛大になります。 (デフォルト: 1.1) | float | repeat_penalty 1.1 |
| temperature | モデルの温度。温度を上げると、モデルの回答がより創造的になります。 (デフォルト: 0.8) | float | temperature 0.7 |
| seed | 生成に使用する乱数シードを設定します。これを特定の数値に設定すると、同じプロンプトに対してモデルが同じテキストを生成します。 (デフォルト: 0) | int | seed 42 |
| stop | 停止シーケンスを設定します。このパターンが検出されると、LLM はテキスト生成を停止して返します。複数の停止パターンを設定するには、モデルファイルで複数の別々の `stop` パラメータを指定します。 | string | stop "AI assistant:" |
| tfs_z | テイルフリーサンプリング (Tail free sampling) は、出力の確率が低いトークンの影響を軽減するために使用されます。より高い値（例：2.0）は、影響をより軽減しますが、1.0の値はこの設定を無効にします。 （デフォルト：1） | float | tfs_z 1 |
| num_predict | テキスト生成時に予測するトークンの最大数。 （デフォルト：128、-1 = 無限生成、-2 = コンテキストを埋める） | int | num_predict 42 |
| top_k | ナンセンスを生成する確率を低減させます。 より高い値（例：100）はより多様な回答を提供し、より低い値（例：10）はより保守的になります。 （デフォルト：40） | int | top_k 40 |
| top_p | top-k と連動します。より高い値（例：0.95）はより多様なテキストを生成し、より低い値（例：0.5）はより焦点を絞り込み、保守的なテキストを生成します。 （デフォルト：0.9） | float | top_p 0.9 |
### テンプレート
`TEMPLATE` は、モデルに渡される完全なプロンプトテンプレートです。これには（オプションで）システムメッセージ、ユーザーのメッセージ、およびモデルからのレスポンスが含まれる場合があります。注：構文はモデルに固有のものです。テンプレートは Go の[テンプレート構文](https://pkg.go.dev/text/template)を使用します。
#### テンプレート変数
| 変数 | 説明 |
| ----------------- | -------------------------------------------------------------------------------------- |
| `{{ .System }}` | カスタム動作を指定するために使用されるシステムメッセージ。 |
| `{{ .Prompt }}` | ユーザープロンプトメッセージ。 |
| `{{ .Response }}` | モデルからのレスポンス。レスポンスを生成する場合、この変数以降のテキストは省略されます。 |
```
TEMPLATE """{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Prompt }}<|im_start|>user
{{ .Prompt }}<|im_end|>
{{ end }}<|im_start|>assistant
"""
```
### システム
`SYSTEM` 命令は、テンプレートで使用されるシステムメッセージを指定します。必要に応じて。
```modelfile
SYSTEM """<system message>"""
```
### アダプタ
`ADAPTER` 命令は、ベースモデルに適用する LoRA アダプタを指定します。この命令の値は、Modelfile からの相対パスまたは絶対パスである必要があり、ファイルは GGML ファイル形式である必要があります。アダプタはベースモデルから調整されている必要があります。それ以外の場合、動作は未定義です。
```modelfile
ADAPTER ./ollama-lora.bin
```
### ライセンス
`LICENSE` 命令は、この Modelfile で使用されるモデルが共有または配布される際の法的なライセンスを指定するためのものです。
```modelfile
LICENSE """
<license text>
"""
```
### メッセージ
`MESSAGE` 命令は、モデルが応答する際に使用するメッセージの履歴を指定するためのものです:
```modelfile
MESSAGE user Is Toronto in Canada?
MESSAGE assistant yes
MESSAGE user Is Sacramento in Canada?
MESSAGE assistant no
MESSAGE user Is Ontario in Canada?
MESSAGE assistant yes
```
## ノート
- **`Modelfile`は大文字と小文字を区別しません**。例では、大文字の命令を使用していますが、これは引数と区別しやすくするためです。
- 命令は任意の順序で指定できます。例では、`FROM` 命令を最初に配置して読みやすさを保っています。
[1]: https://ollama.com/library

141
docs/ja/openai.md Normal file
View File

@ -0,0 +1,141 @@
# OpenAI の互換性
> **注意:** OpenAI の互換性は実験的であり、大規模な変更や互換性のない変更が加えられる可能性があります。Ollama API のすべての機能を使用するには、Ollama の[Python ライブラリ](https://github.com/ollama/ollama-python)、[JavaScript ライブラリ](https://github.com/ollama/ollama-js)、および [REST API](https://github.com/jmorganca/ollama/blob/main/docs/api.md) を参照してください。
Ollama は、既存のアプリケーションを Ollama に接続するのに役立つよう、[OpenAI API](https://platform.openai.com/docs/api-reference) の一部との実験的な互換性を提供します。
## 使用法
### OpenAI Python ライブラリ
```python
from openai import OpenAI
client = OpenAI(
base_url='http://localhost:11434/v1/',
# 必須ですが無視されます
api_key='ollama',
)
chat_completion = client.chat.completions.create(
messages=[
{
'role': 'user',
'content': 'これはテストですと言う',
}
],
model='llama2',
)
```
### OpenAI JavaScript ライブラリ
```javascript
import OpenAI from 'openai'
const openai = new OpenAI({
baseURL: 'http://localhost:11434/v1/',
// 必須ですが無視されます
apiKey: 'ollama',
})
const chatCompletion = await openai.chat.completions.create({
messages: [{ role: 'user', content: 'これはテストですと言う' }],
model: 'llama2',
})
```
### `curl`
```
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "llama2",
"messages": [
{
"role": "system",
"content": "あなたは役に立つアシスタントです。"
},
{
"role": "user",
"content": "こんにちは！"
}
]
}'
```
## エンドポイント
### `/v1/chat/completions`
#### サポートされている機能
- [x] チャット補完
- [x] ストリーミング
- [x] JSON モード
- [x] 再現可能な出力
- [ ] ビジョン
- [ ] 関数の呼び出し
- [ ] ログプロブ
#### サポートされているリクエストフィールド
- [x] `model`
- [x] `messages`
- [x] テキスト `content`
- [ ] `content` の部分の配列
- [x] `frequency_penalty`
- [x] `presence_penalty`
- [x] `response_format`
- [x] `seed`
- [x] `stop`
- [x] `stream`
- [x] `temperature`
- [x] `top_p`
- [x] `max_tokens`
- [ ] `logit_bias`
- [ ] `tools`
- [ ] `tool_choice`
- [ ] `user`
- [ ] `n`
#### 注意事項
- `seed` を設定すると、常に `temperature` が `0` に設定されます。
- `finish_reason` は常に `stop` になります。
- プロンプト評価がキャッシュされている補完では、`usage.prompt_tokens` は `0` になります。
## モデル
モデルを使用する前に、ローカルにプルしてください `ollama pull`：
```shell
ollama pull llama2
```
### デフォルトのモデル名
`gpt-3.5-turbo` などのデフォルトの OpenAI モデル名を使用するツールについては、既存のモデル名を一時的な名前にコピーするには `ollama cp` を使用してください：
```
ollama cp llama2 gpt-3.5-turbo
```
その後、この新しいモデル名を `model` フィールドで指定できます：
```shell
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-3.5-turbo",
"messages": [
{
"role": "user",
"content": "こんにちは！"
}
]
}'
```

93
docs/ja/troubleshooting.md Normal file
View File

@ -0,0 +1,93 @@
# 問題のトラブルシューティング方法
時々、Ollama が期待通りに機能しないことがあります。何が起こったのかを把握する最良の方法の 1つは、ログを確認することです。**Mac** でログを見つけるには、次のコマンドを実行します：
```shell
cat ~/.ollama/logs/server.log
```
`systemd` を使用している **Linux** システムでは、次のコマンドでログを見つけることができます:
```shell
journalctl -u ollama
```
Ollama を **コンテナ** で実行する場合、ログはコンテナ内の stdout/stderr に送られます:
```shell
docker logs <container-name>
```
（`docker ps` を使用してコンテナ名を見つけてください）
ターミナルで `ollama serve` を手動で実行する場合、ログはそのターミナル上に表示されます。
**Windows** 上で Ollama を実行する場合、いくつかの異なる場所があります。エクスプローラウィンドウでそれらを表示するには、`<cmd>+R` を押して次のコマンドを入力します：
- `explorer %LOCALAPPDATA%\Ollama`：ログを表示します
- `explorer %LOCALAPPDATA%\Programs\Ollama`：バイナリを参照します（インストーラーはこれをユーザーの PATH に追加します）
- `explorer %HOMEPATH%\.ollama`：モデルと設定が保存されている場所を表示します
- `explorer %TEMP%`：一時的な実行ファイルが 1つ以上の `ollama*` ディレクトリに保存されている場所を表示します
問題のトラブルシューティングを支援するために追加のデバッグログを有効にするには、まず **トレイメニューからアプリを終了** し、次に PowerShell ターミナルで次のコマンドを実行します：
```powershell
$env:OLLAMA_DEBUG="1"
& "ollama app.exe"
```
ログの解釈に関するヘルプは [Discord](https://discord.gg/ollama) に参加してください。
## LLM ライブラリ
Ollama には、異なる GPU と CPU ベクトル機能向けにコンパイルされた複数の LLM ライブラリが含まれています。Ollama は、システムの機能に基づいて最適なものを選択しようとします。この自動検出に問題があるか、他の問題（例：GPU のクラッシュ）に遭遇した場合は、特定の LLM ライブラリを強制的に指定することで回避できます。`cpu_avx2` が最も優れており、次に `cpu_avx`、最も互換性があるが最も遅いのが `cpu` です。MacOS の Rosetta エミュレーションは `cpu` ライブラリと動作します。
サーバーログには、次のようなメッセージが表示されます（リリースによって異なります）:
```
Dynamic LLM libraries [rocm_v6 cpu cpu_avx cpu_avx2 cuda_v11 rocm_v5]
```
**実験的 LLM ライブラリのオーバーライド**
OLLAMA_LLM_LIBRARY を利用可能な LLM ライブラリのいずれかに設定すると、自動検出をバイパスできます。たとえば、CUDA カードがあるが AVX2 ベクトルサポートを持つ CPU LLM ライブラリを強制的に使用したい場合は、次のようにします:
```
OLLAMA_LLM_LIBRARY="cpu_avx2" ollama serve
```
あなたの CPU がどの機能を持っているかは、以下の方法で確認できます。
```
cat /proc/cpuinfo| grep flags | head -1
```
## AMD Radeon GPU サポート
Ollama は AMD ROCm ライブラリを利用しており、すべての AMD GPU をサポートしているわけではありません。一部の場合、類似した LLVM ターゲットを試すようにシステムに強制することができます。たとえば、Radeon RX 5400 は `gfx1034`（別名 10.3.4）ですが、ROCm は現在、このターゲットをサポートしていません。最も近いサポートは `gfx1030` です。環境変数 `HSA_OVERRIDE_GFX_VERSION` を `x.y.z` の構文で使用できます。たとえば、システムを RX 5400 で実行するように強制するには、サーバー用の環境変数として `HSA_OVERRIDE_GFX_VERSION="10.3.0"` を設定します。サポートされていない AMD GPU がある場合は、以下のサポートされているタイプのリストを使用して実験できます。
現時点では、以下の LLVM ターゲットが既知のサポートされている GPU タイプです。この表には、これらのLLVM ターゲットにマップされるいくつかの例の GPU が示されています：
| **LLVMターゲット** | **例のGPU** |
|-----------------|---------------------|
| gfx900 | Radeon RX Vega 56 |
| gfx906 | Radeon Instinct MI50 |
| gfx908 | Radeon Instinct MI100 |
| gfx90a | Radeon Instinct MI210 |
| gfx940 | Radeon Instinct MI300 |
| gfx941 | |
| gfx942 | |
| gfx1030 | Radeon PRO V620 |
| gfx1100 | Radeon PRO W7900 |
| gfx1101 | Radeon PRO W7700 |
| gfx1102 | Radeon RX 7600 |
AMD は、将来のリリースで ROCm v6 を拡張し、さらに多くの GPU をサポートする予定です。
追加のサポートが必要な場合は、[Discord](https://discord.gg/ollama) に連絡するか、[問題](https://github.com/ollama/ollama/issues)を報告してください。
## Linux での古いバージョンのインストール
Linux で問題が発生し、古いバージョンをインストールしたい場合は、インストールスクリプトにインストールするバージョンを指定できます。
```sh
curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION="0.1.27" sh
```

9
docs/ja/tutorials.md Normal file
View File

@ -0,0 +1,9 @@
# チュートリアル
以下は、Ollama を他のツールと組み合わせて興味深いアプリケーションを構築する方法のリストです。
- [JavaScriptでLangChainをOllamaと使用する方法](./tutorials/langchainjs.md)
- [PythonでLangChainをOllamaと使用する方法](./tutorials/langchainpy.md)
- [NVIDIA JetsonデバイスでOllamaを実行する方法](./tutorials/nvidia-jetson.md)
また、Ollamaのさらなる利用方法については、[examples](../../examples) ディレクトリも確認してください。

79
docs/ja/tutorials/fly-gpu.md Normal file
View File

@ -0,0 +1,79 @@
# Running Ollama on Fly.io GPU Instances
Ollama は、[Fly.io GPUインスタンス](https://fly.io/docs/gpus/gpu-quickstart/)上でほとんどまたはまったく設定なしで実行できます。まだ GPU へのアクセス権がない場合は、[アクセスを申請](https://fly.io/gpu/)してウェイトリストに登録する必要があります。承認されると、開始手順が記載されたメールが届きます。
新しいアプリを作成するには、`fly apps create` を使用します:
```bash
fly apps create
```
次に、次のような新しいフォルダに `fly.toml` ファイルを作成してください。
```toml
app = "sparkling-violet-709"
primary_region = "ord"
vm.size = "a100-40gb" # see https://fly.io/docs/gpus/gpu-quickstart/ for more info
[build]
image = "ollama/ollama"
[http_service]
internal_port = 11434
force_https = false
auto_stop_machines = true
auto_start_machines = true
min_machines_running = 0
processes = ["app"]
[mounts]
source = "models"
destination = "/root/.ollama"
initial_size = "100gb"
```
次に、アプリケーション用に [新しいプライベートIPv6アドレス](https://fly.io/docs/reference/private-networking/#flycast-private-load-balancing) を作成してください:
```bash
fly ips allocate-v6 --private
```
その後、アプリケーションをデプロイしてください：
```bash
fly deploy
```
そして最後に、新しいFly.ioマシンを使用して対話的にアクセスできます：
```
fly machine run -e OLLAMA_HOST=http://your-app-name.flycast --shell ollama/ollama
```
```bash
$ ollama run openchat:7b-v3.5-fp16
>>> チョコレートチップクッキーの焼き方
チョコレートチップクッキーを焼くために、以下の手順に従ってください：
1. オーブンを375°F（190°C）に予熱し、天板にはパーチメントペーパーまたはシリコン製のベーキングマットを敷きます。
2. 大きなボウルで、1カップの無塩バター（室温に戻したもの）、3/4カップの砂糖、3/4カップのパッキングされた黒糖を軽く混ぜ合わせ、ふんわりするまで混ぜます。
3. バターの混合物に大きな卵2個を1つずつ加え、各添加後によく混ぜます。1ティースプーンの純粋なバニラエクストラクトを加えて混ぜます。
4. 別のボウルで、2カップのオールパーパス小麦粉、1/2ティースプーンのベーキングソーダ、1/2ティースプーンの塩を混ぜます。ドライな成分を湿った成分に徐々に加え、ちょうど組み合わせるまでかき混ぜます。
5. 生地に2カップのチョコレートチップ（またはチャンク）を折り込みます。
6. 準備したベーキングシートに、丸くて大さじ1杯の生地を約2インチの間隔で並べます。
7. 10〜12分、または端が金褐色になるまで焼きます。中心部は少し柔らかい状態であるべきです。
8. クッキーを焼きたてのうちに、数分間ベーキングシートの上で冷ます後、ワイヤーラックに移して完全に冷やします。
自家製のチョコレートチップクッキーをお楽しみください！
```
これをこのように設定すると、使用が終わると自動的にオフになります。その後、再度アクセスすると、自動的にオンになります。これは、使用していないときに GPU インスタンスの費用を節約する素晴らしい方法です。Ollama インスタンスに対する永続的なウェイクオンユース接続が必要な場合は、[WireGuardを使用したFlyネットワークへの接続を設定](https://fly.io/docs/reference/private-networking/#discovering-apps-through-dns-on-a-wireguard-connection)できます。その後、Ollama インスタンスには `http://your-app-name.flycast` でアクセスできます。
以上で完了です！

76
docs/ja/tutorials/langchainjs.md Normal file
View File

@ -0,0 +1,76 @@
# Using LangChain with Ollama using JavaScript
このチュートリアルでは、LangChain と Ollama を使用して JavaScript を学び、少し新しい情報を得ることを目指します。2023年8月にマウイで発生した一連の山火事について学びます。その時点より前にトレーニングされたLLMは、トレーニングデータにそれよりも新しい情報が含まれていないため、これについて知ることはできません。したがって、[山火事に関するWikipediaの記事](https://en.wikipedia.org/wiki/2023_Hawaii_wildfires)を見つけ、その内容について質問してみましょう。
始めるために、単純な質問をモデルに尋ねるために **LangChain** を使ってみましょう。これを JavaScript で行うためには、**LangChain** をインストールする必要があります：
さて、JavaScript を構築し始めることができます：
```javascript
import { Ollama } from "langchain/llms/ollama";
const ollama = new Ollama({
baseUrl: "http://localhost:11434",
model: "llama2",
});
const answer = await ollama.call(`why is the sky blue?`);
console.log(answer);
```
これにより、ターミナルで `ollama run llama2 "why is the sky blue"` を実行したのと同じ結果が得られます。ただし、質問を尋ねるためにウェブからドキュメントを読み込みたいです。**Cheerio** はウェブページを取り込むための優れたライブラリで、**LangChain** では **CheerioWebBaseLoader** で使用されています。そのため、**Cheerio** をインストールしてアプリのその部分を構築しましょう。
```bash
npm install cheerio
```
```javascript
import { CheerioWebBaseLoader } from "langchain/document_loaders/web/cheerio";
const loader = new CheerioWebBaseLoader("https://en.wikipedia.org/wiki/2023_Hawaii_wildfires");
const data = await loader.load();
```
それにより、ドキュメントが読み込まれます。このページは「オデュッセイア」よりは小さいですが、ほとんどのLLMのコンテキストサイズよりも大きいです。したがって、より小さな部分に分割し、質問に関連する部分だけを選択する必要があります。これにはベクトルデータストアが非常に役立ちます。この例では、**LangChain** の一部である **MemoryVectorStore** を使用します。ただし、データストアにコンテンツを取り込むためにはもう1つ必要なものがあります。テキスト内のトークンをベクトルの系列に変換する埋め込みプロセスを実行する必要があります。そしてそのために、**Tensorflow** を使用します。これにはいくつかのステップが含まれています。まず、必要な **Tensorflow** コンポーネントをインストールします。
```javascript
npm install @tensorflow/tfjs-core@3.6.0 @tensorflow/tfjs-converter@3.6.0 @tensorflow-models/universal-sentence-encoder@1.3.3 @tensorflow/tfjs-node@4.10.0
```
もしバージョン番号なしでこれらのコンポーネントをインストールすると、最新バージョンがインストールされますが、**Tensorflow** 内での競合があるため、互換性のあるバージョンをインストールする必要があります。
```javascript
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter"
import { MemoryVectorStore } from "langchain/vectorstores/memory";
import "@tensorflow/tfjs-node";
import { TensorFlowEmbeddings } from "langchain/embeddings/tensorflow";
// テキストを500文字のチャンクに分割し、各チャンクを20文字ずつオーバーラップさせます。
const textSplitter = new RecursiveCharacterTextSplitter({
chunkSize: 500,
chunkOverlap: 20
});
const splitDocs = await textSplitter.splitDocuments(data);
// 次に、TensorFlowの埋め込みを使用してこれらのチャンクをデータストアに格納します。
const vectorStore = await MemoryVectorStore.fromDocuments(splitDocs, new TensorFlowEmbeddings());
```
データストアをLLMに対する質問に接続するには、**LangChain** の中心にある概念を使用する必要があります。それが「チェーン」です。チェーンは、特定のタスクを達成するために複数の活動を結びつける方法です。いくつかの種類のチェーンが利用可能ですが、このチュートリアルでは **RetrievalQAChain** を使用します。
```javascript
import { RetrievalQAChain } from "langchain/chains";
const retriever = vectorStore.asRetriever();
const chain = RetrievalQAChain.fromLLM(ollama, retriever);
const result = await chain.call({query: "ハワイの大規模災害宣言の要請はいつ承認されましたか？"});
console.log(result.text)
```
したがって、リトリーバーを作成しました。これはデータストアからクエリに一致するチャンクを返す方法です。そして、その後、リトリーバーとモデルをチェーンを介して接続します。最後に、チェーンにクエリを送信し、文書をソースとして回答を得ます。返された回答は正確で、2023年8月10日でした。
これで、**LangChain** と **Ollama** で何ができるかの簡単な紹介が完了しました。

83
docs/ja/tutorials/langchainpy.md Normal file
View File

@ -0,0 +1,83 @@
# Using LangChain with Ollama in Python
さて、私たちが古典文学、例えば **ホメロス** の **『オデュッセイア』** を勉強していると想像しましょう。ネレウスとその家族に関する質問があるかもしれません。その情報を尋ねるために llama2 に質問すると、次のような情報が得られるかもしれません:
> 申し訳ありませんが、私は大規模な言語モデルであり、現実に存在しない個人や家族に関する情報は提供できません。ネレウスは実在の人物やキャラクターではなく、そのため家族や他の個人的な詳細はありません。混乱を招いた場合は申し訳ありません。他にお手伝いできることはありますか？
これは典型的な検閲された回答のようですが、llama2-uncensored でもまずまずの回答が得られます:
> ネレウスはピュロスの伝説的な王であり、アルゴナウタイの一人であるネストールの父でした。彼の母は海のニンフ、クリュメネで、父は海の神ネプチューンでした。
それでは、**LangChain** を Ollama と連携させ、Python を使用して実際の文書、ホメロスの『オデュッセイア』に質問する方法を考えてみましょう。
まず、**Ollama** を使用して **Llama2** モデルから回答を取得できる簡単な質問をしてみましょう。まず、**LangChain** パッケージをインストールする必要があります：
`pip install langchain`
それからモデルを作成し、質問をすることができます：
```python
from langchain.llms import Ollama
ollama = Ollama(base_url='http://localhost:11434',
model="llama2")
print(ollama("なぜ空は青いのか"))
```
モデルと Ollama の基本 URL を定義していることに注意してください。
さて、質問を行うためのドキュメントをロードしてみましょう。私はホメロスの『オデュッセイア』を読み込みますが、これは Project Gutenberg で見つけることができます。**LangChain** の一部である**WebBaseLoader** が必要です。また、私のマシンではこれを動作させるために **bs4** もインストールする必要がありました。したがって、`pip install bs4`を実行してください。
```python
from langchain.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://www.gutenberg.org/files/1727/1727-h/1727-h.htm")
data = loader.load()
```
このファイルはかなり大きいです。序文だけで3000トークンあります。つまり、完全なドキュメントはモデルのコンテキストに収まりません。したがって、それをより小さな部分に分割する必要があります。
```python
from langchain.text_splitter import RecursiveCharacterTextSplitter
text_splitter=RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
all_splits = text_splitter.split_documents(data)
```
分割されていますが、関連する分割を見つけて、それらをモデルに送信する必要があります。これを行うには、埋め込みを作成してそれらをベクトルデータベースに保存します。この例では、ベクトルデータベースとして ChromaDB を使用します。埋め込みモデルをインスタンス化するために、Ollama を直接使用できます。`pip install chromadb`
```python
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma
oembed = OllamaEmbeddings(base_url="http://localhost:11434", model="nomic-embed-text")
vectorstore = Chroma.from_documents(documents=all_splits, embedding=oembed)
```
それでは、ドキュメントから質問をしてみましょう。**ネレウスは誰で、彼の家族には誰がいますか？** ネレウスはオデュッセイアの登場人物で、答えはテキスト内にあります。
```python
question="ネレウスは誰で、ネレウスの家族には誰がいますか？"
docs = vectorstore.similarity_search(question)
len(docs)
```
これにより、検索に類似したデータのマッチング数が出力されます。
次に、質問と文書の関連部分をモデルに送信して適切な回答を得ることができるかどうかを確認することです。ただし、プロセスの2つの部分を結合しているため、これを「チェーン」と呼びます。これはチェーンを定義する必要があることを意味します：
```python
from langchain.chains import RetrievalQA
qachain=RetrievalQA.from_chain_type(ollama, retriever=vectorstore.as_retriever())
qachain.invoke({"query": question})
```
このチェーンから受け取った回答は以下の通りです：
> ネレウスはホメロスの「オデュッセイア」に登場するキャラクターで、ペネロペの求婚者たちの文脈で言及されています。ネレウスはクロリスの父であり、クロリスはネレウスと結婚し、ネストル、クロミオス、ペリクリュメノス、およびペロを含む複数の子供をもうけました。また、ニーソスの息子であるアンフィノムスもペネロペの求婚者として言及されており、その優れた性格と愉快な会話で知られています。
これは完璧な回答ではありません。なぜなら、実際にはクロリスは「イアソスの息子でミューニュオン・オルコメノスの王であるアンフィオンの末娘であり、ピュロスの女王でした」。
テキスト分割のための chunk_overlap を 20 に更新して再試行しました。すると、はるかに良い回答が得られました：
> ネレウスはホメロスの叙事詩「オデュッセイア」に登場するキャラクターです。彼はイアソスの息子でミューニュオン・オルコメノスの王であるアンフィオンの末娘であるクロリスと結婚しています。ネレウスはクロリスとの間に、ネストル、クロミオス、ペリクリュメノス、およびペロを含む複数の子供がいます。
これがはるかに良い回答です。

36
docs/ja/tutorials/nvidia-jetson.md Normal file
View File

@ -0,0 +1,36 @@
# Running Ollama on NVIDIA Jetson Devices
いくつかの細かい設定で、Ollama は [NVIDIA Jetsonデバイス](https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/)でうまく動作します。以下は [JetPack 5.1.2](https://developer.nvidia.com/embedded/jetpack) でのテストが行われました。
NVIDIA Jetson デバイスは、AIアプリケーション向けに特別に設計されたLinuxベースの組み込み型AIコンピュータです。
Jetson にはメモリコントローラに直接接続された統合 GPU があります。このため、`nvidia-smi` コマンドは認識されず、Ollama は「CPUのみ」モードで動作します。これは、jtop などのモニタリングツールを使用して確認できます。
これを解決するために、Jetson の事前インストールされた CUDA ライブラリのパスを単純に `ollama serve` に渡します（tmuxセッション内で）。そして、ターゲットモデルのクローンに `num_gpu` パラメータをハードコードします。
事前に必要:
- curl
- tmux
以下は手順です：
- 標準の Linux コマンドを使用して Ollama をインストールします（404 エラーは無視してください）：`curl https://ollama.com/install.sh | sh`
- Ollama サービスを停止します：`sudo systemctl stop ollama`
- `tmux`セッションで Ollama serve を起動します。これを`ollama_jetson`という tmux セッションとして開始し、CUDA ライブラリのパスを参照します：`tmux has-session -t ollama_jetson 2>/dev/null || tmux new-session -d -s ollama_jetson 'LD_LIBRARY_PATH=/usr/local/cuda/lib64 ollama serve'`
- 使用したいモデル（例：mistral ）を取得します：`ollama pull mistral`
- Jetson で GPU サポートを有効にするための新しい Modelfile を作成します：`touch ModelfileMistralJetson`
- ModelfileMistralJetson ファイルで、以下に示すように FROM モデルと num_gpu PARAMETER を指定します：
```
FROM mistral
PARAMETER num_gpu 999
```
- Modelfile から新しいモデルを作成します：`ollama create mistral-jetson -f ./ModelfileMistralJetson`
- 新しいモデルを実行します：`ollama run mistral-jetson`
jtop などのモニタリングツールを実行すると、Ollama が Jetson の統合 GPU を使用していることが確認できるはずです。
以上で完了です！

38
docs/ja/windows.md Normal file
View File

@ -0,0 +1,38 @@
# Ollama Windows プレビュー
Ollama Windows プレビューへようこそ。
WSL はもう必要ありません！
Ollama は今やネイティブの Windows アプリケーションとして動作し、NVIDIA および AMD Radeon GPU をサポートしています。
Ollama Windows Preview をインストールした後、Ollama はバックグラウンドで実行され、
`cmd`、`powershell`、またはお気に入りのターミナルアプリケーションで `ollama` コマンドラインが利用可能になります。通常どおり、Ollamaの [API](./api.md) は `http://localhost:11434` で提供されます。
これはプレビューリリースなので、そこかしこにいくつかのバグがあることを予想してください。問題が発生した場合は、[Discord](https://discord.gg/ollama) で連絡するか、[issue](https://github.com/ollama/ollama/issues) を報告してください。
問題を診断するのにログはしばしば役立ちます（以下の [トラブルシューティング](#トラブルシューティング) を参照）。
## システム要件
* Windows 10 以降、Home または Pro
* NVIDIA カードをお持ちの場合は、NVIDIA 452.39 またはそれ以降のドライバ
* Radeon カードをお持ちの場合は、AMD Radeon ドライバ [こちら](https://www.amd.com/en/support) からダウンロード
## API アクセス
こちらは `powershell` からの API アクセスのクイックな例です。
```powershell
(Invoke-WebRequest -method POST -Body '{"model":"llama2", "prompt":"Why is the sky blue?", "stream": false}' -uri http://localhost:11434/api/generate ).Content | ConvertFrom-json
```
## トラブルシューティング
プレビュー中は、常に `OLLAMA_DEBUG` が有効になっています。これにより、アプリケーションのメニューに "view logs" メニューアイテムが追加され、GUI アプリケーションおよびサーバーのログが増えます。
Windows上 の Ollama はいくつかの異なる場所にファイルを保存します。エクスプローラーウィンドウでこれらを表示するには、`<cmd>+R` を押して次のように入力します：
- `%LOCALAPPDATA%\Ollama` には、ログとダウンロードされたアップデートが含まれます
- *app.log* には、GUI アプリケーションのログが含まれます
- *server.log* には、サーバーのログが含まれます
- *upgrade.log* には、アップグレードのログ出力が含まれます
- `%LOCALAPPDATA%\Programs\Ollama` には、バイナリが含まれます（インストーラーはこれをユーザーの PATH に追加します）
- `%HOMEPATH%\.ollama` には、モデルと構成が含まれます
- `%TEMP%` には、1つ以上の `ollama*` ディレクトリに一時的な実行ファイルが含まれます