# ตรวจสอบเวอร์ชัน Python — ต้องขึ้นเลขเวอร์ชัน ไม่ใช่ข้อความ error
python --version

# ตรวจสอบ pip (ตัวจัดการไลบรารีที่มาพร้อม Python)
pip --version

# 1. สร้างโฟลเดอร์โปรเจกต์ แล้วเข้าไปข้างใน
mkdir ai-first-app
cd ai-first-app

# 2. สร้าง virtual environment ชื่อ .venv (จุดนำหน้าคือธรรมเนียม แปลว่าไฟล์ระบบ)
python -m venv .venv

# 3. เปิดใช้งาน venv  ---- เลือกบรรทัดตามระบบปฏิบัติการของคุณ ----
# Windows (PowerShell):
.venv\Scripts\Activate.ps1
# macOS / Linux:
source .venv/bin/activate

# 4. ยืนยันว่าเข้า venv แล้ว: บรรทัดเทอร์มินัลต้องขึ้นต้นด้วย (.venv)
# ถ้าเห็น (.venv) แปลว่าสำเร็จ

# 5. ติดตั้งไลบรารีตัวแรกที่จะใช้ในบทถัดไป
pip install openai python-dotenv

# 6. บันทึกรายการไลบรารีไว้ เพื่อให้คนอื่นติดตั้งตามได้เหมือนกันเป๊ะ
pip freeze > requirements.txt

import sys
import importlib.util

print("Python เวอร์ชัน:", sys.version.split()[0])

# ตรวจว่าอยู่ใน virtual environment จริงหรือไม่
in_venv = sys.prefix != sys.base_prefix
print("อยู่ใน venv:", "ใช่ ✅" if in_venv else "ไม่ใช่ ❌ (กลับไปทำขั้นที่ 3)")

# ตรวจว่าไลบรารีที่จำเป็นถูกติดตั้งแล้ว
for pkg in ["openai", "dotenv"]:
    found = importlib.util.find_spec(pkg) is not None
    print(f"ไลบรารี {pkg}:", "พร้อม ✅" if found else "ยังไม่ได้ติดตั้ง ❌")

# ===== ไฟล์ชื่อ .env  (จุดนำหน้า ห้ามลืม) =====
OPENAI_API_KEY=sk-วางคีย์จริงของคุณตรงนี้


# ===== ไฟล์ชื่อ .gitignore =====
.env
.venv/
__pycache__/

import os
from dotenv import load_dotenv
from openai import OpenAI

# โหลดค่าจากไฟล์ .env เข้าสู่ตัวแปรสภาพแวดล้อม
load_dotenv()

# อ่าน key จากสภาพแวดล้อม ไม่ใช่จากโค้ด
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
    raise SystemExit("ไม่พบ OPENAI_API_KEY — ตรวจสอบว่าสร้างไฟล์ .env แล้วหรือยัง")

client = OpenAI(api_key=api_key)

response = client.chat.completions.create(
    model="gpt-4o-mini",          # เลือกรุ่นที่ราคาถูกไว้ก่อนตอนทดสอบ
    messages=[
        # system = กำหนดบทบาทถาวร (คือ "องค์ประกอบที่ 1" จากบท 2.1 นั่นเอง)
        {"role": "system", "content": "คุณเป็นผู้ช่วยที่ตอบสั้น กระชับ เป็นภาษาไทย"},
        # user = คำถามของผู้ใช้
        {"role": "user", "content": "อธิบายว่า API คืออะไร ใน 2 ประโยค"},
    ],
    temperature=0.7,   # 0 = ตอบเหมือนเดิมทุกครั้ง / สูงขึ้น = สร้างสรรค์และสุ่มมากขึ้น
    max_tokens=200,    # เพดานความยาวคำตอบ = เพดานค่าใช้จ่ายต่อการเรียกหนึ่งครั้ง
)

# คำตอบซ่อนอยู่ลึกในโครงสร้างข้อมูลที่ตอบกลับมา
print(response.choices[0].message.content)

# ตรวจสอบว่าการเรียกครั้งนี้ใช้ token ไปเท่าไร (token คือหน่วยที่ใช้คิดเงิน)
print("\n--- ใช้ไป:", response.usage.total_tokens, "tokens")

