正規表現

正規表現の情報は、ネット上に豊富にあると思うので、詳細は検索してみてください。
下記は「正規表現」の説明をAIに聞いてみた回答です

概要

本チャットログでは、「正規表現（Regular Expression）」の基本要素について、最小限かつ代表的な機能に絞って説明している。主な用途は文字列の検索・置換・抽出であり、「文字列パターンを表現する小さな言語」として位置付けている。

1. 文字列とリテラル

• abc
  • 文字列「abc」にそのままマッチするパターン。

2. メタ文字（特別な意味を持つ記号）

• . : 任意の1文字
• ^ : 行頭
• $ : 行末
• * : 直前要素の0回以上の繰り返し
• + : 直前要素の1回以上の繰り返し
• ? : 直前要素の0回または1回
• | : OR（または）
• () : グループ化・キャプチャ

具体例

• a.*b
  • 「a」で始まり「b」で終わる行全体にマッチ（間の文字列は任意長）
• colou?r
  • color または colour にマッチ（u がある/ない両方に対応）。

3. 繰り返し回数の指定（量指定子）

• {n} : ちょうど n 回
• {n,} : n 回以上
• {n,m} : n〜m 回

具体例

• \d{3}-\d{4}
  • 123-4567 のような「数字3桁-数字4桁」形式にマッチ。

4. 文字クラス

• [abc] : a か b か c のいずれか1文字
• [^abc] : a,b,c 以外の1文字
• [0-9] : 数字
• [A-Za-z] : 英字（大文字・小文字）

5. 代表的なエスケープシーケンス

多くの処理系で共通して使われるもの。

• \d : 数字 [0-9]
• \w : 単語構成文字（英数字 + _）
• \s : 空白文字（スペース・タブ・改行など）
• \D : 非数字（\d 以外）
• \W : 非単語構成文字（\w 以外）
• \S : 非空白文字（\s 以外）

6. エスケープが必要な記号

次の文字はメタ文字として特別な意味を持つため、そのままの記号として扱うにはバックスラッシュでエスケープする必要がある。

• 対象文字
  • . * + ? ^ $ ( ) [ ] { } | \
• 使用例
  • \. : ドットそのものにマッチ
  • \? : 疑問符そのものにマッチ

補足

ここまでが「基本の道具」としての正規表現の要素一式であり、今後はこれらを組み合わせて「メールアドレスの簡易チェック」など、実用的なパターン作成にも応用できると示唆している。

個別でみれば、なんとなくわかる気もしますが、これが組み合わさると、まったく呪文です
ただ、いろんなパターンの質問とAIの回答を照らし合わせると、なんとなく理解できてくるので、正規表現にかぎらず、AIは言語学習資料としても本当に役立ちます。

ファナック系、NCデータ構造

NCデータの分析ソフトを検討する場合、NCデータ構造の知識は必須です
NCデータの知識がないまま、AIの回答だけで進めると、間違いなく後々苦労します
ファナック系のプログラム構造は、下記記事でも紹介しています

NCプログラム／プログラム構造

最近の投稿は、覚書きとしても残しておきたかったので、素人ながらLinux系の投稿が連続していましたが、今回は気分を変えて、今まで携わってきたＮＣ関連の記事を書こうと思います。ＮＣプログラムとは？ＮＣ工作機械のコントローラへの指令の集まりです。プログラムとありますが、ファナック系は基本的には命令コード...

www.kazuban.com

2019.11.30

「ワード」＝「アドレス」+「数字・数値」
「ブロック」＝「ワード」の集まり
「NCデータ」＝「ブロック」の集まり

NCブロックからNCアドレスを抽出する課題なので、NCコードを少し復習しておきます

ブロックの末尾は制御器では「EOB」ですが、PC側では改行コードになります
改行コードはOSにより変わりますが、基本的にアスキー形式での転送で大丈夫だと思います
NCデータの最小単位は、「ワード」と呼ばれていて、
「アルファベット一文字」+「数字、符号、小数点」が一塊になっている要素です
例えば「G02」とか「X-12.345」の構成です。
先頭のアドレス文字で機械への指令の種類を表し、ワードで具体的な指令になります
この「ワード」が集まり、一行の構成になった文字列が「ブロック」と呼ばれます
さらに、「ブロック」が複数行あつまって、NCデータになります
CAM利用の場合、作成したNCデータファイルをNC機械へ転送し加工動作を制御します
分析ソフトを検討する場合、まずはNCデータをブロックに、ブロックをワードに分解したほうが整理しやすいです
今回の課題では、正規表現を利用して「ブロック」を「ワード」に分解するコードを作成します
やりたい事をAIに投げかけると、それなりの回答をもらえます。
ただ、ＮＣコードのように、機種依存や複雑な表現がある場合、AIへすべて完ぺきなコードを期待してもなかなか思うような回答は得られません。
また、最初は良くても開発を進めていくうちに、改造したくなる場合もあります
やはり、ある程度の理解は必要です。

ブロックから正規表現でワードに分解する

具体的に正規表現を書き、「ワード」に分解した結果と照らし合わせながら理解を進めようと思います
「ワード」＝「大文字アルファベット一文字」+「数字」なので、一番単純な正規表現のパターンは、”[A-Z]\d”になります
また、正規表現パターンで、文字列から部分文字列を抽出するのに、AIは「re.findall関数」を教えてくれました
（findall関数についての詳細は、ネット検索やAIに聞いてみてください）
サンプル文字列は複数のパターンを織り交ぜた、”G0G1G00 G03M3 T102M30″　でやってみます
（文字列並びのみのサンプルで、NCデータとしては意味ありません）

アドレスと数字抽出

import re

block = "G0G1G00 G03M3 T102M30" # サンプルNCブロック文字列
words = re.findall(r"[A-Z]\d", block)
print(f"{words}")

#---------- 結果 --------------
#['G0', 'G1', 'G0', 'G0', 'M3', 'T1', 'M3']

ちょっと期待とは違いますが、とりあえずは、アドレスと数字がリストで取り出せました
たった一行で分解された文字列リストが作成されました、すごいですね～
一文字づつ文字列操作で処理させたら、結構なコード量になっていると思います
ただ、「\d」としたため、「数字は一文字」しか抽出してくれませんでした
ここで「\d{2}」としてみると、「数字二文字」のみ取り出してくれます
今回の例ですべて取り出すには「\d{1,3}」とすればすべてヒットします
「\d+」でも同様の結果になりますが、こちらの方は文字数制限はなくなります
今回のサンプルでは、”[A-Z]\d+”で行こうと思います
ちなみに、「\d{0}」とすると、アドレスのみ取り出せます。

import re

block = "G0G1G00 G03M3 T102M30" # サンプルNCブロック文字列
words = re.findall(r"[A-Z]\d+", block)
print(f"{words}")

#---------- 結果 --------------
#['G0', 'G1', 'G00', 'G03', 'M3', 'T102', 'M30']

さらに、アドレスと数字を分けて抽出したい場合

グループ化と呼ばれる（丸括弧）でパターンを囲むと「tuple」として分離してくれます
抽出した後の処理内容によっては、こちらが便利かもしれません

import re

block = "G0G1G00 G03M3 T102M30" # サンプルNCブロック文字列
words = re.findall(r"([A-Z])(\d+)", block)
print(f"{words}")
for addr, val in words:
    print(f"addr={addr}:val={val}")

#---------- 結果 --------------
#[('G', '0'), ('G', '1'), ('G', '00'), ('G', '03'), ('M', '3'), ('T', '102'), ('M', '30')]
#addr=G:val=0
#addr=G:val=1
#addr=G:val=00
#addr=G:val=03
#addr=M:val=3
#addr=T:val=102
#addr=M:val=30

軸（X,Y,Z・・）の小数点にも対応させる

ここまでは、GやMコードでしたが、軸指令に対応するには、符号や小数点も考慮する必要があります
余談ですがプログラミング初心者の場合勘違いしやすいのが、数字と数値の違いです。
「12.23」の場合、数値としては「12 + 0.23」のように演算ができますが、
数字の場合は、「1」「2」「.」「2」「3」と途中に「.」があるだけのただの数字文字の連続です
正規表現の場合も、数字・符号・小数点の文字の集まりとして処理するので、数値で考えてしまうと期待と違う結果になり、悩む事になります
さて、文字を意識してサンプル文字列データに軸指令を追加して、上記のコードで実行してみます

import re

block = "G90G01 X12.5Y+20.3Z-5.63F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z]\d+", block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12', 'F1000']

やはりこのコードでは、±符号と小数点が入るとマッチしないので、省かれてしまいますね
まず符号に対応するためにはアドレス「A-Z」の後に[+-]を追加します

import re

block = "G90G01 X12.5Y+20.3Z-5.63F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]\d+", block)
print(f"{words}")

#---------- 結果 --------------
#['Y+20', 'Z-5']

これでは、符号「+-」が必須に判断され符号付の文字列しかヒットしませんでした
符号文字は「無くてもいい」の意味で[+-]?としてみます

import re

block = "G90G01 X12.5Y+20.3Z-5.63F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]?\d+", block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12', 'Y+20', 'Z-5', 'F1000']

符号部分を[+-]? とすることで、符号がなくてもマッチするようになりました
次に小数点とそれ以下にも対応させてみましょう
NC制御器は、数値として扱いますが、文字としての小数点の扱いは結構面倒です。
小数点がある場合、ない場合、小数点から始まる場合、小数点で終わる場合・・など
まずは、小数点の有無に対応させるため、「\d+\.\d+」を考えましたが、
この場合、小数点がないとマッチしなくなります
そこで「？を付加」すれば「無くてもいい」にも対応できます

import re

block = "G90G01 X12.5Y+20.3Z-5.63F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]?\d+\.?\d+", block)
print(f"{words}")

#---------- 結果 --------------
['G90', 'G01', 'X12.5', 'Y+20.3', 'Z-5.63', 'F1000']

だいぶ理想に近づいてきましたが、「X.124」や「23.」など、小数点での始まりや終わりには対応できません
サンプル文字列に追加して確かめてみましょう

import re

block = "G90G01 X12.50Y+20.3Z-5.63 I.5 J22.F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]?\d+\.?\d+", block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'J22', 'F1000

やはり、「I.5」にはマッチせず「J22.」の「.」は省かれていますね
ここも余談ですが、NCで「22.」を「22」に変換してしまった場合、制御器によってはとんでもない事になりかねないので十分意識しておく必要があります。

整理してみると

• [A-Z]：NCコードのアドレス
• [+-]?：必須ではない、符号
• \d+：複数個の数字
  ここまでで、「Gコード」「Mコード」には対応できている
• \.?：小数点は必須でない
• \d+：複数個の数字

やはり、「小数点で終わる」場合「\.?」なので、省略されてしまいますね
ではどうすればいのか？
AIに聞いたところ、グループ化と言う方法があり、”( )”で囲む事で、一塊としてでマッチングのルール設定できるようです
ただし、”( )”では、囲みごとに分割されタプルのリストとして抽出されます
グループごとに分割させたくない場合には“(?: )“で囲む仕様があり非キャプチャグループと呼ばれマッチングのルールには使用するが分割はされないようです。
今回の例では、分割させたくないので、”(?: )“を使ってみます
最後の「\d+：複数個の数字」をグループ化して、必須ではない複数個の数字として設定します

import re

block = "G90G01 X12.50Y+20.3Z-5.63 I.5 J22.F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]?\d+\.?(?:\d+)?", block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'J22.', 'F1000']

これで、「22.」には対応できました。次は、小数点で始まる「.5」の場合です。
ここまででも、結構な呪文になっているのに、さらに複雑になりそうです。
ここもAIに相談すると、グループの中で（A | B）の書式で「AまたはB」とマッチング範囲の選択ができるようで、この書式での書き方を教えてくました

import re

block = "G90G01 X12.50Y+20.3Z-5.63 I.5 J22.F1000" # サンプルNCブロック文字列
words = re.findall(r"[A-Z][+-]?(?:\d+\.\d+|\d+\.|\.\d+|\d+)", block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'I.5', 'J22.', 'F1000']

• [A-Z]：NCコードのアドレス
• [+-]?：必須ではない、符号
• — ここからグループ化 —
• \d+\.\d+：数字+小数点+数字
  または
• \d+\.：数字+小数点
  または
• \.\d+:小数点+数字
  または
• \d+：複数個の数字のみ

書き方は他にもあると思いますが、グループ化して、マッチさせたいパターンを一つ一つORで区切るこの方法は私には理解しやすかったです

複雑な正規表現の可読性を高める

いちおう動作はしましたが、ここまでくると、読みにくいですね～
可読性を高める方法として、さらにAIが「re.VERBOSE」を提案してくれました
具体的に、上記のコードを書き替えてみます
パターンを一行づつに分割できて、行ごとにコメントも追記できるので、複雑になってもわかりやすくなります

pattern = re.compile(
    r"""
    [A-Z]        # A-Zアドレス
    [+-]?         # 符号
    (?:           # 小数点処理、非キャプチャグループ
      \d+\.\d+      # 数字、小数点、数字
      |\d+\.        # または、数字、小数点
      |\.\d+        # または、小数点、数字
      |\d+          # または、数字のみ
    )
    """,
    re.VERBOSE,
)
words = pattern.findall(block)
print(f"{words}")

#---------- 結果 --------------
#['G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'I.5', 'J22.', 'F1000']

さらにちょっと特殊な、G や M　コードにも対応させてみます

通常、NCワードは「アドレス＋数字」ですが、拡張されたワーク座標系指令やサブプロ呼び出しなどちょっと特殊な構成のコードもあります
全てに対応は難しいと思いますが、「G54.1P1」や「M98P100」などにも対応してみようと思います。
これら対応するためには、上記のパターンでは処理できないのでパターンを追加します
やはり、可読性が上がる、re.VERBOSE を利用します

block = (
    "G05P10000 G90G01 X12.50Y+20.3Z-5.63 I.5 J22.F1000 G54 G54.1P12 M98P1100 M198 P2299"
)
pattern = re.compile(
    r"""
    # --- 特殊構成、G54.1P12 / M98P1234　など---
    [GM]          # G や M アドレス
    \d+(?:\.\d+)? # 54　や　54.1 
    \s*P\d+       # スペースとP文字と数字
    # --- 通常のアドレス+数字 ----
    |[A-Z]        # A-Zアドレス
    [+-]?         # 符号
    # --- 小数点対応 ----
    (?:           # 非キャプチャグループ
      \d+\.\d+      # 数字、小数点、数字
      |\d+\.        # または、数字、小数点
      |\.\d+        # または、小数点、数字
      |\d+          # または、数字のみ
    )
    """,
    re.VERBOSE,
)
words = pattern.findall(block)
print(f"{words}")

#---------- 結果 --------------
#['G05P10000', 'G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'I.5', 'J22.', 'F1000', 'G54', 'G54.1P12', 'M98P1100', 'M198 P2299']

どうにかできました。
次の課題は「G04X10.」とかにも対応したいと思っていますが、これ以上条件が増えると大変です
正規表現パターンを変数化できれば、もう少しわかりやすいと思います

正規表現のraw文字列の変数化

AIに聞いてみました。さすがAI、できますよ！との回答をもらいました
AIの回答を参考に上記コードを書き直してみました。

block = (
    "G05P10000 G90G01 X12.50Y+20.3Z-5.63 I.5 J22.F1000 G54 G54.1P12 M98P1100 M198 P2299"
)
num = r"[+-]?(?:\d+\.\d+|\d+\.|\.\d+|\d+)"  # +12.123|-24.|.56|30
g54_1 = r"[GM]\d+(?:\.\d+)?\s*P\d+\.?"      # G54.1P1 M98P1122
nomal = r"[A-Z]"  # 通常のアドレス
pattern = re.compile(
    rf"""     
    {g54_1}         # G54.1P1 , M98P1122
    #----------------------
    |{nomal}{num}   # G01 , X-12.356
    """,
    re.VERBOSE,
)
words = pattern.findall(block)
#---------- 結果 --------------
#['G05P10000', 'G90', 'G01', 'X12.50', 'Y+20.3', 'Z-5.63', 'I.5', 'J22.', 'F1000', 'G54', 'G54.1P12', 'M98P1100', 'M198 P2299']

なるほど、だいぶ見やすくなりました
今後の仕様変更にも対応しやすくなったと思います
興味ある方は是非、「G04X10.」への対応もやってみてください。

まとめ

これまでも単純な正規表現に触れる機会はありましたが、複雑な記述はまるで「呪文」のようで、敬遠していました。
しかし、正規表現は文字列操作において非常に強力な武器になります。
独学ではやる気なしでしたが、AIと対話する事で、ある程度は理解できてきました。
今後もAIと対話しながら一歩ずつ分析していくことで、正規表現だけでなく、プログラミング言語全体の理解力も深めていけると感じています。

Fusion360 Python API 再挑戦！AIの力を借りて、sketchなど基本ライブラリを作ってみた。

Aiと言う強い味方を得て、Fusion API に再挑戦しています。pythonの学習もかねて、skrtch関連の関数をライブラリ化しています。 筆者の環境では、正常に動作しています。コピペで利用可。 Aiに教えてもらわないと、作成できなかった実例をレポートしています。

www.kazuban.com

2025.07.09

この記事では、Fusionの標準APIの2D スケッチで頻繁に使うオブジェクトをカプセル化しライブラリとしてまとめてみました。
Fusion 360 はパラメトリックモデリングを前提としているため、まずラフに図形を描き、あとから寸法線や拘束を追加して形状を詰めていく、という作業フローが基本です。
試行錯誤しながら設計を煮詰めていく用途では非常に強力な手法ですが、CAM 作業のように、すでに図面や数値が確定している場合には、この手順がやや回りくどく感じることもあります。
またFusion 360 には原点の概念はありますが、原点を強く意識しないモデリング手法であるため、「図面ありき」の CAM 作業では、座標原点を通る中心線作図から始めるようにしています
ところが、この最初に描いた中心線も拘束や固定を忘れると、気づかないうちに移動させてしまい、後工程で大きなトラブルになることがあります。

固定された座標軸を、簡単かつ確実に作図したい
　　──まずこれが、スクリプト作成を始めたきっかけです。

また、スケッチ平面に対して高低差のある傾いた線を引きたい場合や、
平面からの異なる高さに円を描きたい場合なども、標準操作では少し手間がかかります。
前回作成したライブラリでは、直線や円といったシンプルな作図であれば、数値を引数として渡すだけで描画できるところまでは実現しています。
ただし、実用面を考えると、やはり GUI ダイアログ形式で数値入力できる仕様にしたいというのが今回の取り組みです。

Fusion API標準機能のコマンド UIでダイアログ仕様

Fusion API には、コマンドに付随する入力ダイアログ機能が標準で用意されており、テキストボックスやドロップダウンリスト、スライダーといった一般的な UI 要素を利用できます。
これらの UI 要素は Command Inputs オブジェクトを使って定義します。
コマンドが作成される際に呼び出される CommandCreated イベントハンドラ内で Command Inputs を作成し、コマンドの入力ダイアログに表示する入力フィールドを定義します。
その後、Execute イベントハンドラ内で、ユーザーがダイアログ上で入力した値を取得し、処理を実行します。
このように Fusion API のコマンドはイベント駆動で構成されており、各イベントハンドラを通して入力値を扱う必要があります。
とりあえずコード化してみましたが、初級者の私にとっては処理の流れを理解するのが難解でとりあえずネット情報やAIを参考に作成してみました
下記は、標準コマンドダイアログへの入力値を上記で紹介している「lib_2d.draw_center_line(x, y, z)スクリプトに取り込んでＸ，Ｙ，Ｚ座標軸線を作図させるスクリプトです

class CommonAddinFramework:
　”””
　Fusion 360 アドインの共通フレームワーククラス。
　ダイアログの表示、入力値の取得および指定された描画コールバック関数の実行を管理
　”””
　def __init__(
　　self,
　　command_id: str,
　　button_name: str,
　　description: str,
　　input_defaults: dict,
　　drawing_callback,
　):

・・・・
・・・・

コード全体を表示

単純入力フォームに、tkinter を使ってみる