import time
from openai import OpenAI, RateLimitError, APIError

def ask_ai(client, prompt, retries=3):
    """เรียก API พร้อมลองใหม่แบบหน่วงเวลาเพิ่มขึ้นเรื่อย ๆ (exponential backoff)"""
    for attempt in range(retries):
        try:
            r = client.chat.completions.create(
                model="gpt-4o-mini",
                messages=[{"role": "user", "content": prompt}],
                max_tokens=200,
            )
            return r.choices[0].message.content

        except RateLimitError:
            # เรียกถี่เกินไป หรือเครดิตหมด — รอแล้วลองใหม่
            wait = 2 ** attempt          # รอ 1, 2, 4 วินาที
            print(f"ถูกจำกัดอัตราการเรียก รออีก {wait} วินาที...")
            time.sleep(wait)

        except APIError as e:
            # ฝั่งผู้ให้บริการมีปัญหา — ไม่ใช่ความผิดของโค้ดเรา
            print("เซิร์ฟเวอร์มีปัญหา:", e)
            return None

    print("ลองครบ", retries, "ครั้งแล้วยังไม่สำเร็จ")
    return None

import os
from dotenv import load_dotenv
from openai import OpenAI, RateLimitError, APIError

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
    raise SystemExit("ไม่พบ OPENAI_API_KEY — ตรวจสอบไฟล์ .env")

client = OpenAI(api_key=api_key)

MODEL = "gpt-4o-mini"
SYSTEM_PROMPT = "คุณเป็นผู้ช่วยภาษาไทยที่ตอบกระชับ สุภาพ และซื่อสัตย์ ถ้าไม่รู้ให้บอกว่าไม่รู้"
MAX_TURNS = 10   # เก็บประวัติล่าสุดกี่รอบ (1 รอบ = คำถาม + คำตอบ)

# ประวัติเริ่มต้นมีแค่ system prompt ซึ่งจะไม่ถูกลบทิ้งเลย
history = [{"role": "system", "content": SYSTEM_PROMPT}]


def trim_history(msgs):
    """เก็บ system prompt ไว้เสมอ + เก็บเฉพาะข้อความล่าสุด MAX_TURNS*2 ข้อความ
    ป้องกันค่าใช้จ่ายบานปลายเมื่อคุยยาว"""
    system, rest = msgs[0], msgs[1:]
    return [system] + rest[-MAX_TURNS * 2:]


def ask(msgs):
    """เรียก API พร้อมจัดการข้อผิดพลาดพื้นฐาน"""
    try:
        r = client.chat.completions.create(
            model=MODEL, messages=msgs, temperature=0.7, max_tokens=500
        )
        return r.choices[0].message.content, r.usage.total_tokens
    except RateLimitError:
        return "(ถูกจำกัดอัตราการเรียก หรือเครดิตหมด — ลองใหม่อีกครั้ง)", 0
    except APIError as e:
        return f"(เซิร์ฟเวอร์มีปัญหา: {e})", 0


print("แชทบอทพร้อมแล้ว — พิมพ์ 'ออก' เพื่อจบการสนทนา\n")
total_tokens = 0

while True:
    user_input = input("คุณ: ").strip()
    if user_input in ("ออก", "exit", "quit"):
        print(f"\nจบการสนทนา ใช้ไปทั้งหมด {total_tokens} tokens")
        break
    if not user_input:
        continue

    history.append({"role": "user", "content": user_input})
    history = trim_history(history)

    reply, tokens = ask(history)
    total_tokens += tokens

    # เก็บคำตอบเข้าประวัติ เพื่อให้รอบถัดไปมีบริบท
    history.append({"role": "assistant", "content": reply})
    print(f"AI: {reply}\n")

pip install flask flask-cors

import os
from flask import Flask, request, jsonify, send_from_directory
from flask_cors import CORS
from dotenv import load_dotenv
from openai import OpenAI, RateLimitError, APIError

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
    raise SystemExit("ไม่พบ OPENAI_API_KEY — ตรวจสอบไฟล์ .env")

client = OpenAI(api_key=api_key)   # key อยู่ที่นี่เท่านั้น ไม่มีวันไปถึงเบราว์เซอร์
app = Flask(__name__)
CORS(app)   # อนุญาตให้หน้าเว็บเรียกได้ (ตอนพัฒนาในเครื่อง)

SYSTEM_PROMPT = "คุณเป็นผู้ช่วยภาษาไทยที่ตอบกระชับ สุภาพ และซื่อสัตย์"


@app.route("/")
def home():
    # ส่งหน้าเว็บ index.html ให้ผู้ใช้
    return send_from_directory(".", "index.html")


@app.route("/api/chat", methods=["POST"])
def chat():
    """รับข้อความจากหน้าเว็บ ส่งต่อให้ AI แล้วส่งคำตอบกลับ"""
    data = request.get_json()
    history = data.get("history", [])

    # ใส่ system prompt ไว้ต้นเสมอ (หน้าเว็บกำหนดบุคลิกบอทไม่ได้ กันการดัดแปลง)
    messages = [{"role": "system", "content": SYSTEM_PROMPT}] + history[-20:]

    try:
        r = client.chat.completions.create(
            model="gpt-4o-mini", messages=messages,
            temperature=0.7, max_tokens=500,
        )
        return jsonify({"reply": r.choices[0].message.content})
    except RateLimitError:
        return jsonify({"reply": "ระบบไม่ว่างชั่วคราว ลองใหม่อีกครั้ง"}), 429
    except APIError:
        return jsonify({"reply": "เกิดข้อผิดพลาดฝั่งเซิร์ฟเวอร์ AI"}), 502


if __name__ == "__main__":
    # debug=True เฉพาะตอนพัฒนา — ปิดเมื่อขึ้นใช้งานจริง
    app.run(port=5000, debug=True)