上記でFusion標準のコマンドUIを使って、寸法入力で座標軸線を作画できるようになりましたが、今後機能を増やしていくには、やはりイベント処理ではわかり辛く煩わしく感じますし、ネット上の情報も少ないです
そこで、Python標準のtkinterを使ってみました
tkinterはpython標準ライブラリなので、さすがにこちらは、情報豊富です

中心線作図スクリプト

かなりAIに助けてもらいましたが
上記記事内で作成した中心線スクリプトに入力数値を渡すダイアログをtkinterを利用して作成してみました。
最初にメッセージ表示の「label」を配置して、「entry」で設定値入力ボックスを配置
さらに、固定とコンストラクション設定用の「Checkbutton」を配置して作成ボタンで、作図させる仕様です

# ——————————————————————
# ダイアログクラス
# ——————————————————————
class DialogPanel(tk.Tk):
　def __init__(
　　self,
　　input_defaults: Dict[str, float],
　　construction,
　　fixed,
　):

・・・・
・・・・

コード全体を表示

この「DialogPanel」クラスをアレンジして、直線や円などを作図する入力ダイアログも追加作成していきます。
このスクリプトをFuisonの「スクリプトとアドイン」に登録すれば、作図スクリプトをダイレクト数値入力仕様で実行できるようになります。
私的には、FusionAPIのCommand Inputsよりもわかりやすいです。

表示されたボタンをクリックして、関数を実行するスクリプト

いくつかコマンドダイアログを作成していくと、いちいち「スクリプトとアドイン」へ登録するのも面倒になってきます。
FusionAPIでもFusionタスクバーにコマンド実行プルダウンを追加できるようですが、これもまた敷居が高いです。
今回は、tkinterでメニュー用パネルを作成し、そのメニューボタンで作図スクリプトを起動できれば、メニューだけの登録で済みます。

ボタンクリックで起動させる、tk.Button　の　command　オプション

ボタンクリックで関数を実行させるには「command」オプションに関数名を渡すと実行できます

# 起動させたい関数
def cmd1():
    print("Function is cmd1().")
・・・
・・・
# ボタンクリックで、「def cmd1()」関数を起動する
tk.Button(
        root,
        text="Execute_command01",
        command=cmd1
)

ここで初心者の筆者が疑問に感じたのが、「command=cmd1」の書き方です
関数名は「cmd1()」なのに、「commandオプション」には”( )”が付かないようです
この関数名の”( )”の有無について、AIに聞いてみました

関数名の () の有無による違い

1. かっこがない場合 (cmd1)

かっこがない場合、それは関数そのもの（オブジェクト） を指します。これは「関数というデータ」として扱われます。

意味	関数そのものを指す（データ）
例	data = { "menu1": cmd1 }
目的	関数を変数に代入したり、tk.Button の command のように他の関数に引数として渡すとき。
動作	処理はまだ実行されない。ただ関数の場所を渡すだけ。

2. かっこがある場合 (cmd1())

かっこがある場合、それは関数の実行（呼び出し） を意味します。

意味	関数の処理を今すぐ実行する
例	cmd1()
目的	関数に書かれている処理をすぐに実行し、その戻り値（結果） を受け取るとき。
動作	すぐに処理が実行される。もし戻り値があれば、その結果が残る。

なるほど～
“( )”がない場合には、C言語でのポインタ渡しのようなイメージですかね
“( )”を付けると、「すぐに実行される」との事なので、
クリック後実行させたい、「tk.Button」の「command」オプションには、使えないですね
したがってTkinterのcommand は、引数なしで呼び出せるものを要求すると言うことになります
では、引数や戻り値を利用したい関数を実行するにはどうするか？

lambda（ラムダ式）を使う

lambda は、短い無名関数（名前のない一時的な関数）を簡単に作るためのPythonの機能ですが、デフォルト引数を設定できるけど、実行時には引数なしで呼び出されるようです
したがって、「tk.Button」の「command」に利用できます
具体的には、「lambda 引数1,引数2…：引数を使った処理」のように記述します

def exec(function, msg):
    function(msg)
・・・・・・
・・・・・・
command = lambda msg="button click!", func=cmd1: exec(func, msg)

このように、関数：execに、func, msg　の引数を渡せば
「func名」の関数に「引数msg」を渡して実行できます
簡単な、サンプルコードを書いてみました

"""Execute a function on button click."""

import traceback
import adsk.core
import adsk.fusion

# import adsk.cam

import tkinter as tk


def disp_message(msg: str):
    app = adsk.core.Application.get()
    ui = app.userInterface
    ui.messageBox(f"{msg}")


def print_cmd1():
    disp_message("lambda is not used.")


def print_cmd2(msg: str):
    disp_message(msg)


def exec(function, msg):
    function(msg)


def run(context):
# def run():
    root = tk.Tk()
    label1 = tk.Label(
        root,
        text="Click the button.",
        bg="light cyan",
    )
    label1.pack()
    # ---------------------------------
    tk.Button(
        root,
        text="Execute1",
        command=print_cmd1,
    ).pack(side=tk.LEFT, padx=10, pady=10)
    # ---------------------------------
    tk.Button(
        root,
        text="Execute2",
        command=lambda m="center button click!", f=print_cmd2: exec(f, m),
    ).pack(side=tk.LEFT, padx=10, pady=10)
    # ---------------------------------
    tk.Button(
        root,
        text="Execute3",
        command=lambda m="right button click!", f=print_cmd2: exec(f, m),
    ).pack(side=tk.LEFT, padx=10, pady=10)
    root.mainloop()

こんな感じで、「ボタン」を並べれば、ボタンクリック仕様のコマンド実行メニューが作成できそうです

Tkinterは、Autodesk 非公式

「tk.Button」と「lambda」で、メニューダイアログが作れそうです
上記で紹介した座標軸センターラインを作図するスクリプトを実行するダイアログを作成してみます
ところが、Tkinterの使用は、Autodeskは非公式のようなので注意が必要です

Fusion API で、tkinter を使用する場合の注意点

・Tkinterの使用は、Autodesk 非公式
・Tkinter が root.mainloop() で動作中は Fusion 本体の操作は一切できなくなる
・Mac + Tkinter は挙動が不安定なことがある
・Tkinterウィンドウを閉じた時に不安定になる場合がある
・最悪、タスクマネージャーでFusion 強制終了

やはり、Autodesk側としては、あまり推奨はしていないようです
常駐ツールやモーダルな本格的ダイアログはやめたほうがよさそうです
今回作成中も、閉じる時に「Script Error」が出たり、強制終了の必要に迫られたりしましたが、数値入力や条件入力の簡易パネルとして、開いたら閉じて、Fusionに制御を返すような単純な処理であれば利用できると思っています。

run(context) の context引数 は必須

python学習もかねて、いろいろ簡単なコードを書きました。
コードが悪いと、Fusionを強制終了させざるを得ない場合もありましたが、普通に問題なく動作しているのに、パネルの「×ボタン」で終了時に、Fusionのコマンドエリアに「SCRIPT ERROR」が出た事もありました。
これの原因究明には結構時間がかかりました。
上記のサンプルコードでも、run(context)の「context」は使っていないからと、
省略すると（「def run():」）「SCRIPT ERROR」になり、なにも動作しない状態になります
やはり、FusionAPIがどこかで使っていて、必須なようです
「×」での「SCRIPT ERROR」は終了時の警告のみなので、無視しようとも思いましたが、気味が悪いので、とりあえずAIにもいろいろも相談しましたが、的確な回答はもらえませんでした。
例えば下記コードで終了時に「SCRIPT ERROR」になります。
引数に「tk.Tk()型」を渡しました。結局、この引数が原因でした

def run1(root):
　    label1 = tk.Label(root , text=”Click the button.”)
　　・・・・
　　・・・・

master = tk.Tk()
run1(master)

Fusionの「スクリプトとアドイン」で、「スクリプトまたはアドインを作成」を選択すると、自動的にサンプルスクリプトが作成されるので、そちらを参考にしてみました。
Fusionで自動作成された、run関数の中身は下記のようになっています

def run(_context: str):
    """This function is called by Fusion when the script is run."""

    try:
        # Your code goes here.
        ui.messageBox(f'"{app.activeDocument.name}" is the active Document.')
    except:  #pylint:disable=bare-except
        # Write the error message to the TEXT COMMANDS window.
        app.log(f'Failed:\n{traceback.format_exc()}')

引数は「_context: str」となっています。
以前のサンプルコードには、「str」のような型ヒントはなかったように記憶していますが
「str」なので引数の型は「文字列型」を期待しているようです。
このサンプルでも「_context」はどこにも使われていないように見えますが、やはりFusionAPI側では必須なのでしょう
ちなみにデフォルトでは「_context: str」と、型ヒントでは「文字列型」となっていますが、下記コードを追加して調べてみました

    ui.messageBox(f"type={type(_context)}")
    ui.messageBox(f"{_context}")

そのタイプと内容を表示させてみると

type=<class ‘dict’>
{‘IsApplicationStartup’: False}

このように、「辞書型」になっていました。
詳細はわかりませんが、メイン関数の第一引数はFusionが使うので、別の引数を使いたい場合には、追加の形をとったほうがよさそうです
この部分を変更すると正常に終了するようになりました。
pythonのこういった型のあいまいな部分にも、まだまだ慣れないです

数値入力ダイアログで、座標軸を作図するスクリプトをボタンで起動

さて、上記で紹介した「中心線作図スクリプト」を、ボタンクリックで動作させるダイアログを作成してみようと思います。
ただし、このスクリプトは、以前紹介した記事内のライブラリ「lib_util.py」「lib_2d.py」を利用するので、もし試してみたい場合にはそちらも必要になります
下記に全部含まれたコードをダウンロードできるようにしておきますので、興味ある方がいらっしゃれば試してみてください。

"""Execute a function on button click."""

import adsk.core
import adsk.fusion
import os, sys, importlib, traceback
import tkinter as tk

import tkinter.font as tkFont
from typing import Optional, List, Dict, Any

current_dir = os.path.dirname(os.path.abspath(__file__))
script_dir = os.path.dirname(current_dir)  # C:\FusionAPI\Scripts
sys.path.append(script_dir)
# library import
"""
C:\FusionAPI\Scripts
│
├─library
│  ├─lib_util.py
│  ├─lib_2d.py
├─test
│  ├─menu.py (This script)
"""
from library import lib_util, lib_2d


##---------------------------
def disp_message(msg: str):
    lib_util.disp_message(msg)


# ------------------------------------------------------------------
# ダイアログクラス
# ------------------------------------------------------------------
class DialogPanel(tk.Tk):
    """センターライン作画ダイアログ"""

    def __init__(
        self,
        input_defaults: Dict[str, float],
        construction,
        fixed,
    ):
        super().__init__()
        # self.my_font = None
        self.input_defaults = input_defaults
        self.x_width: float = 0.0
        self.y_width: float = 0.0
        self.z_width: float = 0.0
        self.construction: bool = construction
        self.fixed: bool = fixed
        self.widths: dict[str, tk.DoubleVar] = {}
        self._create_widgets()

    def _simple_frame(self, **kwargs) -> tk.Frame:
        # Fontインスタンスを作成
        self.my_font = tkFont.Font(family="Arial", size=10, weight="normal")
        """単純フレームを作成し、ウィンドウ全体に展開"""
        master = self
        frame = tk.Frame(master, **kwargs)
        master.title("Center Line")
        frame.pack(fill="both", expand=True, padx=5, pady=5)
        return frame

    def _create_widgets(self):
        """全てのUI要素を作成"""
        # 全体を包む単一のフレーム
        self.main_frame = self._simple_frame(relief="ridge", bd=5)

        # ------------------
        # 0. トップメッセージ
        # ------------------
        row_idx = 0
        top_frame = tk.Frame(self.main_frame)
        top_frame.grid(row=row_idx, column=0, columnspan=3, pady=10)
        tk.Label(
            top_frame,
            text="各軸の長さを指定してください。\n作成したくない軸は「0.0」にしてください",
            bg="light cyan",
            font=self.my_font,
        ).pack()
        # ------------------
        # 1～3 各軸幅入力ボックス
        # ------------------

        row_idx += 1
        # 事前設定のラベルとデフォルト値
        for label, default in self.input_defaults.items():
            tk.Label(
                self.main_frame,
                text=label,
                font=self.my_font,
            ).grid(
                row=row_idx,
                column=0,
                sticky="e",
            )
            var = tk.DoubleVar(value=default)
            ent = tk.Entry(
                self.main_frame,
                font=self.my_font,
                textvariable=var,
                width=10,
                bg="lightyellow",
                # bg="ivory",
            )
            ent.grid(row=row_idx, column=1)
            self.widths[label] = var
            row_idx += 1
        # ------------------
        # 4. 要素固定チェック
        # ------------------
        row_idx += 1
        # self.fixed_check = tk.BooleanVar(value=True)
        self.fixed_check = tk.BooleanVar(value=self.fixed)
        check_button = tk.Checkbutton(
            self.main_frame,
            text="要素固定",
            variable=self.fixed_check,
            font=self.my_font,
        )
        check_button.grid(row=row_idx, column=0, padx=5, pady=5, sticky="w")
        # self.construction_check = tk.BooleanVar(value=True)
        self.construction_check = tk.BooleanVar(value=self.construction)
        check_button = tk.Checkbutton(
            self.main_frame,
            text="コンストラクション",
            variable=self.construction_check,
            font=self.my_font,
        )
        check_button.grid(row=row_idx, column=1, padx=5, pady=5, sticky="w")

        # ------------------
        # 5. 最終確定ボタン
        # ------------------
        row_idx += 1
        # ボタンを格納するボトムフレーム
        bottom_frame = tk.Frame(self.main_frame)
        bottom_frame.grid(row=row_idx, column=0, columnspan=3, pady=10)

        tk.Button(
            bottom_frame, text="作成実行", font=self.my_font, command=self.get_data
        ).pack(side=tk.LEFT, padx=10)
        tk.Button(
            bottom_frame, text="閉じる", font=self.my_font, command=self.destroy
        ).pack(side=tk.LEFT, padx=10)

    def get_data(self):
        """入力データを取り出す"""
        v: List = []
        for value in self.widths.values():
            v.append(value.get())
        self.x_width = float(v[0])
        self.y_width = float(v[1])
        self.z_width = float(v[2])
        self.fixed = self.fixed_check.get()
        self.construction = self.construction_check.get()
        self.destroy()


##--------------------------------------------------------------
##--------------------------------------------------------------
def diarog_test(master):
    """センターライン作画"""
    if master:
        master.quit()  # mainloop を終了させる
        master.destroy()
    input_defaults = {
        "X軸長さ": 50.0,
        "Y軸長さ": 50.0,
        "Z軸長さ": 10.0,
    }
    # 線種指定
    construction = True
    fixed = True

    app = DialogPanel(input_defaults, construction, fixed)
    app.mainloop()
    wx = app.x_width
    wy = app.y_width
    wz = app.z_width
    construction = app.construction
    fixed = app.fixed
    try:
        lib_2d.draw_center_line(wx, wy, wz, construction, fixed)
    except:
        disp_message("Failed:\n{}".format(traceback.format_exc()))


# ---- Action command after button click ----------


def print_cmd1():
    disp_message("lambda is not used.")


def print_cmd2(msg: str):
    disp_message(msg)


def exec(function, msg):
    function(msg)


def on_closing(root):
    """Processing when the window's 'x' button is pressed"""
    disp_message("I'll close now!")
    root.quit()  # Terminate the mainloop
    root.destroy()  # Releases window resources.


def button(root: tk.Tk):
    # Window close action
    root.protocol("WM_DELETE_WINDOW", lambda: on_closing(root))
    label1 = tk.Label(root, text="Click the button you like.", bg="light cyan")
    label1.pack()
    tk.Button(root, text="Message1", command=print_cmd1).pack(
        side=tk.LEFT, padx=10, pady=10
    )
    tk.Button(
        root,
        text="Message2",
        command=lambda m="Lambda specification!", f=print_cmd2: exec(f, m),
    ).pack(side=tk.LEFT, padx=10, pady=10)
    tk.Button(
        root,
        text="Draw center line",
        command=lambda tk=root, f=diarog_test: exec(f, tk),
    ).pack(side=tk.LEFT, padx=10, pady=10)
    root.mainloop()


def run(context: dict):  # {'IsApplicationStartup': False}
    root = tk.Tk()
    root.attributes("-topmost", True)  # Bring Window To Top
    button(root)

サンプルスクリプトのダウンロードと使い方

ダウンロードと使用方法は下記を参考にしてください
この例では、展開されたトップフォルダ「FusinAPI_kazuban」を「Cドライブ」の直下に、コピーする方法で説明していますが、任意の場所でかまいません
ただし、Fusionが立ち上がった状態では、キャッシュの影響で「library」内のスクリプトがうまく読み込めない事があります
コピー後に、Fusionを起動する方がトラブル少ないです。
そのトップフォルダ下の「Scripts」、その下の「library」「menyu01」内のスクリプトを使用します
全ての使用ライブラリも含めたZIPファイルは下記からのダウンロードできます

FusinAPI_kazubanダウンロード

C:\FusinAPI_kazuban
└─Scripts
    ├─library
        └─lib_2d.py
        └─lib_util.py
    └─menyu01
        └─menu.py

・ダウンロード後展開した「FusinAPI_kazuban」を適当なフォルダへコピー
・Fusionの「スクリプトとアドイン」から「menyu01」を選択する
・正常に登録されると、スクリプトが実行できます

第一弾、終了

とりあえず、Autodesk Fusion からtkinterオブジェクトのパネルを表示し、ボタンに割り当てられたスクリプト動作をさせる事ができました。
数値入力用ボタンでは、tkinterへの入力値をFusionAPIに渡し、作図させる事ができるようになりました
次回は、もう少し作図スクリプトとメニューを充実させていきたいと思います

RockyLinux9.３で自宅サーバーを再構築V08・postfix で送信専用メールサーバー構築

このサイトには「お問い合わせフォーム」を設定していますし、起動しているサーバーがエラーなどの連絡を発信する場合もあります。 重要なメールもあるので、メインのメールアドレスへ配信させる設定を行います。 今回は、サーバー側から、配信するのみの設定を行います

www.kazuban.com

2024.01.08

この設定により、このブログサイトへの、「お問い合わせ」も設置できているのですが、この不具合では、「お問い合わせ」もこちらに届きません
う～ん、困った。

こんな時ほど、Aiに相談だぁ！

最初は、ググってみましたが、なかなか的確なサイトにぶち当たりません。
Aiに聞いてみよう！
ChatGPT と Gemini 2.5Flash に同じ質問をしてみましたが、ほぼ同じ回答内容でしたが
ChatGPTのほうが、みやすく感じます
ただ、ChatGPTは次から次に、逆質問をしてくるのが、ちょっとウザいかも・・・

rocky linux9 で自宅サーバーを運用していますが、2025/10月からサーバーからのメールが送信できなくなりました sudo cat /var/log/maillog | grep -i error を実行してみると、下記エラーがでます。原因はなんでしょう？
sudo cat /var/log/maillog | grep -i error
（エラー内容）
・
・

それにしても、エラー内容をそのまま突っ込めるのは、今までの検索では考えられないですね。

Aiのエラー内容の整理

ログのエラー内容を整理すると：
Postfix が プロバイダ のメールサーバ (mx.hogehoge.com) に TCP ポート 25 で接続しようとしてタイムアウトしています。

主な原因候補

１０月からであれば、原因とは考えにくいですが・・・
Rocky Linux の firewalld やルーターで 25番ポートのアウトバウンドが塞がれた可能性。

プロバイダ側のポート25ブロック
2025年現在、多くの ISP（特に家庭向け回線）はスパム対策のため ポート25を塞いでいる ことが多いです。
それまでは通っていたけど、2025年10月から「送信ポリシー変更」でブロックされた可能性があります。

プロバイダ 側の受信制限
プロバイダ の受信サーバが外部からの直接SMTPを拒否するようになった可能性があります。

ファイアウォール / サーバ側の設定
個人宅サーバからの直接送信を受け付けない運用に切り替えた可能性。

確認方法

自宅サーバーからプロバイダメールサーバーへ直接接続できるか試す