<!DOCTYPE html>
<html lang="th">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>แชท AI ของฉัน</title>
  <style>
    body{font-family:sans-serif;max-width:640px;margin:0 auto;padding:16px;background:#f8fafc}
    #log{height:60vh;overflow-y:auto;border:1px solid #e2e8f0;border-radius:12px;
         padding:16px;background:#fff;margin-bottom:12px}
    .msg{margin:8px 0;padding:10px 14px;border-radius:12px;max-width:80%;line-height:1.6}
    .user{background:#7B2FFD;color:#fff;margin-left:auto}
    .ai{background:#f1f5f9;color:#1e293b}
    form{display:flex;gap:8px}
    input{flex:1;padding:12px;border:1px solid #cbd5e1;border-radius:999px;font-size:15px}
    button{padding:12px 24px;background:#7B2FFD;color:#fff;border:none;
           border-radius:999px;font-size:15px;cursor:pointer}
    button:disabled{opacity:.5}
  </style>
</head>
<body>
  <h2>💬 แชท AI ของฉัน</h2>
  <div id="log"></div>
  <form id="chatForm">
    <input id="input" placeholder="พิมพ์ข้อความ..." autocomplete="off" required>
    <button type="submit">ส่ง</button>
  </form>

  <script>
    const log = document.getElementById('log');
    const form = document.getElementById('chatForm');
    const input = document.getElementById('input');
    const history = [];   // ความจำฝั่งหน้าเว็บ (เหมือนบท 11.1)

    function addMsg(text, who){
      const div = document.createElement('div');
      div.className = 'msg ' + who;
      div.textContent = text;
      log.appendChild(div);
      log.scrollTop = log.scrollHeight;
    }

    form.addEventListener('submit', async (e) => {
      e.preventDefault();
      const text = input.value.trim();
      if(!text) return;

      addMsg(text, 'user');
      history.push({role:'user', content:text});
      input.value = '';
      form.querySelector('button').disabled = true;

      try {
        // เรียก "เซิร์ฟเวอร์ของเรา" ไม่ใช่ AI โดยตรง — ไม่มี key ในหน้าเว็บ
        const res = await fetch('/api/chat', {
          method:'POST',
          headers:{'Content-Type':'application/json'},
          body: JSON.stringify({history})
        });
        const data = await res.json();
        addMsg(data.reply, 'ai');
        history.push({role:'assistant', content:data.reply});
      } catch(err) {
        addMsg('เชื่อมต่อเซิร์ฟเวอร์ไม่ได้ — เปิด server.py อยู่หรือเปล่า?', 'ai');
      } finally {
        form.querySelector('button').disabled = false;
        input.focus();
      }
    });
  </script>
</body>
</html>

# รันเซิร์ฟเวอร์ (venv ต้องเปิดอยู่)
python server.py

# แล้วเปิดเบราว์เซอร์ไปที่:
# http://localhost:5000

pip install openai python-dotenv numpy

import os, numpy as np
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# ---- ขั้นที่ 1: แบ่งเอกสารเป็นชิ้น ----
def load_and_chunk(path, size=500):
    """อ่านไฟล์ข้อความ แล้วตัดเป็นชิ้นละ ~size ตัวอักษร โดยพยายามตัดที่ย่อหน้า"""
    text = open(path, encoding="utf-8").read()
    paras = [p.strip() for p in text.split("\n\n") if p.strip()]
    chunks, buf = [], ""
    for p in paras:
        if len(buf) + len(p) < size:
            buf += "\n" + p
        else:
            if buf: chunks.append(buf.strip())
            buf = p
    if buf: chunks.append(buf.strip())
    return chunks

# ---- ขั้นที่ 2: ฝังข้อความเป็นเวกเตอร์ ----
def embed(texts):
    """แปลงลิสต์ข้อความเป็นเวกเตอร์ด้วยโมเดล embedding"""
    r = client.embeddings.create(model="text-embedding-3-small", input=texts)
    return np.array([d.embedding for d in r.data])

# ---- ขั้นที่ 3: ค้นหาชิ้นที่ใกล้ที่สุด ----
def search(query, chunks, chunk_vecs, top_k=3):
    """หา top_k ชิ้นที่ความหมายใกล้คำถามที่สุด (cosine similarity)"""
    q = embed([query])[0]
    # cosine = dot product ของเวกเตอร์ที่ normalize แล้ว
    sims = chunk_vecs @ q / (np.linalg.norm(chunk_vecs, axis=1) * np.linalg.norm(q))
    top = sims.argsort()[-top_k:][::-1]
    return [chunks[i] for i in top]

# ---- ขั้นที่ 4: ตอบจากชิ้นที่ค้นเจอ ----
def answer(query, context_chunks):
    context = "\n\n---\n\n".join(context_chunks)
    prompt = f"""ตอบคำถามโดยใช้เฉพาะข้อมูลในเอกสารด้านล่างเท่านั้น
ถ้าเอกสารไม่มีคำตอบ ให้บอกว่า "ไม่พบข้อมูลนี้ในเอกสาร" ห้ามเดา

เอกสาร:
{context}

คำถาม: {query}"""
    r = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,   # 0 เพื่อความคงที่ งานสกัดข้อมูลไม่ต้องการความสร้างสรรค์
    )
    return r.choices[0].message.content

# ---- ประกอบทั้งหมด ----
if __name__ == "__main__":
    chunks = load_and_chunk("my_document.txt")
    print(f"แบ่งเอกสารได้ {len(chunks)} ชิ้น กำลังฝังเวกเตอร์...")
    chunk_vecs = embed(chunks)          # ฝังครั้งเดียว เก็บไว้ใช้ซ้ำ

    while True:
        q = input("\nถาม (หรือ 'ออก'): ").strip()
        if q in ("ออก", "exit"): break
        found = search(q, chunks, chunk_vecs)
        print("\nคำตอบ:", answer(q, found))

pip install openai python-dotenv

import os, json
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# ---- เครื่องมือจริงที่โค้ดเรารัน (ไม่ใช่ AI) ----
PRICES = {"เสื้อยืด": 250, "กางเกง": 590, "รองเท้า": 1200}

def calculate(expression):
    """คำนวณนิพจน์เลขคณิตอย่างปลอดภัย"""
    allowed = "0123456789+-*/(). "
    if not all(c in allowed for c in expression):
        return "นิพจน์ไม่ปลอดภัย"
    return str(eval(expression))          # ปลอดภัยเพราะกรองอักขระแล้ว

def get_product_price(name):
    """ค้นราคาสินค้าจากฐานข้อมูลของร้าน"""
    return str(PRICES.get(name, "ไม่พบสินค้านี้"))

TOOL_FUNCS = {"calculate": calculate, "get_product_price": get_product_price}

# ---- คำอธิบายเครื่องมือที่ส่งให้ AI ----
tools = [
    {"type": "function", "function": {
        "name": "calculate",
        "description": "คำนวณนิพจน์เลขคณิต เช่น '1200*2+250*3'",
        "parameters": {"type": "object",
            "properties": {"expression": {"type": "string"}},
            "required": ["expression"]}}},
    {"type": "function", "function": {
        "name": "get_product_price",
        "description": "ค้นราคาสินค้าตามชื่อ",
        "parameters": {"type": "object",
            "properties": {"name": {"type": "string"}},
            "required": ["name"]}}},
]

def run_agent(question):
    messages = [{"role": "user", "content": question}]
    for _ in range(6):                    # จำกัดรอบ กันวนไม่รู้จบ
        r = client.chat.completions.create(
            model="gpt-4o-mini", messages=messages, tools=tools, temperature=0)
        msg = r.choices[0].message
        if not msg.tool_calls:            # AI ตอบเสร็จ ไม่ขอเครื่องมือเพิ่ม
            return msg.content
        messages.append(msg)              # เก็บคำขอเรียกเครื่องมือไว้
        for call in msg.tool_calls:       # รันทุกเครื่องมือที่ AI ขอ
            args = json.loads(call.function.arguments)
            result = TOOL_FUNCS[call.function.name](**args)
            messages.append({"role": "tool", "tool_call_id": call.id, "content": result})
    return "เกินจำนวนรอบที่กำหนด"

if __name__ == "__main__":
    print(run_agent("รองเท้า 2 คู่ กับเสื้อยืด 3 ตัว รวมเป็นเงินเท่าไร?"))

ollama run llama3.2

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",   # ชี้ไปที่ Ollama ในเครื่อง
    api_key="ollama",                        # ใส่อะไรก็ได้ Ollama ไม่ตรวจ
)

r = client.chat.completions.create(
    model="llama3.2",                        # โมเดลที่ pull ไว้
    messages=[{"role": "user", "content": "อธิบาย RAG ใน 2 ประโยค"}],
)
print(r.choices[0].message.content)

pip install fastapi uvicorn openai python-dotenv

import os
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
app = FastAPI(title="AI Service")

# อนุญาตเฉพาะเว็บของเรา (เปลี่ยนเป็นโดเมนจริงตอน deploy)
app.add_middleware(
    CORSMiddleware, allow_origins=["https://zzaxstudio.com"],
    allow_methods=["POST"], allow_headers=["*"],
)

class Ask(BaseModel):
    message: str

@app.post("/api/chat")
def chat(req: Ask):
    text = req.message.strip()
    if not text:
        raise HTTPException(400, "ข้อความว่าง")
    if len(text) > 1000:                       # จำกัดความยาว กันใช้เกิน
        raise HTTPException(400, "ข้อความยาวเกินไป")
    try:
        r = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": text}],
        )
        return {"reply": r.choices[0].message.content}
    except Exception:
        # ไม่เผยรายละเอียดภายในให้ผู้ใช้
        raise HTTPException(502, "บริการ AI ขัดข้องชั่วคราว")

uvicorn main:app --host 0.0.0.0 --port 8000

{"messages": [{"role": "system", "content": "คุณคือผู้ช่วยของร้าน ZZAX"}, {"role": "user", "content": "คืนสินค้าได้กี่วัน"}, {"role": "assistant", "content": "คืนได้ภายใน 7 วันครับ พร้อมใบเสร็จและป้ายสินค้า"}]}
{"messages": [{"role": "system", "content": "คุณคือผู้ช่วยของร้าน ZZAX"}, {"role": "user", "content": "ส่งฟรีไหม"}, {"role": "assistant", "content": "สั่งครบ 500 บาทส่งฟรีทั่วประเทศครับ"}]}

from openai import OpenAI
client = OpenAI()

f = client.files.create(file=open("data.jsonl", "rb"), purpose="fine-tune")
job = client.fine_tuning.jobs.create(
    training_file=f.id, model="gpt-4o-mini-2024-07-18")
print("เริ่มฝึกแล้ว:", job.id)
# รอสักพัก (เช็คสถานะที่ dashboard) เมื่อเสร็จจะได้ชื่อโมเดลใหม่
# เช่น ft:gpt-4o-mini:...:xxxx เอาไปใส่แทนชื่อโมเดลเดิมในโค้ดได้เลย

pip install peft transformers datasets trl

from peft import LoraConfig
from trl import SFTTrainer
from datasets import load_dataset

data = load_dataset("json", data_files="data.jsonl", split="train")
lora = LoraConfig(r=16, lora_alpha=32, task_type="CAUSAL_LM")  # r = ขนาดชั้นที่แทรก

trainer = SFTTrainer(
    model="meta-llama/Llama-3.2-3B",
    train_dataset=data,
    peft_config=lora,          # บรรทัดนี้ทำให้เป็นการฝึกแบบ LoRA
)
trainer.train()
trainer.save_model("my-lora-model")   # ได้ไฟล์ LoRA เล็ก ๆ ไม่กี่ MB

import base64
from openai import OpenAI
client = OpenAI()

def encode(path):
    with open(path, "rb") as f:
        return base64.b64encode(f.read()).decode()

img = encode("receipt.jpg")
r = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "ในภาพนี้มีอะไรบ้าง อธิบายสั้น ๆ"},
        {"type": "image_url",
         "image_url": {"url": f"data:image/jpeg;base64,{img}"}},
    ]}],
)
print(r.choices[0].message.content)