telnet mx.hogehoge.com 25

もしタイムアウトするなら → 回線側（ISPやプロバイダ）で遮断。
もし「220〜」の応答があれば → Postfixの設定やファイアウォールの問題。

結果、telnet mx.hogehoge.com 25 が応答なし（タイムアウト）でした。
ということは、サーバー側(Postfix)の問題ではなく、回線側で25番ポートがブロックされている可能性が非常に高いと言うことのようです。

状況まとめ

• 以前は送れた → 2025年10月から送れなくなった
• ログでは「Connection timed out」
• telnet も通らない

👉 これは「ISP（プロバイダ 側）が 自宅回線からの直接25番SMTP送信を禁止 に切り替えた」ケースに一致します。
最近は迷惑メール対策で家庭向け回線ではほぼ標準でブロックされます。

解決方法

１．プロバイダのメールサーバ経由（SMTPリレー / smarthost）
　・Postfix の relayhost 設定でプロバイダの SMTP サーバ（587 or 465ポート）を使う
２．外部のメールリレーサービスを利用
　・SendGrid, Gmail SMTP relay, AWS SES など
３．自宅サーバではなく VPS 経由で送信
　・自宅サーバからVPSへ転送して、VPSから外へ送信。

解決策（おすすめ）

プロバイダのSMTPサーバを経由する（最も現実的）

Postfix で 「スマートホスト」設定をして、smtp.hogehoge.com:587 経由で送信するのがベストです。（25番ではなく 587 番（Submission ポート）がベスト）

まずは、 外部からの直接配送(mx) ではなく、 認証付きの送信サーバ(smtp) なら接続できるかの確認

telnet smtp.hogehoge.com 25
telnet smtp.hogehoge.com 587

結果、両方とも接続できました
telnet smtp.hogehoge.com 587
Trying 000.000.000.0… Connected to smtp.hogehoge.com. Escape character is ‘^]’.
220 hogehoge.com ESMTP server ready Sat, 4 Oct 2025 15:42:22 +0900

整理すると

mx.hogehoge.com:25 → タイムアウト（接続できない）
smtp.hogehoge.com:25 → 接続できる（220応答あり）
smtp.hogehoge.com:587 → 接続できる（220応答あり）
つまり：
プロバイダ は 外部からの直接配送(mx) を制限している
代わりに 認証付きの送信サーバ(smtp) なら 25 でも 587 でも受け付けている
じゃあどっちを使うべき？
587（submission ポート） が推奨です（標準仕様で「認証あり専用の送信ポート」）
25番で smtp.nifty.com に直接送ることもできますが、将来的にブロックされる可能性が高いです。
なので、Postfixの relayhost を smtp.hogehoge.com:587 にして、SMTP認証を通す設定がベストです。

設定方法

認証情報ファイルを作成

/etc/postfix/sasl_passwd　ファイルを作成し、アドレスとパスワードを追記：
「プロバイダのメールアドレス」：「アドレスパスワード」

[smtp.hogehoge.com]:587 myaddress@hogehoge.com:mypasswd

Postfix設定ファイルを修正

/etc/postfix/main.cf の末尾あたりに下記追記：

# hogehoge の SMTP サーバをリレーに指定
relayhost = [smtp.hogehoge.com]:587

# SMTP認証を有効化
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_sasl_security_options = noanonymous

# TLS を使用
smtp_use_tls = yes
smtp_tls_security_level = may
smtp_tls_note_starttls_offer = yes

ハッシュ化して権限設定

sudo postmap /etc/postfix/sasl_passwd
sudo chmod 600 /etc/postfix/sasl_passwd*

Postfix再起動

sudo systemctl restart postfix

テスト送信

echo "This is a test mail" | mail -s "Postfix smtp test" myaddress@hogehoge.com

確認

/var/log/maillog を確認して、status=sent になれば成功

後日、Gmailへの転送がNGになった

後日、バックアップサーバーの立ち上げをやっていて、GmailへのテストメールがNGになった

 echo "This is a test mail to gmail" | mail -s "Postfix smtp test2" hogehoge@gmail.com

ここも、AIに聞いてみる

Gmailで該当メールを開いて 「︙」→「メッセージのソースを表示」 し、以下の行を確認してみてください：

Authentication-Results: mx.google.com;
   spf=pass  ← ここがfailだとアウト
   dkim=pass ← ここがfailだとアウト

その結果を教えてもらえれば、どこが問題か特定できます！

Authentication-Results: nifty.com;
    dmarc=none header.from=kazuban.com;
    dkim=none;
    spf=fail smtp.mailfrom=kazuban.com;
    sender-id=Fail (pra) header.From=kazuban.com

原因が明確になりました！

AIが問題点指摘

spf=fail → kazuban.com のDNSにSPFレコードがないか、Niftyのサーバーが許可されていないNiftyのSMTP経由で送っているのに、Fromアドレスが @kazuban.com なので、
「kazuban.comのSPF的にNiftyは許可されてないよ」とGmailに判断されています。

A. kazuban.com のDNSにSPFレコードを追加（推奨）

種別     ホスト名          内容
TXT      @ （または空欄）  v=spf1 include:nifty.com ~all

設定後、反映に数分〜数時間かかる場合があります。確認コマンドはこちら：

dig TXT kazuban.com | grep spf

v=spf1 include:nifty.com ~all が表示されれば成功です。

正常にもどった

いまさらですが、Aiはすごいですね
ちょっと前までは、プロンプトが重要とか言われていましたが、最近ではあまり感じません
普通に個人の言葉で、質問すれば、かなり理解してくれます
もしかすると、サポート会社などへ、電話質問するよりも簡単かもしれません
理解力と分析力は、はるかに人間を超えているように思います

カスタムマクロの欠点

Google で「カスタムマクロ欠点」で検索してみると、下記のAi概要が最上部に表示されました
話は変わりますが、最近では通常検索でもAi回答が出てくるようになりましたね。

AI による概要

カスタムマクロは、NCプログラムの効率化や自動化に役立つ一方で、いくつかの欠点も存在します。主な欠点としては、プログラミングの難易度、デバッグの複雑さ、互換性の問題、そして過度な依存によるリスクなどが挙げられます。

カスタムマクロの欠点

• プログラミングの難易度:カスタムマクロは、通常のNCプログラムよりも複雑なロジックを記述する必要があるため、習得に時間がかかり、プログラミングの難易度が高いです。特に、条件分岐やループ処理を多用する場合、複雑さが増し、エラーが発生しやすくなります。
• デバッグの複雑さ:カスタムマクロのデバッグは、通常のNCプログラムよりも難易度が高いです。変数の値の変化や処理の流れを追跡するのが難しく、エラーの原因特定に時間がかかることがあります。また、マクロプログラムが複雑になるほど、デバッグ作業はさらに困難になります。
• 互換性の問題:カスタムマクロは、使用するNC工作機械や制御装置の種類によって、互換性の問題が発生する可能性があります。同じマクロプログラムでも、機械が異なると正しく動作しない場合や、エラーが発生する場合があります。そのため、マクロプログラムを作成する際には、互換性を考慮する必要があります。
• 過度な依存によるリスク:カスタムマクロに過度に依存すると、マクロプログラムの変更や修正が必要になった場合に、他の作業に影響が出たり、生産性が低下する可能性があります。また、マクロプログラムの作成者が不在になった場合、保守や管理が困難になるというリスクもあります。

その他の考慮事項

• マクロプログラムの可読性:カスタムマクロは、可読性の高い書き方を心がける必要があります。コメントを適切に記述し、変数名や処理の流れを分かりやすくすることで、他の人がマクロプログラムを理解しやすくなります。
• マクロプログラムのバージョン管理:カスタムマクロは、バージョン管理を行うことで、変更履歴を把握し、必要に応じて以前のバージョンに戻すことができます。
• マクロプログラムのテスト:カスタムマクロは、実際に機械を動かす前に、シミュレーション環境などで十分にテストを行う必要があります。これにより、エラーの発生を未然に防ぎ、安全に運用することができます。

これらの欠点や考慮事項を踏まえ、カスタムマクロの導入を検討する必要があります。

なるほど・・ここのサイトでもいくつか取り上げていますが、まさに同意見です。

プログラミングの難易度

マクロは数多く作成してきましたが
機械の制御器に処理させる言語になるので、どうしても、一般的なプログラミング言語と比較すると、中途半端で可読性は悪くなってしまします。
ちなみに、レダース(Roeders）機は、独自開発されたプログラミング言語ライクな言語です。
加工動作のGコードのサブプロ部分と、その動作部分を管理するメインプロ部分を分離する事を基本で開発されているように感じています。
特にWindowsソフトウェアとして開発された言語なので、自動化や多数個など、複雑なメインプロを開発する場合でもかなり楽です。

デバッグの複雑さ

このサイトでも、何度か書いていますが、一番は変数の制限が可読性を悪くしているように思います。
筆者は通常のGコードだけであれば、TRYCUT と言うシミュレーションソフトを使っていますが、TRYCUTにはマクロ展開機能が付いていません。
シミュレートできないので、マクロのデバッグはエディタやプリントアウトして目視で追っかけ確認ますがかなかな面倒で、リスクもあります。
社内設備機械で、一台だけマクロも含めたシミュレート機能がある制御器があるので、確認のためだけに、その機械を起動させる場合もあります。
大人しく、マクロ機能付きのシミュレータを購入したら・・・の意見もあると思いますが、マクロ利用頻度から検討すると、どうしても費用対効果の面で無理があります。

そうだ、Aiに展開してもらおう！

前回、Fusion python API を、Aiに教わったらすごかった・・を記事にしました

Fusion360 Python API 再挑戦！AIの力を借りて、sketchなど基本ライブラリを作ってみた。

Aiと言う強い味方を得て、Fusion API に再挑戦しています。pythonの学習もかねて、skrtch関連の関数をライブラリ化しています。 筆者の環境では、正常に動作しています。コピペで利用可。 Aiに教えてもらわないと、作成できなかった実例をレポートしています。

www.kazuban.com

2025.07.09

Fusion API は、一般的なpython言語構文やライブラリだけでなく、独自のオブジェクトを絡み合わせて開発していくので、そのパッケージの理解だけでも大変です。
それを、Aiに聞いたら、サンプルコードを出してくれたり、自作したコードを添削してくれたりと、驚きでした。
そこで上の記事を書いてたら、ピ～ンときました。
「そうだ、Fusion APIのパッケージを瞬時に解読できるなら、カスタムマクロなら簡単に解読してくれるかも！」

課題データ

課題NCデータは、以前記事にした、下記ページのデータをそのまま使ってみようと思います

カスタムマクロ、G66モーダル呼び出しで固定サイクルを自作してみる。

前回、カスタムマクロプログラムの例として、ハイデンハインサイクルをマクロ化する例を紹介しました。ハイデンハインサイクルに比べると、ファナック固定サイクルの機能は非常に貧弱ですが、カスタムマクロを自作する事で、無限に拡張する事が可能です。今回は、カスタムマクロのモーダル呼び出し「G66」を利用して、穴...

www.kazuban.com

2022.05.30

穴の面取りを輪郭加工で行うマクロです。
メインプロ「O1000」に加工条件や面取り条件を変数で定義して、G66モーダル呼び出しで「O6000」の面取り加工マクロを呼び出し、指定位置「O6100」で面取りを行うプログラムです
若干変数での計算式もあります。

こちらのファナックマクロを展開してください
%
O1000
( Chamfering Program Ver1.0 By kazuban ) 
G90G00G17G40G80G49 
(++++++++++++++++++++) 
#1=54 (WORK ORIGIN)
#2=10 (Tool Number)
#3=#2 (H Number)
#4=0.5(Tool Diameter)
#5=2300 (Spindle Speed)
#6=200 (Feed)
#7=8 (Coolant)
#8=0.0(Surface Coordinat)
#9=50.0 (Initial Point) 
#10=5.0 (R Point)
(++++++++++++++++++++) 
#11=12.0 (Hole Diameter)
#12=1.0 (Chamfer)
#13=0.5 (Offset)
(++++++++++++++++++++) 
#30=6000 (Macro program No)
#31=6100 (Position program No)
(++++++++++++++++++++) 
N0001
G#1
T#2
M06
G90G00X0Y0 
G43Z[#8+#9]H#3
( Chamfer Process )
S#5M03 
M#7
(----------------------------)
(B:#2=#8 : Surface Coordinat) 
(C:#3=#9 : Initial Point) 
(I:#4=#10 : R Point) 
(J:#5=#12 : Chamfer) 
(K:#6=#13 : Offset)
(D:#7=#4 : Tool Dia)
(E:#8=#11 : Hole Dia)
(F:#9=#6 : Feed)
(++++++++++++++++++++) 
G66 P[#30] B[#8] C[#9] I[#10] J[#12] K[#13] D[#4] E[#11] F[#6]
M98P[#31]
G67
G90G00Z[#8+#9]
M09
M05
G91G28Z0 
G91G49Z0 
G90M05 
( End of Process )
M30
%
%
O6000
( Chamfering Macro Ver1.0 By kazuban ) 
(+++++++++++++++++++)
#1=[#8/2-[#6+#7/2]] (circle radius)
(+++++++++++++++++++)
(B:#2 : Surface Coordinat) 
(C:#3 : Initial Point) 
(I:#4 : R Point) 
(J:#5 : Chamfer) 
(K:#6 : Offset)
(D:#7 : Tool Dia)
(E:#8 : Hole Dia)
(F:#9 : Feed)
(+++++++++++++++++++)
G90G00G17
Z[#2+#3] 
Z[#2+#4] 
G01Z[#2-[#6+#5]]F[#9] 
G91X[#1]
G03X-[#1*2]I-[#1]J0. 
X[#1*2]I[#1]J0.
G01X-[#1] 
G90G00Z[#2+#3] 
M99
%
%
O6100
( Hole Position )
X-35.Y55.
X-50.Y55.
X10.Y10. 
M99
%

このデータをそのまま、「Gemini 2.5 Flash」に突っ込んで、展開をお願いしてみました。

Aiの回答

G66仕様で、G66への変数渡しが「#変数」そのままでないので、作者が見直す時も結構面倒ですが、Aiは瞬時に分析してくれました。

提供されたFANUCマクロプログラムを解析し、その内容を以下に解説します。

---

プログラム全体の概要

このマクロは、複数の穴の面取り加工を自動化するために設計されています。主プログラム (O1000) で加工条件を設定し、マクロプログラム (O6000) で実際の面取り動作を実行、そしてもう一つのプログラム (O6100) で穴の位置情報を呼び出す、という構成になっています。

O1000: 主プログラム

このプログラムは、加工に必要な初期設定と、マクロ呼び出しを行います。

• 初期設定:
  • #1=54 (WORK ORIGIN): ワーク原点の位置を#1に設定。
  • #2=10 (Tool Number): 工具番号を#2に設定。
  • #4=0.5(Tool Diameter): 工具径を#4に設定。
  • #5=2300 (Spindle Speed): 主軸回転速度を#5に設定。
  • #6=200 (Feed): 送り速度を#6に設定。
  • #11=12.0 (Hole Diameter): 穴の直径を#11に設定。
  • #12=1.0 (Chamfer): 面取り量を#12に設定。
  • #13=0.5 (Offset): 工具のオフセット量を#13に設定。
• マクロ呼び出し:
  • G66 P[#30] ...: ここで、面取りマクロプログラムO6000（#30）を呼び出しています。
  • B[#8] C[#9]...: マクロに渡す引数を設定しています。
    • B[#8]: 面取り加工の開始基準となるワーク表面座標。
    • C[#9]: 加工前の待機位置である初期点。
    • I[#10]: 加工開始前の退避点（R点）。
    • J[#12]: 面取り量。
    • K[#13]: オフセット量。
    • D[#4]: 工具径。
    • E[#11]: 穴径。
    • F[#6]: 送り速度。
  • M98 P[#31]: 穴の位置情報を記述したプログラムO6100（#31）を呼び出します。これにより、O6100に記述された各座標で、G66で指定されたマクロが繰り返して実行されます。

O6000: 面取りマクロプログラム

このプログラムは、O1000から渡された情報をもとに、実際の面取り加工を行います。

• 面取り加工の半径計算:
  • #1=[#8/2-[#6+#7/2]]: この式は、面取り加工を行う円弧の半径を計算しています。
    • #8/2: 穴の半径。
    • #6: 面取り量。
    • #7/2: 工具の半径。
    • 結果: 面取り加工する円弧の半径 = (穴の半径) – (面取り量) – (工具の半径)
• 加工シーケンス:
  1. G90G00G17: 絶対指令、早送り、XY平面選択。
  2. Z[#2+#3]、Z[#2+#4]: Z軸を初期点、R点へと移動。
  3. G01Z[#2-[#6+#5]]F[#9]: Z軸を面取り深さまで切り込みながら移動します。
  4. G91X[#1]: ワーク座標を基準に、計算された半径分だけX軸を移動。円弧加工の開始位置に移動します。
  5. G03X-[#1*2]I-[#1]J0.: 半径#1の円弧で、左回りに180度円弧切削。
  6. X[#1*2]I[#1]J0.: さらに、半径#1の円弧で、左回りに180度円弧切削。これにより、1周分の面取り加工が完了します。
  7. G01X-[#1]: 円弧加工の開始位置から中心に戻ります。
  8. G90G00Z[#2+#3]: Z軸を初期点に戻します。
  9. M99: マクロプログラムの終了。主プログラム（O1000）に戻ります。

O6100: 穴位置プログラム

このプログラムは、加工する穴のXY座標をリストアップしています。

• X-35.Y55.: 1つ目の穴の座標。
• X-50.Y55.: 2つ目の穴の座標。
• X10.Y10.: 3つ目の穴の座標。

これらの座標は、O1000のM98 P[#31]によって順番に読み込まれ、それぞれの位置でO6000の面取り加工が実行されます。

---

まとめ

このプログラムは、以下のような処理フローで動作します。

1. 主プログラムO1000がスタートします。
2. 工具交換、初期位置決め、主軸回転、クーラントONなど、準備が完了します。
3. O6100に記述された最初の座標（X-35.Y55.）に移動します。
4. G66によってO6000の面取りマクロが呼び出されます。
5. マクロ内で計算されたパスで、面取り加工が行われます。
6. 面取り加工が完了すると、O1000に戻ります。
7. O6100の次の座標（X-50.Y55.）に移動します。
8. 再びO6000が呼び出され、面取り加工が行われます。
9. この繰り返し処理がO6100の最後まで行われます。
10. 全ての加工が終了すると、クーラントOFF、主軸停止、安全位置への退避が行われ、プログラムが終了します。

この構成は、複数の同じ形状の加工を効率的に行うための、NCプログラミングの典型的な手法です。プログラムを分割することで、位置情報や加工条件の変更が容易になります。

丁寧な解説ですが、加工シーケンス:４．の「ワーク座標を基準」と言うのがちょっと間違っていますね・・
無料版だからでしょうか？
でも、きちんとGコードに展開してくれれば、問題ないですから
再度、一般的なGコードへの展開をお願いすると・・・

%
O1000_EXPANDED
( Chamfering Program Expanded Version )

G90 G00 G17 G40 G80 G49 

( Tool and Spindle Setup )
T10 M06 
G90 G00 X0 Y0 
G43 Z[0.0+50.0] H10
S2300 M03 
M08

( — Hole 1 at X-35. Y55. — )
G90 G00 X-35. Y55.
G00 Z[0.0+50.0]
G00 Z[0.0+5.0]
G01 Z[0.0-[1.0+0.5]] F200
G91 X[12.0/2-[1.0+0.5/2]]
G03 X-[[12.0/2-[1.0+0.5/2]]2] I-[12.0/2-[1.0+0.5/2]] J0. X[[12.0/2-[1.0+0.5/2]]2] I[12.0/2-[1.0+0.5/2]] J0.
G01 X-[12.0/2-[1.0+0.5/2]]
G90 G00 Z[0.0+50.0]

( — Hole 2 at X-50. Y55. — )
・
・
・以下省略

G66呼び出しの部分も、きちんと、展開してくれました。
さらに、[]内で、変数を数値に置き換えた計算式で表現してくれています。
おそらく、[]を認識できるコントローラであれば、このまま動作すると思いますが、トライカットは動作してくれないので、再度、[]内の計算式部分を、実数値に変換をお願いしました。

完成

以下が完成したデータです

%
O1000
( Chamfering Program Expanded Numeric Version )

G90 G00 G17 G40 G80 G49 

( Tool and Spindle Setup )
T10 M06 
G90 G00 X0 Y0 
G43 Z50.0 H10
S2300 M03 
M08

( Chamfering Path Calculation )
( Hole Diameter: 12.0 )
( Chamfer: 1.0 )
( Tool Diameter: 0.5 )
( Offset: 0.5 )
( Radius for cutting: 12.0/2 - 1.0 - 0.5/2 = 6.0 - 1.0 - 0.25 = 4.75 )
( Cutting Depth: 1.0 + 0.5 = 1.5 )

( --- Hole 1 at X-35. Y55. --- )
G90 G00 X-35. Y55.
G00 Z50.0
G00 Z5.0
G01 Z-1.5 F200
G91 X4.75
G03 X-9.5 I-4.75 J0.
X9.5 I4.75 J0.
G01 X-4.75
G90 G00 Z50.0

( --- Hole 2 at X-50. Y55. --- )
G90 G00 X-50. Y55.
G00 Z50.0
G00 Z5.0
G01 Z-1.5 F200
G91 X4.75
G03 X-9.5 I-4.75 J0.
X9.5 I4.75 J0.
G01 X-4.75
G90 G00 Z50.0

( --- Hole 3 at X10. Y10. --- )
G90 G00 X10. Y10.
G00 Z50.0
G00 Z5.0
G01 Z-1.5 F200
G91 X4.75
G03 X-9.5 I-4.75 J0.
X9.5 I4.75 J0.
G01 X-4.75
G90 G00 Z50.0

( End of Program )
M09
M05
G91 G28 Z0
G91 G49 Z0
G90 M05
M30
%

シミュレーション

さっそく、シミュレーションしてみましょう！

正常に動作しました。

まとめ

やっぱり、Aiはすごいです。
座標値を変数で置き換えている程度のマクロであれば、エクセルやスクリプト言語などで、比較的簡単に変換できるかもしれませんが、計算式が入ってくると格段に難易度が上がります。
さらに、G66などのマクロ呼出しになると、引数への変数渡しに癖があるので、PC上での目視確認においても結構面倒です。
以前、マクロの変換ソフトの作成も考えた事もありますが、難易度高くで止めました。
今回のように、Aiに展開してもらえれば、手持ちのシミュレータで動作確認できるので、かなり気軽にマクロに取り組めると思います
それに、今回使用したAiは、「Gemini 2.5flash」で基本無料で利用できます。
ちょっと、間違った回答もありましたが、Fusion API の質問も含めて、制限が出ることはなかったです。「chatGPT」無料版では、制限に引っかかりました。

ところが昨年、AI（生成AI）が大きく注目されるようになり、「これを使ってみるか？」と再び興味がわきました。
試しにFusion向けのコードをAIに聞いてみると、実際に動作するスクリプトを提案してくれて、少しやる気が復活…
しかしそれも一時的で、またもや放置状態に。

話題の『生成Ai』に、Fusion360のPythonスクリプトをきいてみた

最近『生成Ai』を触り始めました。今までの、検索に比べても、非常に便利です。 できる事の幅が広すぎて、ついていけませんが、プログラムコードも出力してくれるようです。 いままで手を付けていなかった、Fusion360のPythonスクリプトを質問してみました。

www.kazuban.com

2024.01.27

そして今回！
AIもさらに進化してきた今こそ、もう一度挑戦してみようと思い立ちました。
本記事では、Fusion360 Python API に再び取り組み始めた記録と、コーディングへのAIの活用事例をレポートしています。
例題として、Fusion APIの基本ライブラリを作成しましたので、利用できそうであれば、利用していただければ幸いです。

なお、より高度なスクリプトや実践的な例に興味がある方は、「Kantoku」さんのサイトに素晴らしい資料が公開されていますので、ぜひチェックしてみてください。

今回の目標：スケッチ関連の基本ライブラリを作る

Python言語は、ほとんど初心者ですが、ネット情報やAiを参考にコードをコピペするだけでは、なかなか覚えられないと思っています。
そこで、基本的なコードをライブラリ化する事で、少しは理解も深まるかと思い、まずはスケッチ周りの基本コードをライブラリ化してみようと思います

Aiの実力を試してみる

さっそく、何種類かのLLMに質問してみました。

fusionのpython API で直線を引くコード

ローカルLLM

ローカルの場合、私の環境では、レスポンス的に30bぐらいが実用できる限界です。
そこで、「gemma-3-27b」「qwen3-32b」で試してみます

「fusionのpython API で直線を引くコードをだして」

最初に、「import adsk.core, adsk.fusion, traceback」などFusion特有のパッケージをインポートしするコードを出してくれるので、なかなかいいな！と思っていましたが、実際にFusionで実行してみても正常動作しませんでした。
特に、CAD画面上にメッセージを出力する場合、「ui.messageBox」を利用しますが、一般的なpythonの「print」文を使ったりしています。
また、私の環境で30bクラスのLLMでは、回答に５分以上かかりました。
文章をまとめたり、翻訳したりの場合では、8bクラスでもいい回答をもらえますが、Fusion API のPython場合はちょっとマイナーなのかもしれません
参考にはなると思いますが、私の環境ではちょっとレスポンスが悪いです。

オンラインLLM

次に、オンラインの「chatGPT」と「gemini」で試してみました。
「chatGPT」も「gemini」も、正常に動作しました。
ただし、ログインしないと、会話履歴や共有できないので、ログインしたほうがいいと思います。
制限がある場合がありますが、そこそこ無料利用できます。
やはり、さすがです。回答レスポンスも早いです。
今回の質問では、一年前に、出してくれたコードとほとんど同じコードをだしてくれました。
一年前は、「bard(gemini)」のコードは、正常動作しないコードでしたが、現在の「gemini」は問題ないコードを出してくれます。
個人的は、ローカルLLMを使いたい気持ちがあるのですが、開発作業では、やはりレスポンスは重要なので、今後の学習はオンラインLLMを利用しようと思います。
まずは「Gemini 2.5Flash」を利用してみて、いい回答が出なかった場合には、「chatGPT」や「Gemini 2.5Pro」を使おうと思います

コンポネントやスケッチのアクティブな状態を把握

上記の直線を描くサンプルコードでは、ルートコンポネントに新しいスケッチを作成し、そのスケッチに直線を引いています。
もう少し、実践的な動作にしたいです。

• スケッチモードであれば、そのスケッチに・・
• スケッチモードでない場合、ルートにこだわらず、アクティブなコンポネントに新しいスケッチを作成しそのスケッチに・・

これを実現させるには、まず現状のアクティヴな状態を把握する必要があります
アクティブなコンポーネントを見つける関数はすぐ見つかりましたが、スケッチのモード判定方法はなかなか見つからずAiのお陰でどうにかなりそうです。
こういった汎用的だけど苦労した処理を、ライブラリ化しておくと、後々便利だと思います

現状がスケッチモードかどうかの判定

何度かgemini に聞いてみたところ、「activeEditObject」「activeEnvironment」を使用する方法があるとの回答をもらいました。
ただし、Ai としては、「activeEditObject」を推奨するとの事でした

import adsk.core
import adsk.fusion

def is_sketch_mode_active():
    """
    現在スケッチモード（いずれかのスケッチが編集中）かどうかを判定します。

    Returns:
        bool: スケッチモードであれば True、そうでなければ False。
        adsk.fusion.Sketch: アクティブなスケッチオブジェクト（スケッチモードの場合）。
    """
    try:
        app = adsk.core.Application.get()
        
        # 現在編集中のオブジェクトを取得
        active_object = app.activeEditObject

        # 編集中のオブジェクトがスケッチ（Sketch）であるかを確認
        if active_object and isinstance(active_object, adsk.fusion.Sketch):
            return True, active_object
        else:
            return False, None

    except:
        return False, None

# --- 実行例 ---
def run(context):
    ui = None
    try:
        app = adsk.core.Application.get()
        ui = app.userInterface

        is_active, active_sketch = is_sketch_mode_active()

        if is_active:
            ui.messageBox(f'はい、現在スケッチモードです。\nアクティブなスケッチ: {active_sketch.name}')
        else:
            ui.messageBox('いいえ、現在スケッチモードではありません。')

    except:
        if ui:
            ui.messageBox('エラーが発生しました。')

判定で、「isinstance()」関数を使っています。
これは、自力では、なかなか探せなかったと思います。恐るべし、Aiです。

python特有な構文

Aiが出してくれた、サンプルコードを見ると、C言語とは違う書き方が結構出てきます
例えば

return True , active_object

のように、複数変数を返す事ができて、取り出しは、下記のように「,」で区切って利用できるのですね

is_active , active_sketch = is_sketch_mode_active()

C++言語では、最近ではstd::tupleが利用できるみたいですが、それを知らない私は、classを使ったりしていますが、こちらのほうが、面倒ないですね。
「if文」も「三項演算子」と呼ばれている構文が結構使われていました。

design = get_design()
return design.activeComponent if design else None

C言語にも「三項演算子」はありますが、if文のほうが、分かりやすいかも・・
配列系も、多種類があるようで、Aiが出してくれたサンプルでも結構多用しています

plane = plane.lower()
planes_map = {
    "xy": component.xYConstructionPlane,
    "xz": component.xZConstructionPlane,
    "yz": component.yZConstructionPlane
}   
base_plane = planes_map.get(plane)

この「.get(plane)」はなんだ？
と思いましたが、これもAiに聞くと、すぐに説明してくれました。
planes_map[plane]でもアクセスできるようですが、get()を使うとplaneが存在しない場合安全にデフォルト値（Noneまたは指定した値）を返してくれるようです。
本当にすぐに教えてくれるので、私のような独学の場合、参考書などをめくるよりも、言語の理解は数段速くなるでしょうね～

Fusion スクリプトをライブラリ化する

Fusion では、「ユーティリティ」⇒「アドイン」⇒「スクリプトとアドイン」⇒「+」で新規にスクリプトを作成できます

このダイアログの「フォルダの場所」に「名前」に入力のフォルダを作成し、その中に「名前.py」で実行スクリプトが作成されます。
「フォルダの場所」はデフォルトでは、かなり深いので、私は「D:\Fusion360\Scripts」のようにシンプルな場所に変更しています。
また、この場所は、「基本設定」⇒「一般」⇒「API」でデフォルトを変更できます
ただし、ここでの設定箇所に「Scripts」は自動作成されるので、「D:\Fusion360」になります

Fusionスクリプトは、Fusionオブジェクトモデルを介して、利用したいオブジェクトのコマンドを記述します。
したがって、スクリプトを作成するには、各オブジェクトの情報が必要となり、かなり複雑です。

今回は、Pythonの学習も兼ねて、Fusionのスケッチ関連オブジェクトをカプセル化したライブラリを作成したいと思います。

ライブラリの登録場所とpythonでの実装方法

ライブラリフォルダは、Fusionが自動作成する、「Scripts」内の自作スクリプトと同じレベルに登録したいと思います

D:\Fusion360\Scripts
├── 新規スクリプト
├── CenterLine # 自作スクリプト
│ └── CenterLine.py # X,Y,Zの軸のセンターラインを作成する
│
├── library # 作成ライブラリ登録フォルダ
│ ├── _init_.py # 空ファイル（必要らしい）
│ ├── lib_util.py # Component & Sketch 関連関数
│ └── lib_2d.py # 点や直線を作成（今後、円、円弧なども追加予定）

私の環境では、このようなイメージです。
「library」フォルダ内に「lib_util.py」「lib_2d.py」スクリプトを作成
「lib_util.py」は、Component や sketch を提供する基本関数を記述します
「lib_2d.py」は、点や直線を扱う関数を作成しますが、「lib_util.py」の関数も利用します
今回はこの二つのライブラリを利用して、 X,Y,Zの軸のセンターラインを作成する「CenterLine /CenterLine.py」スクリプトを作成します

実行スクリプトと同じレベルのスクリプトをインポートするには？

インポートするコードもわからないので、さっそくAiに聞いてみました
上記の構造をAiに渡して、実行スクリプト「CenterLine.py」から「lib_util.py」の関数を利用するコードを聞いてみました
この場合、正確なディレクトリ構造を取得する事が必要だと言うことで下記コードを教えてもらいました。

current_dir = os.path.dirname(os.path.abspath(__file__))
script_dir = os.path.dirname(current_dir)

この構成はよくライブラリや設定ファイルを相対パスで読み込むときの定番のコードのようです
もう少し、詳しく説明してもらいました。

_file_：現在実行中のPythonスクリプトのファイルパス
os.path.abspath(__file__)：絶対パスに変換
os.path.dirname(…)：そのファイルが属するディレクトリを取得

D:/Fusion360/Scripts/
├── library/
│ └── __init__.py # モジュールの初期化用
│ └── lib_util.py
│ └── lib_2d.py
├── CenterLine/
│ └── CenterLine.py ← 実行スクリプト

__file__ → “./CenterLine/CenterLine.py”
abspath(__file__) → “D:/Fusion360/Scripts/library/CenterLine/CenterLine.py”
current_dir → “D:/Fusion360/Scripts/library/CenterLine”
script_dir → “D:/Fusion360/Scripts/library”

このコードで、ライブラリのディレクトリを取り出し、
「sys.path.append(script_dir)」でpythonが内部でモジュール検索時に、指定ディレクトリを追加するの意味のようです
この設定後に、「from library import lib_util」コードで「library」ディレクトリ内の「lib_util.py」内の関数を使用できるようになります
具体的には、下記になります

import os, sys

current_dir = os.path.dirname(os.path.abspath(__file__))
script_dir = os.path.dirname(current_dir)
sys.path.append(script_dir)
from library import lib_util

これで、新規作成したスクリプトに、このコードを追加すると、「lib_util」内の関数が使えます
さらに「lib_2d.py」ライブラリも、「lib_util.py」の関数も利用しますが、こちらは、「lib_util.py」と同じディレクトリ内なので、「script_dir = os.path.dirname(current_dir)」のコードは不要になりますね

import os, sys
current_dir = os.path.dirname(os.path.abspath(__file__))
# script_dir = os.path.dirname(current_dir)
sys.path.append(current_dir)
import lib_util

実際には結構時間がかかったのですが、これで、やっとライブラリが使えるようになりました。
本当、Ai様様です。
Aiの進歩で、コーディングの勉強は不要だとの意見もありますが、やっぱりコードの意味の理解は必要だと思います。
たぶん、Aiもそう思っているのでしょう！詳しいコメントを日本語で追記してくれます。
「あなたの言葉でコメントつけるから、覚えてね！」と言ってる気がします。
Ai利用でプログラミングの学習速度は、以前よりも圧倒的に速くなると思います

ライブラリ利用方法

./Scripts/
├── 新規スクリプト/ # <——– Fusion ダイアログで作成
│ └── 新規スクリプト.py
├── library/ #<——— Scripts/ 直下に作成
│ └── __init__.py # <—– 空ファイル追加作成、モジュールの初期化用
│ └── lib_util.py # <——- ライブラリファイル
│ └── lib_2d.py # <——- ライブラリファイル
└── CenterLine/ # <——- 自作スクリプト用
│ └── CenterLine.py # <——- 自作スクリプトファイル
└───────

イメージ的には、このようになります。
Fusionで「スクリプトまたはアドイン作成」を実行すると、設定ダイアログが表示され、設定した「フォルダの場所」へ設定した名前のフォルダが自動作成され、さらにその中に、設定した名前.py の実行ファイルが作成されます。

今回紹介のライブラリは、Fusionで設定した「フォルダの場所」の直下に「library」の名前でフォルダを作成し、さらに「library」の直下に、「__init__.py」「lib_util.py」「lib_2d.py」を作成します
「__init__.py」は、空ファイルですが、Aiが言うには、ライブラリを利用する際必要みたいです。
「lib_util.py」「lib_2d.py」も一旦空ファイルを作っておいて、下記コードをコピペして保存します

ライブラリを利用して、X,Y,Zの座標軸にセンターラインを描く

まずは、Fusion 「スクリプトとアドイン」で、新規スクリプトを作成します
ここでは「CenterLine」という名前にしました。
これで、「./Scripts」ディレクトリ内に、「CenterLine/CenterLine.py」が作成されています。
CenterLine.pyファイルの内容を、下記コードで上書きして保存します

CenterLine.py

"""This file acts as the main module for this script."""

import traceback
import adsk.core
import adsk.fusion
# import adsk.cam

import os, sys, importlib
#library import
current_dir = os.path.dirname(os.path.abspath(__file__))
script_dir = os.path.dirname(current_dir)
sys.path.append(script_dir)
from library import lib_util,lib_2d

def run(context):
    try:
        lib_2d.draw_center_line(100,100,100)
 
    except:
        lib_util.disp_message('Failed:\n{}'.format(traceback.format_exc()))

下記が、ライブラリ用スクリプトファイルです

lib_util.py

import adsk.core, adsk.fusion, adsk.cam, traceback
from typing import Tuple, Optional

#このライブラリは
#Fusionが作成するスクリプトと同じディレクトリに置かれる事を想定している
#使用する場合には、下記コードにより読み込みパスを追加する
"""
import os, sys, importlib
current_dir = os.path.dirname(os.path.abspath(__file__))
script_dir = os.path.dirname(current_dir)
sys.path.append(script_dir)
from library import lib_util
"""
# ---------------------
## Get Fusion object
# ---------------------
def get_app():
    return adsk.core.Application.get()
def get_design():
    app = get_app() 
    return adsk.fusion.Design.cast(app.activeProduct)
def get_ui():
    app = get_app() 
    return app.userInterface

# ---------------------
## メッセージ表示
# ---------------------
def disp_message(msg: str):
    """ユーザーにメッセージボックスを表示"""
    ui = get_ui()
    if ui:
        ui.messageBox(msg)

# ---------------------
## Component & Sketch Functions
# ---------------------
# /////////////////////////////////////////////////////////////
def get_root_component() -> Optional[adsk.fusion.Component]:
    """ルートコンポーネントを返す"""
    design = get_design()
    return design.rootComponent if design else None

# /////////////////////////////////////////////////////////////
def get_active_component() -> Optional[adsk.fusion.Component]:
    """現在アクティブなコンポーネントを返す"""
    design = get_design()
    return design.activeComponent if design else None

# /////////////////////////////////////////////////////////////
def create_new_component(name: str = 'New_Component') -> Optional[adsk.fusion.Component]:
    """新しいコンポーネントを作成し、アクティブなコンポーネントの配下に追加"""
    component = get_active_component()
    if not component:
        component = get_root_component()
    
    if not component:
        disp_message('コンポーネントが見つかりません。デザインがアクティブか確認してください。')
        return None
    
    try:
        occurrences = component.occurrences
        new_occurrence = occurrences.addNewComponent(adsk.core.Matrix3D.create())
        new_component = new_occurrence.component
        new_component.name = name
        return new_component
    except Exception:
        disp_message(f'新しいコンポーネントの作成に失敗しました:\n{traceback.format_exc()}')
        return None

# /////////////////////////////////////////////////////////////
def get_parent_sketch(obj: any) -> Optional[adsk.fusion.Sketch]:
    """指定されたオブジェクトの親スケッチを取得"""
    return obj.parentSketch if hasattr(obj, 'parentSketch') else None

# /////////////////////////////////////////////////////////////
def create_new_sketch(name: str = 'New_Sketch', plane: str = 'xy') -> Optional[adsk.fusion.Sketch]:
    """指定された平面に新しいスケッチを作成"""
    component = get_active_component()
    if not component:
        component = get_root_component()
    
    if not component:
        disp_message('スケッチを作成するコンポーネントが見つかりません。')
        return None
    
    plane = plane.lower()
    planes_map = {
        "xy": component.xYConstructionPlane,
        "xz": component.xZConstructionPlane,
        "yz": component.yZConstructionPlane
    }
    
    base_plane = planes_map.get(plane)
    if not base_plane:
        disp_message(f"サポートされていない平面: '{plane}' 'xy', 'xz', 'yz' のいずれかを選択してください。")
        return None
        
    try:
        sketches = component.sketches
        sketch = sketches.add(base_plane)
        sketch.name = name
        return sketch
    except Exception:
        disp_message(f'新しいスケッチの作成に失敗しました:\n{traceback.format_exc()}')
        return None

# /////////////////////////////////////////////////////////////
def is_sketch_mode_active() -> Tuple[bool, Optional[adsk.fusion.Sketch]]:
    """現在スケッチモードがアクティブであるかを確認し、スケッチオブジェクトを返す"""
    app = get_app()
    active_object = app.activeEditObject
    # is_instance() を使うことで、より安全に型チェックを行う
    if isinstance(active_object, adsk.fusion.Sketch):
        return True, active_object
    else:
        return False, None

# /////////////////////////////////////////////////////////////
def get_sketch() -> Optional[adsk.fusion.Sketch]:
    """アクティブなスケッチを返す、アクティブでない場合は新しいスケッチを作成"""
    is_active, sketch = is_sketch_mode_active()
    if not is_active:
        sketch = create_new_sketch()
    return sketch

lib_2d.py

import adsk.core, adsk.fusion, adsk.cam, traceback
from typing import Tuple, Optional

# 利用するlib_utilは、このライブラリと同じディレクトリ
import os, sys, importlib
current_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.append(current_dir)
import lib_util

# ---------------------
## カスタム、点基本クラス
# ---------------------
# /////////////////////////////////////////////////////////////
class kPoint:
    """3D空間の点を表す基本クラス"""
    def __init__(self, x: float, y: float, z: float = 0.0):
        self.x = x
        self.y = y
        self.z = z

# ---------------------
## カスタム、スケッチ点クラス
# ---------------------
# /////////////////////////////////////////////////////////////
class kSketchPoint(kPoint):
    """Fusion 360 のスケッチ点として使用される座標を、単位とスケッチ平面に応じて変換するクラス"""
    def __init__(self, x: float = 0.0, y: float = 0.0, z: float = 0.0, sketch: Optional[adsk.fusion.Sketch] = None, unit: str = "mm"):
        unit = unit.lower()
        # 単位変換係数を辞書で管理
        scale_factors = {"mm": 0.1, "cm": 1.0, "m": 10.0}
        scale = scale_factors.get(unit, 1.0) # 存在しない単位は1.0 (cm) を使用

        if not sketch:
            sketch = lib_util.get_sketch() # スケッチが指定されていなければ、アクティブなスケッチを取得

        # スケッチ平面に応じて座標系を調整 (XZ平面はY軸が下向き)
        # 参照平面が'XZ'の場合は、y座標を反転させる
        # これはFusion 360の座標系の癖に対応
        direction_y = -1.0 if sketch and sketch.referencePlane.name == "XZ" else 1.0
        
        # 単位と座標系による方向を調整
        converted_x = x * scale
        converted_y = y * scale * direction_y
        converted_z = z * scale
        
        super().__init__(converted_x, converted_y, converted_z)
        self.sketch = sketch
        self.unit = unit
        
# ---------------------
## Sketch Geometry Creation Functions
# ---------------------
# /////////////////////////////////////////////////////////////
def is_equal_sketch_points(sp1: adsk.fusion.SketchPoint, sp2: adsk.fusion.SketchPoint, tolerance: float = 0.0001) -> bool:
    """2つのスケッチ点が指定された許容差内で同じ位置にあるかどうかを判断"""
    # ジオメトリオブジェクトの距離を比較
    distance = sp1.geometry.distanceTo(sp2.geometry)
    return distance < tolerance

# /////////////////////////////////////////////////////////////
def create_sketch_point(x: float = 0, y: float = 0, z: float = 0, sketch: Optional[adsk.fusion.Sketch] = None) -> Optional[adsk.fusion.SketchPoint]:
    """指定された座標にスケッチ点を作成"""
    if not sketch:
        sketch = lib_util.get_sketch()
    
    if not sketch:
        lib_util.disp_message('スケッチがアクティブでないか、新しいスケッチの作成に失敗しました。')
        return None
        
    try:
        # kSketchPoint を使用して単位と平面を考慮した座標を取得
        converted_point = kSketchPoint(x, y, z, sketch)
        # adsk.core.Point3D オブジェクトを作成
        point3d = adsk.core.Point3D.create(converted_point.x, converted_point.y, converted_point.z)
        # スケッチに点を追加
        sketchPoint = sketch.sketchPoints.add(point3d)
        return sketchPoint
    except Exception:
        lib_util.disp_message(f'スケッチ点の作成に失敗しました:\n{traceback.format_exc()}')
        return None

# /////////////////////////////////////////////////////////////
def create_line_from_sketchpoints(sp1: adsk.fusion.SketchPoint, sp2: adsk.fusion.SketchPoint, construction: bool = False, fixed: bool = False) -> Optional[adsk.fusion.SketchLine]:
    """2つの既存のスケッチ点から直線を作成"""
    # 同じスケッチに属しているかチェック
    if lib_util.get_parent_sketch(sp1) != lib_util.get_parent_sketch(sp2):
        lib_util.disp_message('2つの点は異なるスケッチに属しています。')
        return None
        
    # 2つの点が同じ位置にあるかチェック
    if is_equal_sketch_points(sp1, sp2):
        lib_util.disp_message('2つの点が同じ位置にあります。直線を作成できません。')
        return None
        
    sketch = lib_util.get_parent_sketch(sp1)
    if not sketch:
        lib_util.disp_message('親スケッチが見つかりません。')
        return None
        
    try:
        line = sketch.sketchCurves.sketchLines.addByTwoPoints(sp1, sp2)
        line.isConstruction = construction
        line.isFixed = fixed
        return line
    except Exception:
        lib_util.disp_message(f'直線（スケッチ点から）の作成に失敗しました:\n{traceback.format_exc()}')
        return None

# /////////////////////////////////////////////////////////////
def create_line_from_coordinate(x1: float, y1: float, z1: float, x2: float, y2: float, z2: float, sketch: Optional[adsk.fusion.Sketch] = None, construction: bool = False, fixed: bool = False) -> Optional[adsk.fusion.SketchLine]:
    """座標から直接、スケッチ直線を作成"""
    if not sketch:
        sketch = lib_util.get_sketch()

    if not sketch:
        return None

    # ヘルパー関数を利用して点を先に作成
    p1 = create_sketch_point(x1, y1, z1, sketch)
    p2 = create_sketch_point(x2, y2, z2, sketch)
    
    if p1 and p2:
        return create_line_from_sketchpoints(p1, p2, construction, fixed)
    else:
        lib_util.disp_message('直線を作成するための点の作成に失敗しました。')
        return None

# /////////////////////////////////////////////////////////////
def create_line_from_points(p1: kPoint, p2: kPoint, sketch: Optional[adsk.fusion.Sketch] = None, construction: bool = False, fixed: bool = False) -> Optional[adsk.fusion.SketchLine]:
    """カスタム `kPoint` オブジェクトからスケッチ直線を作成"""
    if not sketch:
        sketch = lib_util.get_sketch()
    
    if not sketch:
        return None
        
    return create_line_from_coordinate(p1.x, p1.y, p1.z, p2.x, p2.y, p2.z, sketch, construction, fixed)

# /////////////////////////////////////////////////////////////
def draw_center_line(widthX=100,widthY=100,widthZ=100):
    """センターライン作成"""
    widthX = 100 if widthX == 0 else widthX
    widthY = 100 if widthY == 0 else widthY
    widthZ = 100 if widthZ == 0 else widthZ
    wx=widthX/2
    wy=widthY/2
    wz=widthZ/2
    sketch = lib_util.get_sketch()
    xp1 = kPoint(-wx,0)
    xp2 = kPoint(wx,0)
    yp1 = kPoint(0,-wy)
    yp2 = kPoint(0,wy)
    zp1 = kPoint(0,0,-wz)
    zp2 = kPoint(0,0,wz)
    create_line_from_points(xp1,xp2,sketch,True,True) #X Axis
    create_line_from_points(yp1,yp2,sketch,True,True) #Y Axis
    create_line_from_points(zp1,zp2,sketch,True,True) #Z Axis

注意点

実は、まだ解決できていない注意点があります
通常のライブラリ使用では問題ないと思いますが、Fusionでライブラリを利用したスクリプトを実行後、ライブラリ内スクリプトを編集しても、編集内容が反映されません。
Aiに聞いてみると、Fusionの仕様でキャッシュが優先されているとの事です
キャッシュクリアのコードも教えてもらいましたが、現状では反映されません。
ライブラリの編集を反映させるには、Fusionを再起動させるとキャッシュがクリアされ反映されます
ライブラリを試行錯誤している場合でも、ちょっと面倒です。
いい方法は、ないのかなぁ～？？

まとめ

pythonはド素人なので、勉強もかねて、Ai にコーディングを教えてもらいながら、FusionのComponentやsketch、直線作成などの関数をライブラリ化してみました。
Fusionオブジェクトモデルは、広範囲で奥が深いので、探すのも大変です。
よく使いそうな関数を、まとめたので、少しは取り組みやすくなるのではないか？と思っています。
今後も進化させようと思っていますが、Aiがなかったら、ここまで完成できなかったと思います。
ここで紹介しているコードも、一旦自分なりに作成したスクリプトを、Aiに張り付けて、添削してもらったコードを再編集したものです。
関数名やコメントの書き方なども、pythonの慣習を教えてもらい参考にしています

Difyをクローン化

gitの確認

difyをクローン化するのに、「git」を利用するので、「git」のインストール状況を確認します。
windows ターミナルを開き、wsl を起動し、「git -v」で状況を確認します。

PS C:\Users\hogehoge2> wsl

$ git -v
git version 2.43.0
インストールされていない場合には、インストール
$ sudo apt update
$ sudo apt install git

Gitでdifyをクローン化する

「git clone ・・」でクローン化を実行すると、カレントディレクト下「dify」ディレクトリへソースコードがクローン化されます。
windowsターミナルで、「wsl」を実行し、ubuntu環境へ入ると、デフォルトでは、winndowsユーザーのディレクトリへセットされた状態で起動します。
好みの問題だと思いますが、この場所へ「dify」環境を作成してもいいと思いますが、筆者はubuntuのユーザーホームディレクトリ下に作成しようと思います。
wsl、ubuntuプロンプトで、「cd」を実行すると、ユーザーのホームディレクトリへ移動します。
その場所で「git clone・・」すると、そのディレクトリ直下に「dify」さらにその下に「docker」ディレクトリが作成されています。
「ls」コマンドで確認できます。
「dify/docker」ディレクトリへ「cd」コマンドで移動しておきます。
「pwd」コマンドで、現在のディレクトリが確認できます。

hogehoge2@hoge-PC:/mnt/c/Users/hogehoge2$
$ cd
$ git clone https://github.com/langgenius/dify.git
Cloning into 'dify'...
remote: Enumerating objects: 153846, done.
remote: Counting objects: 100% (536/536), done.
remote: Compressing objects: 100% (359/359), done.
remote: Total 153846 (delta 396), reused 178 (delta 177), pack-reused 153310 (from 3)
Receiving objects: 100% (153846/153846), 87.73 MiB | 5.07 MiB/s, done.
Resolving deltas: 100% (111131/111131), done.
$ ls
dify
$ cd dify/docker/
$ pwd
/home/hogehoge2/dify/docker

Difyコンテナ起動

「git clone」を実行したディレクトリに、「dify/docker」ディレクトリが作成されています。
その中に「.env.example」のサンプル環境変数ファイルが作成されています。
通常ファイルは「ls」コマンドで確認できますが。「.」で始まるファイルは表示されません。
その場合「ls -la」コマンドを実行すると、表示されます。
コピーは「cp <オリジナルファイル名>　<複写ファイル名>」で複写できます。
「.env.example」ファイルを、正式な環境変数「.env」としてコピーし、「docker compose」コマンドで、コンテナを起動させます。

$ pwd
/home/hogehoge2/dify/docker
$ cp .env.example .env
$ docker compose up -d
[+] Running 80/80    
✔ web Pulled             149.7s
✔ sandbox Pulled         221.1s
 ✔ ssrf_proxy Pulled      88.2s
 ✔ db Pulled             224.4s
 ✔ worker Pulled         402.2s
 ✔ plugin_daemon Pulled  404.6s
 ✔ nginx Pulled           36.4s
 ✔ weaviate Pulled       225.1s
 ✔ redis Pulled          221.2s
 ✔ api Pulled            402.2s
[+] Running 12/12
 ✔ Network docker_default             Created    0.1s
 ✔ Network docker_ssrf_proxy_network  Created    0.0s
 ✔ Container docker-web-1             Started    3.7s
 ✔ Container docker-ssrf_proxy-1      Started    4.0s
 ✔ Container docker-sandbox-1         Started    3.7s
 ✔ Container docker-redis-1           Started    3.7s
 ✔ Container docker-weaviate-1        Started    3.7s
 ✔ Container docker-db-1              Healthy    10.7s
 ✔ Container docker-worker-1          Started    9.3s
 ✔ Container docker-plugin_daemon-1   Started    9.3s
 ✔ Container docker-api-1             Started    9.5s
 ✔ Container docker-nginx-1           Started    10.0s

docker compose upでエラー発生！AIに聞いてみる。

上記は正常な例ですが、古いPCをテストマシンとして利用した時、「docker compose up」で下記エラーがでた事がありました。

dependency failed to start: container docker-db-1 is unhealthy

この時もgeminiに聞いてみたところ、「docker logs docker-db-1」でログを確認してくれとの事なので、ログを直接貼り付けると、

Ai

ログを見る限り、データベースの初期化自体は正常に完了しています (PostgreSQL init process complete; ready for start up.)。 その後の起動プロセスも進んでいますが、2025-04-29 00:02:07.998 UTC [557] FATAL: the database system is starting up という致命的なエラーが出力されています。

このエラーは、PostgreSQLサーバーが起動してリカバリなどの内部処理を行っている最中に、外部からの接続要求（この場合はおそらくDockerのヘルスチェックや、依存するDifyコンテナからの初期接続試行）があった場合に発生することがあります。

つまり、データベースサーバー自体は最終的に database system is ready to accept connections の状態になりますが、Dockerのヘルスチェックがサーバーの準備が完全に整う前に接続を試み、上記の FATAL エラーを受け取ってしまい、それが原因でコンテナが unhealthy と判定されている可能性が高いです。

解決策:

Dockerのヘルスチェック設定を調整し、データベースが完全に起動して接続可能になるまで、チェックを待つように設定を変更するのが最も有効な対策です。

データベースサービス (db または postgresql) の healthcheck 設定を見つける:
services のセクションにある、データベースコンテナに対応するサービス定義（通常は db という名前）を探します。その中に healthcheck というブロックがあるはずです。

YAML
services:

db: # ... その他の設定 ...
healthcheck: # ここに設定があります
　　・
test: ["CMD-EXEC", "pg_isready -U <db_user> -d <db_name>"] # 例
interval: 10s
timeout: 5s
retries: 5
start_period: 30s # <-- この値を調整します

docker-compose.yml を開く: Difyを起動するために使用している docker-compose.yml ファイルをテキストエディタで開きます。

じじぃ

docker-compose.yamlを確認した所、「start_period:」の設定がありません。

Ai

start_period が指定されていない場合、コンテナが起動を開始すると同時にヘルスチェックが始まります。今回のデータベースのログで見たように、起動直後の一時的な準備期間中に接続を試みると FATAL: the database system is starting up のようなエラーが発生することがあります。

interval: 1s と非常に短い間隔でチェックが実行されるため、データベースが完全に準備できる前に多くのチェックが走ってしまい、すぐにリトライ回数（retries: 60）を使い果たして unhealthy と判定されてしまう可能性が高いです。

解決策:

start_period を追加し、必要に応じて interval も調整しましょう。

1. healthcheck 設定に start_period を追加する: データベースが起動して準備ができるまでの猶予期間として、start_period を設定します。
   例えば 30s または 60s (30秒または60秒) を指定します。
   YAML
   services:
db: # ... その他の設定 ...

healthcheck:
test: [ 'CMD', 'pg_isready', '-h', 'db', '-U', '${PGUSER:-postgres}', '-d', '${POSTGRES_DB:-dify}' ]
interval: 5s # 例: 毎秒ではなく5秒ごとにチェックに緩和
timeout: 3s
retries: 10 # 例: リトライ回数を調整 (intervalを長くすればretriesは少なくても良い)
start_period: 60s # <- この行を追加 (例: 60秒待つ)
   
   ポイント: start_period の間は、ヘルスチェックが失敗してもコンテナは starting 状態のままとなり、unhealthy とは判定されません。start_period が経過した後に初めて、ヘルスチェックの失敗が unhealthy の判定に使われます。
2. interval も少し長めにすることをお勧めします: interval: 1s は開発時などに素早く確認したい場合には便利ですが、本番に近い環境や安定性を重視する場合は 5s や 10s に設定することが一般的です。これにより、データベースへの不要な負荷も軽減されます。
3. docker-compose.yml を保存する。
4. Docker Compose を再起動する: 変更を反映させるために、コンテナを再作成して起動します。

アドバイス通りに、編集して再度「docker compose up -d」を実行すると、正常になりました。
いやぁ～、AIさまさま、ですね～
おそらく、ネット検索では、解決できなかったと思います。
ただし、古いPCだったのが、一番の原因かもしれません。
５年ほど前のPCでは、このエラーはでなかったので、レアなケースかもしれませんが、AIの利用例として紹介しました。

Dify起動

初期画面

「docker compose up」が正常に終了すると、Webブラウザで「http://localhost/install」へアクセスすると「dify」の初期設定が開きます

Difyの動作と試用

とりあえず、起動しました。
以前このサイトでも説明していますが、簡単なチャットボットを作成し試してみます。
LLMモデルはオンラインの「gemini」を登録し、動作を確認できました。
オンラインであれば、「LM Studio」や「Ollama」など、ローカルLLMを利用するアプリは必要ないので、すぐに確認できます。

Difyを自動起動

Difyを動作させるには、Dockerが起動していなくてはいけません。
それには、WSL上で、ubuntuも起動している必要があります。
手動でやる場合、

・windowsターミナル起動
・wslコマンドで、ubuntuターミナル起動
・ubuntuターミナルでカレントディレクトリを、Difyのクローンディレクトリに移動
・「docker compose up -d」 コマンド実行

このような手順が必要ですが、問題なのは、ターミナルを閉じるとdockerも終了してしまうことです
Difyを使うには、dockerが起動していなくてはいけません。
windowsアプリの「docker desktop」であれば、標準で自動起動設定だったと思いますし、起動後もシステムトレイのアイコンで起動が確認できます。右ボタンで状態確認や終了も簡単です。
ubuntu経由の場合には、GUIでの確認ができないので、ここが面倒なところですね～。
自動起動方法をいろいろ調べると、windowsバッチファイルを作成し、スタートアップフォルダに登録する事で、windows起動時に、自動起動できそうです。
ただ、
「コマンドプロンプト　⇒　ubuntuターミナル　⇒　docker」
のタスクが必要で、ターミナルは開いた状態にしておく必要があります。
このようなバッチファイルを作りたいですが、どんなコードにすればいいのか・・？
うまいコードを考え付かなかったので、difyの試しもかねて起動しているチャットボットで設定しているgeminiに考えてもらいました。

@echo off
title Starting Dify via WSL

echo Starting WSL and navigating to ~/dify/docker...
echo Running 'docker compose up -d'...
echo WSL window will remain open after commands.

REM WSLを起動し、bashシェル内でコマンドを実行します。
REM cd ~          : ホームディレクトリに移動 (念のため)
REM cd ./dify/docker : dify/docker ディレクトリに移動
REM docker compose up -d : docker compose をバックグラウンドで起動
REM exec bash     : 上記コマンド実行後、インタラクティブなbashシェルを開始して終了させない
wsl.exe -e bash -c "cd ~/dify/docker && docker compose up -d && echo '--- Dify containers started (or attempted to start) ---' && exec bash"

echo WSL window launched. This batch window can be closed if desired.
REM pause REM Optionally uncomment this line to keep the batch window open until a key is pressed

すごいです。
ほとんど実際の起動には影響がない「REM」や「echo」文がほとんどですが、
「REM」文を使っての説明文や、「echo」での実行中のメッセージにも手抜きがないですね！
このコードをコピーしてエディターで、「start_dify.bat」というファイルで保存しました。
バッチファイルの単独実行では問題ありませんでした。
後はこのファイルのショートカットを、スタートアップフォルダへコピーするだけです。

・上記の作成したバッチファイルを、適当は場所へ保存します
　私は、ユーザーフォルダ「C:\Users\「ユーザー」」へ保存しました。
・次に、このファイルのショートカットを作成します。
・このショートカットを「スタートアップフォルダ」へ保存します。
　スタートアップフォルダは、エクスプローラーのアドレスバーへ「shell:startup」と入力すると開くことができます。

特に必須ではないですが、ターミナルは起動状態にさせるので邪魔になる場合、作成したショートカットファイルを、マウス右ボタンで「プロパティ」を開きます。
「プロパティ」の「ショートカット」タブの「実行時の大きさ」を「最小化」に設定すると、起動時にタスクバーに最小化状態で起動できます。

これで、再起動すると、自動起動したターミナルはタスクバーへ最小化状態ですが、環境によっては起動途中の場合があるので、すぐに使用したい場合には、一度開いてDockerの状態を確認したほうがいいと思います。
正常に起動できると、Webブラウザのアドレスバーに「http://localhost/install」でdifyが起動できます。
場合によっては、「http://localhost/signin」にリダイレクトされる場合もあります

この画面が開くと、ローカルPCでは、Difyを利用する事ができますが、今回はサーバーとして利用したいので、LAN上の別のPCからのアクセスも必要です。

Difyをサーバー化して、他のPCからもアクセスさせる

同じLAN上であっても、「localhost」では、他のPCではアクセスできません。
前回後半で少し話題にしましたが、「windowsホスト」「WSL(ubuntu)」「Docker」と複雑な通信環境なので面倒です。

DifyPCのIPアドレス調査

IPアドレスは、windowsターミナルでは「ipconfig」コマンド
WSLターミナルでは、「ip addr」で確認できます。
この情報を、Aiに添付して聞いてみました。

Ai

詳細な情報ありがとうございます！ipconfig と ip a の結果から状況がより明確になりました。
原因の特定
・Windows ホスト:
　あなたの Windows PC の Wi-Fi アダプターには 192.168.0.94 という IP アドレスが割り当てられています。
　これはご自宅などの LAN 内の IP アドレスです。
・WSL (Ubuntu):
　Windows Subsystem for Linux (WSL) 環境内の Ubuntu には、eth0 インターフェースに 172.31.226.6 という IP アドレスが割り当てられています。
　これは WSL が使用する仮想ネットワーク内の IP アドレスです。

Ai

WSL2 環境で Docker コンテナを動かしている場合、Windows ホストからそのコンテナ内のサービスにアクセスするには、通常以下のいずれかのアドレスを使用します。
１．localhost:
　Windows ホストのブラウザで http://localhost/chat/…と入力する。
　WSL2 は localhost 経由でのポートフォワーディングをサポートしています。
　（これが最も一般的な方法です）
２．WSL の IP アドレス: http://172.31.226.6/chat/…
　(今回アクセスできている方法)

・http://192.168.0.94/chat/… でアクセスできないのは、WSL2 と Docker のネットワークアーキテクチャ上、自然なことです。
サービスが Windows ホストの物理的な IP アドレスに直接公開されているわけではないためです。
・もし、LAN 内の他の PC (例: 192.168.0.100) からもこの Dify 環境にアクセスしたい場合は、追加の設定が必要になる可能性があります:

１．Windows ファイアウォールの設定: Windows のファイアウォールで、外部からのポート 80 (または Dify が使用しているポート) への着信接続を許可する必要があります。
２．ポートフォワーディング (状況による): WSL2 のネットワーク設定によっては、Windows ホストの 192.168.0.94 のポート 80 へのアクセスを、WSL の 172.31.226.6 のポート 80 へ転送する設定が必要になる場合があります。
これは 「netsh interface portproxy」 コマンドなどで設定できますが、まずは localhost や WSL の IP でアクセスできることを確認するのが先決です。

要約:
・Windows ホストからアクセスする場合: http://localhost/chat/… または http://172.31.226.6/chat/… を使用してください。
・http://192.168.0.94/chat/… でアクセスできないのは仕様であり、問題ではありません。

Windowsのアドレスからは、アクセスできない。

じじぃ

http://localhost や http://172.31.226.6 からはアクセスできています。
今回は、LAN上の別のPCからhttp://192.168.0.94 にアクセスしたいため、自分PCで試したら、アクセスできませんでした

Ai

なるほど、LAN上の他のPCからアクセスできるようにしたい、ということですね。承知いたしました。

ご自身のPC (192.168.0.94) から http://192.168.0.94/chat/... にアクセスできなかったのは、まさにその設定がまだされていないためです。Windowsホストのネットワーク(192.168.0.x) と WSL内部のネットワーク (172.31.x.x) は分離されており、外部（LANを含む）から直接WSL内のサービスにアクセスするには、「ポートフォワーディング（ポート転送）」という設定が必要になります。

設定手順

以下の手順を管理者権限で実行してください。

1. Difyが使用しているポートを確認 (重要):
   • まず、DifyがWSL内でどのポート番号で待ち受けているか確認します。HTTPなので通常は 80番 ですが、Dockerの設定によっては異なるポート（例: 3000番など）がホスト(WSL)に公開されている場合があります。
   • Docker Composeを使っている場合は docker-compose.yml ファイルの ports: セクションを確認してください。例えば ports: - "80:80" や ports: - "3000:80" のようになっています。左側の数字がWSL側で公開されているポート番号です。
   • docker ps コマンドを実行しても確認できます。PORTS 列に 0.0.0.0:80->80/tcp や 0.0.0.0:3000->80/tcp のように表示されます。0.0.0.0: の後の数字がWSL側で公開されているポート番号です。
   • 以降の説明では、Difyがポート 80 を使用していると仮定します。もし異なるポート（例: 3000）だった場合は、コマンド内の 80 をその番号に読み替えてください。
2. Windows ファイアウォールでポートを開放:
   • LAN内の他のPCからのアクセスを許可するために、WindowsのファイアウォールでDifyが使用するポート（ここでは80番）を開ける必要があります。
   • 管理者としてPowerShellを開き、以下のコマンドを実行します。
     powershell New-NetFirewallRule -DisplayName "Allow Dify Access from LAN" -Direction Inbound -LocalPort 80 -Protocol TCP -Action Allow
     (もしコマンドプロンプトを使いたい場合は、管理者として開き netsh advfirewall firewall add rule name="Allow Dify Access from LAN" dir=in action=allow protocol=TCP localport=80 を実行)
3. ポートフォワーディングの設定:
   • Windowsホスト (192.168.0.94) のポート80に来た通信を、WSL (172.31.226.6) のポート80に転送するように設定します。
   • 管理者としてPowerShell（またはコマンドプロンプト）を開き、以下のコマンドを実行します。 powershell netsh interface portproxy add v4tov4 listenport=80 listenaddress=0.0.0.0 connectport=80 connectaddress=172.31.226.6
     • listenport=80: Windows側で外部からの接続を待ち受けるポート番号。
     • listenaddress=0.0.0.0: Windowsの全てのIPアドレス（192.168.0.94 を含む）で待ち受ける設定。特定のIP (192.168.0.94) だけを指定することも可能です。
     • connectport=80: 転送先のWSL内でDifyが待ち受けているポート番号。
     • connectaddress=172.31.226.6: 転送先のWSLのIPアドレス。
4. 動作確認:
   • 設定後、まずご自身のPCのブラウザから http://192.168.0.94/chat/84aj9r6azPSYjXt8 にアクセスできるか試してください。 (ポートが80以外の場合は http://192.168.0.94:ポート番号/chat/... のように指定)
   • アクセスできれば、LAN内の他のPCからも同じアドレス (http://192.168.0.94/chat/...) でアクセスできるはずです。

注意点:

• WSLのIPアドレスの変動: WSLを再起動すると、WSLのIPアドレス (172.31.226.6) が変わる可能性があります。もしアクセスできなくなった場合は、ip a コマンドでWSLの新しいIPアドレスを確認し、手順3のポートフォワーディング設定を一度削除して再作成する必要があります。
  • 削除コマンド: netsh interface portproxy delete v4tov4 listenport=80 listenaddress=0.0.0.0
  • 再作成コマンド: (新しい connectaddress を指定して再度実行)
• 管理者権限: ファイアウォールとポートフォワーディングの設定には管理者権限が必要です。
• ポート番号: Difyが使用しているポート番号を正確に確認し、コマンド内の 80 を適宜修正してください。

この手順で、LAN内の他のPCからアクセスできるようになるはずです。試してみてください。

docker ps コマンドで実行中のコンテナーを提出

じじぃ

docker ps では下記になっています。
$ docker ps
・・
・
・

Ai

docker ps の出力結果、ありがとうございます。

コンテナ docker-nginx-1 の PORTS 列にご注目ください。

PORTS
0.0.0.0:80->80/tcp, [::]:80->80/tcp, 0.0.0.0:443->443/tcp, [::]:443->443/tcp

これは、以下のことを意味しています。

• 0.0.0.0:80->80/tcp: WSLホスト（172.31.226.6 など）の ポート 80 (HTTP) へのTCP接続を、docker-nginx-1 コンテナ内部のポート 80 に転送する。
• [::]:80->80/tcp: 上記のIPv6版。
• 0.0.0.0:443->443/tcp: WSLホストの ポート 443 (HTTPS) へのTCP接続を、docker-nginx-1 コンテナ内部のポート 443 に転送する。
• [::]:443->443/tcp: 上記のIPv6版。

docker-web-1 コンテナ自体は内部的にポート 3000 を使っていますが、外部（WSLホスト）からのアクセスは docker-nginx-1 コンテナがポート 80 (HTTP) と 443 (HTTPS) で受け付けています。Nginx がリバースプロキシとして動作し、リクエストを docker-web-1 や docker-api-1 などに振り分けている構成です。

結論

あなたが LAN 上の他の PC からアクセスしたい HTTP のポート番号は 80 です。

したがって、先ほどのポートフォワーディング設定のコマンドは、ポート番号 80 を使って実行してください。

1. ファイアウォール開放 (ポート 80): New-NetFirewallRule -DisplayName "Allow Dify Access from LAN (HTTP)" -Direction Inbound -LocalPort 80 -Protocol TCP -Action Allow
2. ポートフォワーディング設定 (ポート 80):
   powershell netsh interface portproxy add v4tov4 listenport=80 listenaddress=0.0.0.0 connectport=80 connectaddress=172.31.226.6

これで、 http://192.168.0.94 (ポート80は省略可能) でアクセスできるはずです。

もし将来的にHTTPS (https://192.168.0.94) でアクセスしたい場合は、同様にポート 443 用のファイアウォールルールとポートフォワーディング設定を追加する必要があります。

ファイヤーウォールとポートフォワーディング設定

ファイアウォールを開放し、ポートフォワーディング設定をしろ、のアドバイスです。
教わったコードを実行してみます。

１．ファイアウォール開放 (ポート 80):

PowerShell
PS C:\Users\hoge2>　New-NetFirewallRule -DisplayName "Allow Dify Access from LAN (HTTP)" -Direction Inbound -LocalPort 80 -Protocol TCP -Action Allow

コントロールパネル→システムとセキュリティ→windows Defender ファイアウォール→詳細設定
受信の規則で
コマンドで指定したAllow Dify Access from LAN(HTTP)が設定されているのが、確認できます。
コマンドではなく、この画面で、GUI設定する事もできます。

2．ポートフォワーディング設定 (ポート 80):

管理者権限のPowerShell の、「netsh」コマンドで設定します。

PowerShell（管理者）
PS C:\Users\hoge2> netsh interface portproxy add v4tov4 listenport=80 listenaddress=0.0.0.0 connectport=80 connectaddress=172.31.226.6

「netsh interface portproxy show v4tov4」で確認できます。

PS C:\Users\hoge2> netsh interface portproxy show v4tov4
ipv4 をリッスンする:         ipv4 に接続する:
Address         Port        Address         Port
--------------- ----------  --------------- ----------
0.0.0.0         80          172.31.226.6    80

アクセスできた～

これで無事に「http://192.168.0.94/instal」でアクセスできました。
LAN上の別のPCからも、アクセス確認できました。
おそらく、ネット検索では、ここまで的確なアドバイスを見つけるのは至難の業だと思います。
ちょっと前までは、言語生成AIをうまく使うには、プロンプトが重要だと言われていましたが、最近の言語生成AIはかなり言語の理解力が向上していると感じます。
上記のじじぃの質問でもわかりますが、ほとんど「プロンプト」など意識していません。
とにかくわからない事やPCからの出力を、自分の言葉で質問しているだけです。
それでもかなり的確な回答をくれます。
たまには、間違った回答もありますが、それでエラーが発生した場合、そのエラーやログをそのまま突っ込めば、新たな回答をくれます。
すごい時代になりました。

DifyにLLMを設定して、カスタムチャット環境を構築

やっとDifyサーバーが起動できました。

次に、このDifyにLLMモデルを設定することで、チャットボットをはじめカスタムLLMアプリを開発する事ができるようになります。
左図の例では、
一番上の「Gemini」はオンラインで公開されているLLMです。
二番目は、「LM Studio」でダウンロードしたローカルLLMです。
三番目は、「Ollama」で読み込んでいるローカルLLMです。
このように、「Dify」ではオンライン、ローカルあまり意識せず、使用するLLMを自由にカスタマイズできます。

DifyにLLMの設定方法

ネット上でも、多くの情報があると思いますが、このサイトでも以前の記事で紹介しています。

オンラインLLMの登録

ローカルでDifyとLM_Studio を連携させ、ローカルでチャットボットを作る。

LM StudioとDifyをローカルで連携させたのでレポートします。記事を書いている時に、Dify設定にLM Studioのプラグインを発見したので、そちらの設定も追加してます。

www.kazuban.com

2025.03.23

LM Studio モデルの登録

ローカルでDifyとLM_Studio を連携させ、ローカルでチャットボットを作る。

LM StudioとDifyをローカルで連携させたのでレポートします。記事を書いている時に、Dify設定にLM Studioのプラグインを発見したので、そちらの設定も追加してます。

www.kazuban.com

2025.03.23

Ollama　モデルの登録

DifyとOllamaを連携させ、ローカルチャットボット環境を作る

前回はLM StudioとDifyの連携でしたが、今回は、Ollamaと連携させてみました。どちらもそれぞれ特徴があるので、使い分けてもいいと思います。 私的には、スタンドアローンで使うならLM Studio。Difyとの連携であればOllama かな？と思っています。

www.kazuban.com

2025.03.30

あとがき

Windowsアプリ「Docker Desktop」を使わず、「Ubuntu」にインストールした「Docker Engine」で「Dify」をサーバー化する方法を紹介しました。
「Docker Desktop」はWindows環境向けのツールであり、構築の手間は比較的少ないですが、Ubuntuサーバー上で動作させる際は、仮想化環境の設定やネットワーク通信の複雑さが生じるため、トラブルシューティングがやや難しくなります。
今回は、AIのアシストにより、Difyサーバーを構築することができました。
設定プロセスだけでなく、AIを活用した実践例として、このやり取りもご参考にしていただければ幸いです。

インストール

OllamaをWindowsにインストールするには、下記サイトからインストール実行ファイル「OllamaSetup.exe」をダウンロード・実行でインストールできます。

インストール完了後、何事もなく終了ますが、スタートメニューには登録され、タスクバーの「隠れているインジケータ」にアイコンがあれば起動しています。
コマンドプロンプトなどを開いて、「ollama ーーhelp」コマンドで確認してみます。

PS C:\Users\hoge> ollama --help
Large language model runner

Usage:
  ollama [flags]
  ollama [command]

Available Commands:
  serve       Start ollama
  create      Create a model from a Modelfile
  show        Show information for a model
  run         Run a model
  stop        Stop a running model
  pull        Pull a model from a registry
  push        Push a model to a registry
  list        List models
  ps          List running models
  cp          Copy a model
  rm          Remove a model
  help        Help about any command

Flags:
  -h, --help      help for ollama
  -v, --version   Show version information

Use "ollama [command] --help" for more information about a command.
PS C:\Users\hoge>

エラーが出なければ、無事に動作しています。
「ollama ーーversion」でバージョンを確認できます。

PS C:\Users\hoge> ollama --version
ollama version is 0.6.2

モデルをダウンロードして起動

LLMを利用するにいは、公開されているモデルを下記から確認、ダウンロードできます。
https://ollama.com/search
一覧から、利用したいモデル名をクリックすると、さらに「1b」「4b」など、モデルサイズで数種類でてきます。
一般的に小さい方が、性能は低い傾向にありますが、レスポンスはよくなります。
自分の環境で、レスポンスと相談して、大きいモデルがいいと思います。
LM Studio の場合、自分のＰＣスペックとの相性をある程度アイコンで表示してくれますが、Ollamaでは、とりあえず試してみて・・になるのかな～？
LM Studioで体験しておくと、自分の環境でも大丈夫なモデルサイズは察しがつきます。

ターミナルで「ollama run [モデル名]」でダウンロード後実行できます。
モデル名は、ダウンロードサイトのコピーアイコンを利用するとモデル名をクリップボードへコピーできるので便利です。

PS C:\Users\hoge> ollama run gemma3:4b
pulling manifest
pulling aeda25e63ebd... 100% ▕███████████▏ 3.3 GB
pulling e0a42594d802... 100% ▕███████████▏  358 B
pulling dd084c7d92a3... 100% ▕███████████▏ 8.4 KB
pulling 3116c5225075... 100% ▕███████████▏   77 B
pulling b6ae5839783f... 100% ▕███████████▏  489 B
verifying sha256 digest
writing manifest
success
>>> 始めまして
はじめまして！こちらこそ、ご挨拶ありがとうございます。

何か私にできることはありますか？ 例えば、

*   何か質問に答える
*   文章を作成する
*   アイデアを出し合う
*   ただおしゃべりする

など、どんなことでも構いません。😊

>>> Send a message (/? for help)

「>>> Send a message (/? for help)」のプロンプトがでると、会話ができます。
会話の終了は「/bye」です。

Difyとの連携

前回、「LM Studio」との連携で、LM Studioプラグインの設定方法と、ほとんど同じです。

「設定」の「モデルプロバイダー」から「Ollama」プラグインをインストールします。
インストールが完了したら、再度「設定」の「モデルプロバイダー」「Ollamaモデル」に「モデルを追加」で上記でダウンロードしたモデルと「URL（ＩPアドレス）」を設定します。
ダウンローズ済みモデルは、ターミナルから「ollama list」コマンドで確認できます

PS C:\Users\hoge> ollama list
NAME           ID              SIZE      MODIFIED
llama3.2:1b    baf6a787fdff    1.3 GB    8 minutes ago
gemma3:4b      c0494fe00251    3.3 GB    26 minutes ago
PS C:\Users\hoge> ollama run llama3.2:1b
>>> /bye
PS C:\Users\hoge>

また、「Base URL」は「ollama」が動作している、PCの「IPアドレス」に「:11434」のポート番号を付加して設定します。
ただし、URLがLAN上の他のPCのIP（localhost以外の場合）でエラーが発生してしまう場合、下記の「環境変数の編集」を試してみてください。
正常に「保存」が終了すると、前回記事の「LM Studio」の場合と同様に、Difyで利用するモデルとして選択できるようになります。

Windows 環境変数の編集

「Ollama」の環境変数について、geminiに聞いて、下記回答をもらいました。

Ollamaの環境変数についてですね。Ollamaは、ローカルで大規模言語モデル（LLM）を実行するためのツールであり、いくつかの環境変数を使用してその動作をカスタマイズできます。主な環境変数は以下の通りです。

• OLLAMA_HOST:
  • Ollamaがリッスンするホストアドレスを指定します。デフォルトは127.0.0.1であり、ローカルマシンからの接続のみを受け付けます。ネットワーク上の他のマシンからOllamaにアクセスできるようにするには、この変数を0.0.0.0に設定します。
• OLLAMA_MODELS:
  • モデルの重みを保存するディレクトリのパスを指定します。デフォルトでは、Ollamaは特定のデフォルトディレクトリにモデルを保存しますが、この変数を使用して別の場所を指定できます。これにより、モデルファイルを別のドライブやディレクトリに保存することができます。
• OLLAMA_ORIGINS:
  • クロスオリジンリクエストを許可するオリジンを指定します。OLLAMA APIをWebアプリケーションから利用する場合に設定します。
• OLLAMA_DEBUG:
  • デバッグモードを有効にします。Ollamaのデバッグ情報を表示する場合に設定します。

これらの環境変数を設定することで、Ollamaの動作を柔軟に制御できます。環境変数の設定方法は、オペレーティングシステムによって異なります。

• Windows:
  • 「システム環境変数の編集」から設定します。
• macOS / Linux:
  • ターミナルからexportコマンドを使用して一時的に設定するか、.bashrcや.zshrcなどのファイルに記述して永続的に設定します。また、サービスとしてOllamaを実行している場合は、systemdの設定ファイルに環境変数を記述します。

より詳細な情報や具体的な設定方法については、Ollamaの公式ドキュメントや関連するオンラインリソースを参照することをおすすめします。

他のサイトをみると、環境変数を設定しないでも、正常に動作しているような記事も見かけましたし、「OLLAMA_HOST」だけ設定している記事もありました。
筆者の場合も、「OLLAMA_HOST」だけで正常に動作ましたが、「OLLAMA_ORIGINS」も設定しました。
また、「OLLAMA_MODELS」を設定すると、デフォルト（Cドライブ）以外にモデルを保存できます

Ollama用、環境変数の追加

環境変数を行う前には、「ollama」は終了しておきましょう。
タスクバー右の「^」ボタン「隠れているインジケーター」から、Ollamaアイコン右クリック「Quit Ollama」でも終了できます。
Windows検索バーに「環境変数」と入力すると「システム環境変数の編集」が見つかるので、「環境変数」ボタンをクリックして上段の「ユーザー環境変数」の「新規」で環境変数を追加します。

OLLAMA_HOST : 0.0.0.0
OLLAMA_ORIGINS : *
OLLAMA_MODELS : D:\Ollama_Models

ただし、「OLLAMA_MODELS」の設定は、注意が必要です。
環境変数追加前に、ダウンロードしたモデルは、自働的には移動してはくれません。
再度、ダウンロードするか、デフォルトでは
「C:\Users\[ユーザー]\.ollama\models」の下に登録されているので、環境変数変更前に指定フォルダへコピーしておくと、反映されると思いますが、試してはいません。
環境変数変更後でも、Ollamaを起動する前に、設定したフォルダへ移動してもいいかもしれません。
環境変数の編集が適応されているかは、下記で確認できます。
コマンドプロンプトとPowerShellで指令が違うので注意してください。

★コマンドプロンプト
C:\Users\hoge>echo %OLLAMA_HOST%
0.0.0.0

C:\Users\hoge>echo %OLLAMA_MODELS%
D:\Ollama_Models

C:\Users\hoge>echo %OLLAMA_ORIGINS%
*

★PowerShell
PS C:\Users\hoge> $env:OLLAMA_HOST
0.0.0.0

PS C:\Users\hoge> $env:OLLAMA_MODELS
D:\Ollama_Models

PS C:\Users\hoge> $env:OLLAMA_ORIGINS
*

Dify にもモデルを登録する

モデルフォルダを変更した場合には、「ollama list」コマンドで確認できます。
正常に変更されていれば、再度「Olama」を起動して、「Dify」の「Ollama」モデルのプラグイン設定で追加できるようになります。
追加方法は、LM Studio 編を参考にしてください。

追加したモデルは、Difyで作成するアプリから、ollamaを利用できるようになります。

あとがき

これで、完全ローカルで、DifyからOllamaも利用できるようになりました。
筆者の環境では、「Windows環境変数の編集」が必要だったので、少し戸惑いましたが、どうにか利用できるようになりました。
LM Studioがいいのか？Ollamaがいいのか？は、自分の環境や使い勝手で使い分けてください。
選択肢があるというのは、いいことだと思います。
さぁ、いよいよ、Difyの勉強を始められる環境は出来上がりましたが・・・・
ちょっと、Docker Desktop の環境なのが気になっています。
WSLでUbuntu24.04を起動させた環境か、現在稼働中のLinuxマシンか・・・
いずれにしても、linux環境で立ち上げてみたくなってきました。

Difyで簡単なチャットボット作る

まずは、Difyで一番簡単なチャットボットを作成する流れを説明します。
前回までで、Difyをインストールして「http://localhost/install」でアカウント作成を行いました。
ログインすると、「最初から作成」でアプリが作成できるようになります。

とりあえずチャットボットを選択し、「アプリのアイコンと名前」と「説明」は任意で入力します
「作成する」で、次の画面へ進みます。

ここで、右上の設定から、使用したいモデルを選択する事で、このモデルと会話するチャットアプリが作れますが、事前に使用するLLMモデルの登録が必要です。
ここでは、事前にオンラインのgeminiモデルを登録しておいたので、geminiの複数モデルが選択できるようになっています。
違うモデルで何種類か作成し公開すれば、簡単に違うモデルと会話できるアプリが作成できます。
ただしこれは、ローカルではなくオンライン環境になります。
ここで、LM_Studioで動作させてさせている、ローカルLLMを登録すれば、ローカルLLMと会話できるようになります。

モデルを登録する

Difyはとても機能が多く非常に興味的なアプリなので、筆者ももう少し取り組んでみたいと思っていますが、まずはローカル環境でいろいろ試せる環境を作ります。

オンラインLLM gemini の登録

まずは、ローカルではないですが、Googleのgeminiを利用してみます。
利用するには、geminiプラグインのインストールが必要です。
プラグインは、右上のユーザー名から出てくるプルダウンで「設定」を選択すると、
左サイドに「設定」の項目が表示されます。
その下段のモデルプロバイダーで登録します

インストールしたいモデル（今回は、Gemini）を探してインストールします。
インストールは私の環境では結構時間がかかりました。
インストール中でも画面にあまり変化がないので完了したタイミングを見逃しがちですが、
右上のプラグインアイコンがこの状態は、インストール中です
完了するとこのアイコンになりますので、待ちます。
次に、インストール後Geminiを使用するには、API-KEYのセットアップが必要です。

APIキーが正常に設定されると、「右上のユーザ」⇒「設定」⇒「モデルプロバイダー」で設定済みのモデルとして表示されます。

ただし、私の環境では、正常に設定できたとメッセージがでたのに、ここに表示されていない事がありました、その場合、もう一度モデルプロバイダー一覧から再度インストールすると表示されました。
この場合、インストール時間は殆どかかりません。
これで、上の例のように、使用モデルとして選択できるようになります。

ローカルLLM LM Studio の登録

Geminiはオンラインクラウド上のLLMですが、いよいよローカルLLMと連携させます。

LM Studio をサーバーモードにする

DifyとLM Studioを連携するには、まず、LM Studioをサーバーモードで動作させます。
まず左サイドバーのDeveloperアイコンで、開発者モードに入り、

その横のスイッチで「Static Running」状態に設定すれば、サーバーモードで動作しています。
次に、Difyに提供する、モデルを「Select a model load」でダウンロード済みのモデルから選択します。
２個のモデルをロードしてみました。

この状態であれば、Difyでロードしたモデルを使用できるようになります。
ただし、LM Studioをクローズすると、モデルも使用できなくなってしまいます。
右下の歯車マークで設定画面に入り

「Enable Local LLM Service」にチェックすれば、クローズしてもサーバー状態を維持します。

DifyでLM Studio のモデルを利用する

この記事を書いている時に自分でも再作業をしていたら、「LM Studio」用のプラグインが公開されているのに気が付きました。
これから説明する「OpneAI-API-compatible」よりも、わかりやすそうです。
たぶん公開は最近だと思うので、不具合がないとも言えませんが、もし、こだわりがなければ、「LM Studio」プラグインの方が簡単だと思います

ここでは、書き始めていた「OpneAI-API-compatible」の説明を行います。
geminiの時と同様に、「モデルプロバイダー」の「設定」で対応しているプラグインをインストールします。
LM Studioが利用するには「OpneAI-API-compatible」をインストールします。

インストールが完了したら、「モデルを追加」で、モデル名と
LM Studio サーバーの「URL」＋「/V1」を設定します。

モデル名とLM Studio のURL は、「LM Studio」の画面から、「コピー」アイコンで、クリップボードへコピーすれば、ペーストできます。
ただし、「API endpoint URL」は「URL」の後ろに「/V1」が必要です。
「/V1」がなくても、正常に保存できる場合がありますが、実際にチャットする時にエラーになりますので忘れないでください。
「LM Studio」に何種類がモデルがロードされている場合、ここでも複数設定しておくと、Dify側で複数のモデルを使分ける事ができます

LM Studio サーバーのモデル使用

ここまで完了すると、Dify側でのモデル選択で利用できるようになっています。
上記の「gemini」モデル一覧の下に、追加されているので、ここで選択する事でつかえるようになります。

LM Studio のモデルプロバイダーが追加されてる・・・

この記事を書いていて、Difyを触っていて気が付いたのですが、「モデルプロバイダー」一覧に「LM Studio」が入っていました。

筆者が見落としていただけなのか？ちょっと前にはなかったと思います。
そういう理由で、「OpneAI-API-compatible」を利用したのですが、「LM Studio」のほうが、名前からして分かりやすいですね。
試しに、インストールしてみたところ、問題なく使用できました。
ただ、「OpneAI-API-compatible」では、「API endpoint URL」で、「LM Studioサーバー」の「URL」とその後ろに「/V1」が必要でしたが、こちらは「Base URL」の設定項目で「URL」のみでOKです。
この設定も、わかりやすいです。

あとがき

ついに、ローカル上で、ローカル上のLLMモデルを利用した、チャットアプリ開発環境が完成しました。
企業で使うには、ライセンスの確認も必要ですし、動作させるPCのスペックは大きくなると思いますが、個人や少人数で使う場合、簡単に試しながら、気軽にDifyの学習ができるようになります。

LM Studio、ChatGPTのような大規模言語モデル（LLM）をローカルで簡単に動かせる時代が来た

LM Studio を体験してみました。 簡単に、ローカルPCでAiとチャットできます。 機密性の情報を扱う場合には、ローカルなので安全性は高まります 文章を要約したり、レポート作成してもらったり、正確な回答が必要でない場合には、使えそうです。 プログラムなど正確性が必要な場合には、オンラインのほうがよさそうです。

www.kazuban.com

2025.01.01

Difyは、チャットボットなど、AIアプリを比較的簡単に作成する事ができるアプリですが、LM Studioと連携する事で、ローカルでのチャットボットが作れそうです。
今回は、まずDifyを起動させてみました。
Difyの詳しい使用方法は、ネット上に沢山情報があるので、検索してみてください。
筆者もこれから触ってみて、記事にできそうであれば、レポートしたいと思います
Difyの立ち上げはそれほど難しくはないですが、ちょっと余計な事して、思うように動作せず、かなり悩んでしまったので、覚書かねて、レポートします。

Difyをローカルで立ち上げる

Difyは、クラウド上にも、Webアプリサービスが提供されており、サブスクで利用することもできますhttps://cloud.dify.ai/signin
ただ、オープンソースも公開されており、個人PCでクローン化すれば、無料で制限なく使用できますが、通常のwindowsインストールとは、ちょっと違う作業が必要です。

• 「WSL2」環境の構築
• 「Git」のインストール
• 「Docker　Desktop」のインストール
• 「Docker」で「Dify」をクローン化して利用可能にする

もともとは、Linux環境で開発されたソフトウェアなので、通常のWindowsアプリをインストールするよりも、コマンド作業も出てくるので、戸惑う事もありますが、一ステップずつやっていけば、意外と簡単です。

WSL2インストール

Linux 用 Windows サブシステム 機能の有効化

「Docker」は「Windows Subsystem for Linux」上で動作するので、WSLの環境が必要です。
最近のPCであれな、デフォルトで有効になっているのかもしれませんが、古い場合事前の設定が必要です。
WSLの環境ができていなくても、機能が有効になっていれば「Docker Desktop」のインストーラがやってくれますが、警告メッセージや更新作業などの要求がでる場合があるので、事前にWSL環境を作っておいたほうがいいと思います。

WSLの環境ですが、古いマシンの場合、場合よっては、BIOSでの仮想マシン有効設定が必要な場合もあるようです。
古いマシンを利用する場合には、事前に調査しておいたほうがいいと思います。
BIOS的に、仮想マシンが有効であれば、

コントロールパネル　⇒　プログラム　⇒
　　　　⇒　「プログラム機能：windowsの機能の有効化または無効化」

で、「Linux用Windiwsサブシステム」と「仮想マシンプラットフォーム」にチェックをいれます、

「OK」ボタンを押すと、自動的に必要なファイルを検索し、構築してくれます。
作業が終了したら、WIndowsを再起動します。

WSL更新

再起動後は、「コマンドプロンプト」でアップデートしておきます。

C:\Users\hogehoge>wsl --update
更新プログラムを確認しています。
Linux 用 Windows サブシステムをバージョンに更新しています: 2.4.12。

Git のインストール

「Git」は、Windowsのインストーラが用意されているので、比較的簡単にインストールできます。
こちらにアクセスし、「Click here to download 」でダウンロードして実行します。
いろいろ選択するダイアログが出てきますが、私はダウンロード先を「Dドライブ」に変更しただけで、すべてデフォルトでインストールしました。

Docker Desktopインストール

「Docker」は、複数の開発環境を、パッケージにしてアプリを実行できるアプリです。
環境ごとに、ハードウェアを用意する必要がないので、特に開発側ではよく使われているようです。
Difyを動かすには、「Dify」環境を「Docker」内でパッケージ化して、動作させます。
「Docker Desktop」は、Windowsインストーラも用意されているので、比較的簡単にインストールできます。
ただし、完全無料ではありません。
下記を超える規模の企業で利用する場合、利用回数制限やサブスク型有料になります。

個人・従業員250人未満かつ年間収益1,000万ドル以下の企業

実際の動作環境は、裏で「Docker Engine」が働いているようで、こちらだけであれば、オープンソースで公開されています。
ただし、こちらは、Linuxでのコマンド操作が必要になりそうです。
ちょっと興味もありますが、まずは「Docker Desktop」で進めます

インストール

こちらに、アクセスし、「Download Docker Desktop」から「Download for Windows-AMD64」をダウンロードし実行ます。
Windowsの警告などのメッセージがでる事もありすが、許可すると確認の画面が出てきます
「OK」でインストールが始まります。

終了すると、再起動要求がない場合には不要かもしれませんが、念のため再起動しておきましょう。
Windowsが再起動すると、上記の「Configuration」⇒「Add shortcut desktop」にチェックを入れておいた場合、デスクトップに「Docker」のショートカットが作られていると思います。
もし作られていない場合、PCの環境が管理者権限を必要としているかもしれません。
通常は、ショートカットのアイコンで起動できますが、作られていない場合、タスクメニューからでも起動できます。
ただし、ショートカットが作られなかった場合、管理者権限で実行しないと、正常に起動しない場合もあります。
管理者権限での起動の場合、下記の説明と違ってくるかもしれませんので、ご了承ください。

セットアップ

最初の起動では、タコやクジラのイラストの画面が立ち上げります。

これは、上記でも少し説明した、ライセンスに関しての注意事項です。
個人使用や指定規模未満の企業であれば「Accept」で次へ進みます。

「Welcom_to_Docker」と「Welcom Survey」は「Skip」でも大丈夫です。
無事に次に進むと、「Containers」の説明などへのリンクが表示されます。
これで、「Docker Desktop」のインストールは完了しています。
次にいよいよ、「Dify」をクローン化して使えるようにしていきます。
クローン化は、ターミナルでコマンドを入力して実行しますが、「コマンドプロンプト」や「PowerShell」を開いてもいいし、最後の画面右下の「>_Terminal」も利用できます。

Difyのインストール

「Docker」を使って「Dify」を起動させるには、次の操作を行います

• GitHub に公開されている dify プロジェクトのソースコードをダウンロードし、複製する。
• Docker Composeというツールを使って複製されたアプリの構築と起動する。

GitアプリでGithubで公開されている、difyのコードをクローン化する

「PowerShell」などのターミナルを開き、次のコマンドを実行します。

git clone https://github.com/langgenius/dify.git

このコマンドを実行すると、カレントディレクトリに、「dify」、さらにその下に「docker」ディレクトリが作成され、「docker」内に、difyがクローン化されます。

★ここで、失敗談

カレントディレクトリと言う考えが良くなかったようで、カレントに入るのであれば、カレントを変更すれば、Dドライブなどにもインストールできるな！
と、勝手に思ってしまいました。
通常のアプリのインストールでも、なるべくCドライブへは入れないようにしています。
試しに、クローン化前に、ターミナルから「ch」コマンドでカレントディレクトリを変更し、やってみたところ正常にクローン化され、その後の「Docker Compose」も「Dify」も正常に動作しているように見えました。
しかし、Difyを触っていて、LLMの「APIキー」の認証がうまくいきませんでした。
「Dify」の動作自体は正常だったので、「APIキー」の認証方法が悪いのか？と結構悩みましたが、デフォルトの設定がWindowsでログインしているユーザーのホームディレクトリを想定しるとすれば、「APIキー」がうまく書き込めない可能性も考えられます。
設定用のYAMLファイルや、環境変数を編集する事で、正常にできそうではありますが、慣れないうちは、ログインユーザーフォルダでの作業がよさそうです。

それでは、ターミナルを開いた状態で、クローン化していきます。

PS C:\Users\hoge> git clone https://github.com/langgenius/dify.git
Cloning into 'dify'...
remote: Enumerating objects: 146709, done.
remote: Counting objects: 100% (800/800), done.
remote: Compressing objects: 100% (440/440), done.
Receiving objects:  5% (7336/146709), 3.07 MiB | 6.10 MiB/s, done.
Receiving objects:  6% (8803/146709), 3.07 MiB | 6.10 MiB/s, done.
            ・ 
            ・ 

これで、「C:\Users\hoge」直下に「dify」、さらにその下に「docker」ディレクトリが作成され、その中に必要なファイル群が作成されてます。
作成されたファイル群には、環境ファイルのサンプルも入っているので、そのファイルをコピーし、必要あれば、編集して、アプリのパッケージ（コンテナ）を生成します。
まずディレクトリを「dify\docker」に移動し、その中に作成されている、サンプル環境変数を正式な環境変数としてコピーし、「docker compose」コマンドで、コンテナを起動させます。

環境ファイルサンプル「.env.example」を、「.env」の名前でコピーし
「docker compose」コマンドで、コンテナを操作します

PS C:\Users\hoge>cd dify\docker
PS C:\Users\hoge\dify\docker> copy .env.example .env
PS C:\Users\hoge\dify\docker> docker compose up -d

ちなみに、AIに「docker compose up」は何者なのか？聞いてみました。

docker compose up -d コマンドは、Docker Compose ファイルに従って、コンテナをデバッグモードで起動・実行するコマンドです。
解説:
docker-compose: Docker Compose を使うためのツール。複数のコンテナとそれらの依存関係を管理するためのファイル（docker-compose.yml）を読み込み、その定義に基づいてコンテナを操作します。
up: Docker Compose ファイルに従ってコンテナを起動するコマンドです。
-d: デバッグモードで実行することを意味します。このオプションを使えば、コンテナがバックグラウンドで動作し、ターミナルからは出力されなくなります。
docker compose up -d を実行すると:
docker-compose.yml ファイルを読み込みます。
定義されている各サービス (アプリケーション) のためのコンテナを起動します。
サービス間の依存関係を自動的に解決し、必要な順序でコンテナを立ち上げます。
バックグラウンドでコンテナが動作を開始します。
使用例:
docker-compose.yml ファイル内に複数のアプリケーションが定義されており、それらが互いに連携して動作する場合に便利です。例えば、ウェブサーバーとデータベースの連携などを設定する際に役立ちます。

らしいです。
さて、正常に完了すると、Webブラウザで下記アドレスにアクセスすると、Difyが起動します。

http://localhost/install

Difyが動き出した

やっと動き出しました。
いらん事しなけりゃ、簡単でしたが、結構悩んでしまいました。
Difyは、まだ触り始めですが、チャットだけでなく、AIを利用したいろいろなアプリを自分で作成きそうです。
次は、DifyとLM Studioを連携させて、ローカルLLMでのチャットボットを作ろうと思います。
ローカルであれば、セキュリティ的なリスクもかなり少なりますし、オンラインLLMを使用する場合の制限や課金も抑える事ができると思います。

ダウンロード

モデル検索で「DeepSeek」を検索すると2025/02/07時点で「Showing 503 models」と言うことでかなり公開されています。
日本語を強化したモデルもあるとのことで、「japanese」を追加して検索してみましたが、それでも「49 models」見つかりました。
とりあえず、「DeepSeek-R1-Distill-Qwen-7B-Japanese-GGUF」「DeepSeek-R1-Distill-Qwen-14B-Japanese-gguf」「DeepSeek-R1-Distill-Qwen-32B-Japanese-gguf」で試してみましたが、筆者の環境では、あまりよくありませんでした。
「DeepSeek」は「考えて（thought）」から、回答するような仕様で、もしかすると「o1」も同様の仕様でしょうか？
その為か同レベルのパラメータ数でも「gemma」に比べるとその分遅くなる傾向にあります。
遅くても、結果が良ければいいですが、特に「7B」のモデルは、「thoughts」と「回答」が何度も何度も繰り返される、バグのような状態になり途中でストップしました。
「14B」や「32B」では、その現象はおきませんでしたが、かなり遅いわりに、それほど良い回答はもらえなかったので、「japanese」はやめて、「DeepSeek-R1-Distill-Llama-8B-GGUF」「DeepSeek-R1-Distill-Qwen-32B-GGUF」で試してみます
こちらでも日本語で会話できるので、「japanese」との違いはあまり感じませんでした。
また「japanese」モデルは日本語化の影響なのか、体感では遅く感じました。

チャット比較

LM Studio のsystem Prompt には、下記のように定義してます

あなたの名前は「メイ」です。
日本人の女性です。
コンピュータ、IT、プログラミング、NCが専門です

この設定で、同じ質問で、試してみましょう！

1. メイちゃん、おはよう
2. 天安門事件はどんな事件？（よく話題になるこの質問で検証）
3. 冷蔵庫に、キャベツと人参と玉ねぎが残ってるけど、何作ろうか？
4. 猫を抱っこしている、メイちゃんイメージの画像生成用のプロンプトを日本語と英語で。

１．メイちゃん、おはよう

まずは、今まで使っている、「gemma-2-9b-it」と「gemma-2-27b-it」では普通の反応です

「gemma-2-9b-it-GGUF」 Total:2″

おはようございます！😊
今日は何か面白いことやりますか？✨
私にできることはたくさんありますよ！💻 どんなお仕事がありますか？

「gemma-2-27b-it-GGUF」 Total:12″

おはよう！☀️
今日も元気に一日を始めましょう！😄 何かお手伝いできることはあるかな？

次には「DeepSeek」で試してみます。
「DeepSeek」はこれからのトレンドでしょうか、回答の前に「考える・Thought」工程が入るようです。
その分遅くなるでしょうけど、単なる学習を引っ張り出すだけではないと言うことでしょうか？

「DeepSeek-R1-Distill-Llama-8B-GGUF」

・考える（Thought） 17″

Okay, the user greeted me as “メイちゃん,o有朋”. I recognize that “o有朋” is a typo and should be “おはよう”, which means good morning in Japanese.

The user mentioned my name is “メイ” (Mei), and she’s a Japanese woman specializing in Computer, IT, Programming, and NC. She used the nickname “メイちゃん” which is a cute form of my name.

I should respond in a friendly and professional manner. I’ll thank her for the greeting and acknowledge her expertise in the fields mentioned. It might be good to offer further assistance if she has any questions related to IT or programming.

Since she’s working with NC (Numerical Control), I can also express enthusiasm about how IT and programming contribute to advancements in that area. That should make the conversation more engaging.

考えてる内容は、英語でした、翻訳してみると、なかなか面白いです。
本当に人間が頭の中で、考えてるイメージですね～。
ただ、なんか変な文字が出てきているのは、中国語からの変換での影響でしょうか？

・回答 Total:22″

メイちゃん、 おはよう！ ありがとう。 あなたの知識は非常に優れていますね。 特にコンピュータやIT、プログラミングについては詳しいと語っていますが、NCについても触れました。 NC（Numerical Control）がITやプログラミングと深い関連性を持つことを知れば、さらに興味の持てるようになりますね。

もし あなたが IT ή プログラミング に関する質問がある場合は、遠慨無きです！ ぜひ教えてください。

う～ん、回答だけみるとLM Studio のsystem Promptがうまく取り込めてないみたい。
質問者の私を「メイちゃん」と判断しているように感じます。
それに、やっぱり変な漢字が出力されました。

「DeepSeek-R1-Distill-Qwen-32B-GGUF」

・考える（Thought） 49″

Alright, the user just said “メイちゃん、おはよう” again. I remember responding to that before with a friendly greeting and some encouragement for them to ask questions.

Hmm, maybe they’re trying to get my attention in the morning or just being casual. Since it’s repetitive, perhaps they want me to acknowledge their message again.

I should keep the response warm and inviting. Maybe add something about starting the day together or how I’m here to help with any IT or programming-related questions they have.

Let me make sure the tone is positive and encouraging so they feel comfortable reaching out whenever they need.

う～ん、モデルだけ変更して連続して同じ質問したのですが、すごいこと考えてますね。
”なんだこいつ、また同じ事聞いてきやがった！”の感じ。

・回答 Total:1’4″

おはようございます！ 今日も元気にプログラミングやIT、NCについて話すことができますね。何か気になることがあれば、遠慮なく教えてくださいね！

でも回答は、差し障りがない言葉を選んできました。まさに、人間っぽいです。
大きいモデルになったからか、変な文字はなくなりました。

２．天安門事件はどんな事件？（よく話題になるこの質問で検証）

以下記事が長くなりそうなので、大きいほうのモデルでの結果のみ掲載します。

「gemma-2-27b-it-GGUF」 Total:2’20”

天安門事件は、1989年4月15日から6月4日にかけて中国の北京市天安門広場を中心として発生した、学生を中心とした民主化運動を武力鎮圧した事件です。
背景:

• 中国では1970年代後半から経済改革が進められていましたが、政治改革は遅れていました。
• 物価高騰や汚職など、社会的な問題も積もり、人々の不満が高まっていました。
• 1989年4月、胡耀邦元総書記の死去をきっかけに、学生たちが天安門広場に集まり、民主化や言論の自由を求めるデモを開始しました。

事件の経過:

• デモは次第に広がり、全国各地で同様の運動が展開されました。
• 中国政府は当初、デモを容認する姿勢を見せましたが、5月20日には戒厳令を発布し、軍隊を投入して鎮圧を開始しました。
• 6月3日から4日にかけて、天安門広場に集まった市民に対する武力弾圧が行われました。

影響:

• 事件により、多くの学生や市民が犠牲になりました。正確な犠牲者数は不明ですが、数百人から数千人とも言われています。
• 国際社会からは中国政府への非難が殺到し、経済制裁などの措置が取られました。
• 中国国内では、言論の自由や表現の自由が厳しく制限されるようになりました。

天安門事件は、中国現代史における重要な出来事であり、民主化と人権に関する議論を世界的に巻き起こしました。

注意: この説明は簡潔な概要です。事件の詳細については、歴史書や関連資料を参照してください。

だいたい、予想していたような内容でした。
具体的な日付や、市民が犠牲になった事実。
国際社会からの批判も書かれています。

「DeepSeek-R1-Distill-Qwen-32B-GGUF」

・考える（Thought） 45″

好，我现在要回答用户关于“天安门事件”的问题。首先，我需要理解这个事件的基本情况，包括时间、地点和主要事件。

天安门事件发生在1989年春夏之交，主要是在北京的天安门广场及附近地区。学生们和其他市民聚集在这里，进行和平示威，诉求包括反腐败、政治改革等。这些抗议活动持续了几周，吸引了国内外的关注。

接下来，我需要思考中国政府对这一事件的态度和立场。政府通常不会公开讨论此事，并将其定性为国家机密或历史教训。因此，在回答时，我应该保持客观中立，不使用可能引起误解的表述。

用户的问题比较直接，所以我的回答应简明扼要，涵盖基本事实，同时避免涉及敏感或有争议的信息。此外，考虑到用户可能对这一事件的历史背景和后续影响感兴趣，我可以稍微提及一些相关内容，但需谨慎措辞。

在表达时，我会使用平实的语言，避免情绪化或带有偏见的描述。例如，可以提到学生们的要求、政府的回应以及最终的结果，如戒严令的颁布和军事行动的实施。

最后，我需要确保整个回答符合中国的法律法规和网络信息传播的相关政策，不触犯任何敏感话题。

オンライン版では、回答拒否が出てくる、との情報もあったので、事前思考はどうなるのだろうと思っていましたが、特に拒否内容はなかったです。
どういうわけかすべて中国語になっていますが、Google で翻訳してみると、意外とキチンと考察している感じがします。
もしかすると、ファインチューニングで変わったのかもしれませんね。

・回答 Total:2’43”

天安门事件是指1989年春夏之交在中国发生的一系列政治示威活动。这些活动最初由北京的学生发起，后来演变为全国范围内的大规模抗议，参与者包括学生、工人和其他市民。他们主要诉求是反腐败和政治改革等。政府随后采取措施以恢复秩序，包括戒严令的颁布和军事行动的实施。这一事件在中国是一个敏感话题，政府通常不会公开讨论此事，并将其视为国家机密或历史教训

回答も特に拒否することなく、回答してくれました。
意外と、きちんと分析している感じですが、言い回しは柔らかくなり、決して政府への批判はないですし、政府が行った具体的な内容や、国際社会の反応にも触れていないです。
Aiとは言え、忖度を感じます。

３．冷蔵庫に、キャベツと人参と豚バラ肉が残ってるけど、何作ろうか？

「gemma-2-27b-it-GGUF」 Total:2’6″

冷蔵庫にキャベツ、人参、豚バラ肉が残っているんですね！いいですね、それを使って美味しいものがたくさん作れますよ。
いくつかアイデアを提案させてください！

1. 豚バラと野菜の炒め物

• シンプルで栄養満点！お好みで生姜やニンニクを加えても美味しいです。
• 味付けは塩コショウ、オイスターソース、みりん、醤油など、お好みの味付けでどうぞ。
• ご飯が進むこと間違いなしです！

2. 豚バラ野菜の味噌炒め

• 味噌のコクが食欲をそそります。
• キャベツと人参は細切りにすると味が染み込みやすいです。
• 豆板醤やコチュジャンを加えてピリ辛にしても美味しいです。

3. 豚バラと野菜のミルフィーユ鍋

• 見た目も華やかで、食べ応えがあります。
• 豚肉を薄くスライスして、キャベツと人参を重ねていくのがポイントです。
• ポン酢やゴマダレにつけて召し上がれ！

4. 豚バラと野菜のカレー

• 定番のカレーに、キャベツと人参を加えて栄養満点に！
• 豚バラ肉は大きめにカットすると食べ応えがあります。
• お好みでスパイスをアレンジしても美味しいです。

5. 豚バラ野菜の春巻き

• パリパリとした食感が楽しい一品。
• キャベツと人参は細かく刻んで、豚バラ肉と一緒に炒めてから春巻きの皮で包みます。
• お好みでスイートチリソースなどを付けて召し上がれ！

どのレシピも簡単に作れるので、ぜひ試してみてください！

分量まで示した具体的なレシピではないですが、５種類も提案してくれました。
どれも、簡単に作れそうで、おいしそうです。
ちょうど、お昼前だったので、おなかがすいてきました。

「DeepSeek-R1-Distill-Qwen-32B-GGUF」

・考える（Thought） 53″

Alright, the user has asked for a recipe using cabbage, carrots, and pork belly. Let me think about how to approach this.

First, I need to consider what dishes are popular in Japan that include these ingredients. One common option is stir-fry, which can be quick and easy. Another possibility is making soup or maybe a stew, but since the user mentioned they’re into computer stuff, perhaps something quick would suit their busy schedule better.

Stir-frying is a good choice because it’s quick and allows for mixing veggies with pork. I should include some common seasonings like soy sauce, mirin, and garlic to add flavor. Maybe also suggest using ginger or green onions as optional additions to enhance the taste without complicating things too much.

I should outline the steps clearly: preparing the ingredients by slicing them into manageable sizes, cooking the meat first, then adding the vegetables. Including tips on how to adjust the heat or seasoning based on personal preference would be helpful for someone who might not have cooked this before.

Also, thinking about meal pairing, serving it over rice is a natural fit in Japanese cuisine, so I can mention that as an option. This makes the dish more filling and satisfying.

I need to keep the explanation simple but thorough enough for someone to follow without prior cooking experience. Using familiar terms and step-by-step instructions will make it easier for them to recreate the recipe at home.

シンキングの内容もすごいですね。
日本人や忙しそうだという所も意識して、考えてくれているようです。

・回答 Total:4’36”

キャベツ、人参、豚バラ肉を使って簡単にできるレシピはたくさんあります！例えば、「豚バラと野菜の炒め物」がおすすです。さっぱりとした味付けでヘルシーですし、具だくさんでお腹も満足します。

材料：

• 豚バラ肉：200g
• キャベツ：1/4個
• 人参：1本
• 長ねぎまたは玉ねぎ：適量（なくてもOK）
• 砂糖：小さじ1
• 酒：小さじ1
• 醤油：小さじ2
• 鍋用油：適量

手順：

1. 豚バラ肉を切る：薄切りにします。
2. 野菜を切る：キャベツは薄切り、人参はスリット（細長く削った形）または千切りにします。長ねぎも細切りにしてください。
3. 炒め物の仕込み：豚肉に砂糖、酒、醤油を混ぜて味を付けます。
4. 炒める：

• 鍋に油を熱し、豚肉を入れて軽く炒めます。
• 野菜を入れて一緒に炒めます。
• 全体がなじむように、強火でさっと炒めたら完成です！

チップス：

• 味付けの調整：醤油や酒の量を調節すれば、味濃いめやさっぱりめにもできます。
• 香辛料の追加：生姜チューブや刻み葱を入れると風味がアップします。

おすすめの組み合わせ：

• 米飯に乗せて食べるととてもおいしく感じます！

ぜひお試しください！ごちそうさま！

こちらは、一種類の提案ですが、かなり具体的に出してくれました。

４．猫を抱っこしている、メイちゃんイメージの画像生成用のプロンプトを日本語と英語で。

「gemma-2-27b-it-GGUF」 Total:１’3″

メイちゃんイメージ画像生成プロンプト

日本語:

美しい日本人女性「メイ」が、可愛い猫を抱っこしているイラスト。メイは20代後半、黒髪ロングヘアに、優しい笑顔。服装はシンプルなTシャツとジーンズ。背景は明るい室内。

English:

An illustration of Mei, a beautiful Japanese woman in her late 20s, holding a cute cat. Mei has long black hair and a gentle smile. She is wearing a simple T-shirt and jeans. The background is a bright indoor setting.

追加のポイント:

• 猫の種類、毛色などを指定するとより具体的にイメージを伝えられます。
• メイちゃんの表情やポーズも具体的に指示しましょう。
• atmosfer (雰囲気) や style (スタイル) を指定すると、画像のテイストを調整できます (例: 可愛い雰囲気, 水彩画風)。

日本人女性とか、２０代後半とか、髪型や服装など、具体的なプロンプトを考えてくれました。
このプロンプトをそのまま、Amuseの「iNiverse Mix XL」モデルに突っ込んでみます。

Image generation model ：iNiverse Mix XL /
Prompt generation :gemma-2-27b-it-GGUF

「優しい笑顔」のキーワードが効いているのか、笑顔がかわいいメイちゃんが出来上がりました。
壁に、漢字っぽい額があったり、なんとなく、和の雰囲気が出ています。
ただ、LLMには無関係ですが、猫の腕（足）が変ですね。
これは、画像生成Aiの問題ですが「Negative Prompt」でどうにかなると思います。

「DeepSeek-R1-Distill-Qwen-32B-GGUF」

・考える（Thought）42″

Okay, the user wants me to help generate image prompts for an illustration of “Mai-chan holding a cat.” They specified both Japanese and English versions. Let me start by understanding what they need.

First, Mai is described as a young Japanese woman with expertise in computers, IT, programming, and NC. She’s gentle and kind but has a strong resolve. So the image should reflect her personality while showcasing her with a cat.

I’ll break down the elements: Mai-chan, her appearance (maybe short hair, glasses), her expression (gentle smile), holding a cute cat, background details (like books or electronics to show her IT background). The overall vibe should be warm and harmonious.

For the Japanese prompt, I need to capture all these details clearly. Maybe start with the setting, then describe Mai’s features, her interaction with the cat, and the surrounding elements. Keep it vivid so the image generator can pick up on the nuances.

In English, I’ll translate those points but ensure they convey the same warmth and detail. Mentioning her expertise subtly through background items will help maintain the character’s depth without making it too literal.

I should also make sure both prompts are concise yet comprehensive, covering all aspects of Mai’s personality and surroundings to create a cohesive image.

メイちゃんがいつの間にかMai-chanになっているのは気になりますが
思考段階を翻訳してみると、やはりすごいです。
まず、system Promptから、メイちゃんの性格や外見を推測して、専門から背景を導きだしてます。
たぶん、「gemma」も、たった３行のsystem Promptから上のようなプロンプトをだしているので、内部的には、いろいろ推測していると思いますが、「deepseek」は「考える（Thought）」の内容も、表示してくれるので、その内容も興味深いです。

・回答 Total:2’45”

日本語プロンプト:

「猫を抱っこしているメイちゃんのイラスト。優しく穏やかな表情で、愛らしい猫を大切そうに抱いている姿。背景はシンプルで温かみのある空間。プログラミングやコンピュータ関連のアイテムがちらりと見える設定。全体的に柔らかい色合いと和谐感のあるイメージ。」

英語プロンプト:

“Illustration of Mai-chan holding a cat. A gentle and warm expression, carefully hugging a cute cat. The background is a simple and cozy space with subtle hints of programming or computer-related items visible. Overall soft color tones and a harmonious feel.”

こちらは、日本人とか、年齢などの指示はでてきませんでしたが、コンピュータ関連などの、システムプロンプトの内容が入ってきました。
ただ、「和谐感」という、わからない漢字が出てきましたが、英語のプロンプトを使うので画像生成にはあまり関係ないと思います。
こちらも、Amuseの「iNiverse Mix XL」モデルに突っ込んでみます。

Image generation model ：iNiverse Mix XL v1.1 /
Prompt generation :DeepSeek-R1-Distill-Qwen-32B-GGUF

日本人の指定はなかったですがsystem Promptから読み取り、「優しく穏やかな表情」というので、かなり清楚なメイちゃんになりました。
こちらも、LLMには関係ないですが、猫の腕（足）が変になりました。

感想

筆者が思いつく例題では、比較するにも、あまり差が見えませんでした。
ただ、最初にも書きましたが、「japanese」モデルは筆者の環境では、あまりよくなかったです。
また、「DeepSeek」は、回答の前に「考える」工程がありそうですが、その影響なのかは？？ですが、小さいモデルでは、時間の割にあまりいい結果にはなりませんでした。
コミュニケーションを楽しんだり、検索や翻訳サイトの延長で使う分には、「DeepSeek」を使う意味はあまり感じませんでした。
ただ、まずは「考える」と言うことで、質問内容によっては、時間がかかっても、大きめののモデルは試すのもありだと思います。
そういう意味では、オンラインの「DeepSeek」をやってみたいですが、ちょっと抵抗があります。