import json

prompt = """อ่านใบเสร็จในภาพ แล้วตอบเป็น JSON เท่านั้น รูปแบบ:
{"ร้าน": "", "วันที่": "", "รายการ": [{"ชื่อ": "", "ราคา": 0}], "รวม": 0}
ถ้าอ่านช่องไหนไม่ได้ ให้ใส่ null ห้ามเดา"""

r = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": prompt},
        {"type": "image_url",
         "image_url": {"url": f"data:image/jpeg;base64,{img}"}},
    ]}],
    response_format={"type": "json_object"},   # บังคับให้ตอบเป็น JSON
)
data = json.loads(r.choices[0].message.content)
print("ยอดรวม:", data["รวม"])

from openai import OpenAI
client = OpenAI()

def agent(system, user):
    """Agent หนึ่งตัว = system prompt เฉพาะทาง + งานที่รับ"""
    r = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "system", "content": system},
                  {"role": "user", "content": user}],
    )
    return r.choices[0].message.content

WRITER = "คุณคือนักเขียนคอนเทนต์ เขียนโพสต์สั้น กระชับ น่าสนใจ"
EDITOR = "คุณคือบรรณาธิการ ตรวจงานเขียน ชี้จุดที่ควรแก้ให้ชัดและกระชับขึ้น ตอบเป็นรายการสั้น ๆ"

def team(topic):
    draft = agent(WRITER, f"เขียนโพสต์เรื่อง: {topic}")
    notes = agent(EDITOR, f"ตรวจงานนี้:\n{draft}")
    final = agent(WRITER,
        f"ปรับงานตามคำแนะนำบรรณาธิการ\nงานเดิม:\n{draft}\n\nคำแนะนำ:\n{notes}")
    return final

if __name__ == "__main__":
    print(team("ประโยชน์ของการรัน AI บนเครื่องตัวเอง"))

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

fastapi
uvicorn
openai
python-dotenv

.env
__pycache__
*.pyc

services:
  ai-api:
    build: .
    ports:
      - "8000:8000"
    environment:
      # ดึงจาก env ของเครื่อง ไม่ฝังค่าจริงในไฟล์
      - OPENAI_API_KEY=${OPENAI_API_KEY}
    restart: unless-stopped

export OPENAI_API_KEY=sk-xxxx      # ตั้งในเชลล์ ไม่เขียนลงไฟล์ที่ commit
docker compose up -d --build