AI และ LLM สำหรับ Developer สอนใช้ OpenAI API, LangChain และ RAG สร้าง AI App 2026

ในปี 2026 AI และ Large Language Models (LLMs) ไม่ใช่แค่เทรนด์อีกต่อไป แต่กลายเป็นเครื่องมือพื้นฐานที่ Developer ทุกคนต้องรู้จักและใช้เป็น ตั้งแต่การสร้าง Chatbot อัจฉริยะ ระบบค้นหาเชิงความหมาย ไปจนถึง AI-powered Application ที่สร้างรายได้จริง

บทความนี้จะสอนคุณทุกอย่างที่ Developer ต้องรู้เกี่ยวกับการนำ AI/LLM มาใช้ในงานจริง ตั้งแต่ OpenAI API, Claude API, LangChain, RAG Architecture ไปจนถึง Vector Database และการสร้าง Production AI Application

AI/LLM Landscape สำหรับ Developer ปี 2026

ก่อนจะเริ่มเขียน Code มาทำความเข้าใจ Landscape ของ AI/LLM ที่ Developer ต้องรู้

ประเภทของ LLM

เลือก Model อย่างไร

• งาน Complex (Reasoning, Code Generation): GPT-4o, Claude Opus, Gemini Ultra
• งานทั่วไป (Chat, Summary, Translation): GPT-4o-mini, Claude Sonnet, Gemini Flash
• Privacy-sensitive: Local LLMs ผ่าน Ollama
• High Volume / Low Cost: GPT-4o-mini, Open Source Models
• Domain-specific: Fine-tuned Models

OpenAI API — พื้นฐานที่ต้องรู้

ติดตั้งและเริ่มต้น

# ติดตั้ง
pip install openai

# หรือ Node.js
npm install openai

Chat Completions — API หลัก

# Python
from openai import OpenAI

client = OpenAI(api_key="sk-...")  # หรือตั้ง OPENAI_API_KEY env

# Basic Chat Completion
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "คุณเป็นผู้เชี่ยวชาญด้านการเขียนโปรแกรม Python"},
        {"role": "user", "content": "อธิบาย List Comprehension ใน Python"}
    ],
    temperature=0.7,  # ความสร้างสรรค์ (0=แม่นยำ, 1=สร้างสรรค์)
    max_tokens=1000,
)

print(response.choices[0].message.content)
print(f"Tokens used: {response.usage.total_tokens}")

Streaming — แสดงผลแบบ Real-time

# Streaming Response (สำหรับ UI ที่แสดงทีละตัวอักษร)
stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "เขียนบทความเรื่อง Python สั้นๆ"}
    ],
    stream=True,
)

for chunk in stream:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)

Function Calling — ให้ AI เรียกฟังก์ชัน

import json

# กำหนด Tools/Functions ที่ AI สามารถเรียกได้
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "ดึงข้อมูลสภาพอากาศของเมืองที่ระบุ",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "ชื่อเมือง เช่น Bangkok, Chiang Mai"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "หน่วยอุณหภูมิ"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

# AI จะตัดสินใจว่าต้องเรียก Function ไหน
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "อากาศกรุงเทพวันนี้เป็นยังไง?"}],
    tools=tools,
    tool_choice="auto",
)

# ตรวจว่า AI ต้องการเรียก Function
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    print(f"AI ต้องการเรียก: {tool_call.function.name}")
    print(f"Arguments: {args}")

    # เรียก Function จริง
    weather_data = get_weather(args["city"])  # ฟังก์ชันของเรา

    # ส่งผลลัพธ์กลับให้ AI
    messages = [
        {"role": "user", "content": "อากาศกรุงเทพวันนี้เป็นยังไง?"},
        response.choices[0].message,
        {
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(weather_data)
        }
    ]
    final = client.chat.completions.create(model="gpt-4o", messages=messages)
    print(final.choices[0].message.content)

Structured Outputs — ได้ JSON ที่ต้องการ

from pydantic import BaseModel

class ProductReview(BaseModel):
    sentiment: str  # positive, negative, neutral
    score: float    # 0.0 - 1.0
    summary: str
    keywords: list[str]

response = client.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "วิเคราะห์รีวิวสินค้าแล้วตอบเป็น JSON"},
        {"role": "user", "content": "สินค้าดีมาก คุณภาพเยี่ยม ส่งไว แพ็คอย่างดี"}
    ],
    response_format=ProductReview,
)

review = response.choices[0].message.parsed
print(f"Sentiment: {review.sentiment}")
print(f"Score: {review.score}")
print(f"Keywords: {review.keywords}")

Anthropic Claude API

# pip install anthropic
from anthropic import Anthropic

client = Anthropic(api_key="sk-ant-...")

# Basic Message
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="คุณเป็นผู้เชี่ยวชาญด้านการเขียนโปรแกรม",
    messages=[
        {"role": "user", "content": "อธิบาย async/await ใน Python"}
    ]
)
print(message.content[0].text)

# Streaming
with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "เขียน Python decorator ตัวอย่าง"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# Tool Use (Function Calling)
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[{
        "name": "calculate",
        "description": "คำนวณสมการทางคณิตศาสตร์",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "สมการ เช่น 2+2"}
            },
            "required": ["expression"]
        }
    }],
    messages=[{"role": "user", "content": "คำนวณ 15% ของ 2500 บาท"}]
)

Local LLMs — Ollama และ llama.cpp

สำหรับงานที่ต้องการ Privacy หรือไม่อยากเสียค่า API สามารถรัน LLM บนเครื่องตัวเองได้

# ติดตั้ง Ollama (https://ollama.ai)
# macOS/Linux
curl -fsSL https://ollama.ai/install.sh | sh

# ดาวน์โหลดและรัน Model
ollama pull llama3.1:8b      # Meta Llama 3.1 8B
ollama pull mistral           # Mistral 7B
ollama pull codellama         # สำหรับ Code

# รัน Chat
ollama run llama3.1:8b

# ใช้ผ่าน API (OpenAI-compatible)
curl http://localhost:11434/v1/chat/completions \
  -d '{
    "model": "llama3.1:8b",
    "messages": [{"role": "user", "content": "Hello"}]
  }'

# ใช้ Ollama กับ OpenAI Python SDK (Compatible!)
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # ไม่จำเป็นแต่ต้องใส่
)

response = client.chat.completions.create(
    model="llama3.1:8b",
    messages=[{"role": "user", "content": "สอน Python OOP"}]
)
print(response.choices[0].message.content)

LangChain — Framework สำหรับ AI Application

LangChain เป็น Framework ที่ช่วยให้สร้าง AI Application ได้ง่ายขึ้น โดยจัดการ Prompt, Chain, Memory, Agent และ Tool Integration ให้

ติดตั้ง

pip install langchain langchain-openai langchain-community
pip install langchain-anthropic  # สำหรับ Claude

Basic Chain

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# สร้าง LLM instance
llm = ChatOpenAI(model="gpt-4o", temperature=0.7)

# สร้าง Prompt Template
prompt = ChatPromptTemplate.from_messages([
    ("system", "คุณเป็นผู้เชี่ยวชาญด้าน {topic}"),
    ("user", "{question}")
])

# สร้าง Chain (LCEL - LangChain Expression Language)
chain = prompt | llm | StrOutputParser()

# เรียกใช้
result = chain.invoke({
    "topic": "Python",
    "question": "อธิบาย Generator ใน Python"
})
print(result)

Memory — จำบทสนทนา

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

llm = ChatOpenAI(model="gpt-4o")

prompt = ChatPromptTemplate.from_messages([
    ("system", "คุณเป็น AI Assistant ที่ช่วยตอบคำถาม"),
    MessagesPlaceholder(variable_name="history"),
    ("user", "{input}")
])

chain = prompt | llm

# Store สำหรับเก็บประวัติ
store = {}

def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history",
)

# สนทนา — AI จะจำบริบทได้
config = {"configurable": {"session_id": "user123"}}
r1 = chain_with_history.invoke({"input": "ผมชื่อสมชาย"}, config=config)
r2 = chain_with_history.invoke({"input": "ผมชื่ออะไร?"}, config=config)
print(r2.content)  # "คุณชื่อสมชาย"

Agents — AI ที่ตัดสินใจและใช้ Tools

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.tools import tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# สร้าง Custom Tools
@tool
def search_database(query: str) -> str:
    """ค้นหาข้อมูลจาก Database ภายใน"""
    # จำลอง Database search
    return f"ผลลัพธ์สำหรับ '{query}': พบข้อมูล 5 รายการ..."

@tool
def calculate_price(base_price: float, discount_percent: float) -> str:
    """คำนวณราคาหลังหักส่วนลด"""
    final = base_price * (1 - discount_percent / 100)
    return f"ราคาหลังลด {discount_percent}%: {final:.2f} บาท"

# สร้าง Agent
llm = ChatOpenAI(model="gpt-4o")
tools = [search_database, calculate_price]

prompt = ChatPromptTemplate.from_messages([
    ("system", "คุณเป็น AI Shopping Assistant ช่วยค้นหาสินค้าและคำนวณราคา"),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("user", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Agent จะตัดสินใจเองว่าต้องเรียก Tool ไหน
result = executor.invoke({
    "input": "ค้นหาสินค้า iPhone 16 แล้วคำนวณราคาถ้าลด 15% จาก 45000 บาท"
})
print(result["output"])

RAG — Retrieval Augmented Generation

RAG เป็นเทคนิคที่สำคัญที่สุดสำหรับการสร้าง AI Application ที่ตอบคำถามจากข้อมูลของเราเอง แทนที่จะพึ่ง Knowledge ของ LLM อย่างเดียว

RAG Architecture

# ขั้นตอนของ RAG:
# 1. Ingestion (ครั้งเดียว):
#    เอกสาร → Chunk → Embedding → Vector Database
#
# 2. Query (ทุกครั้งที่ User ถาม):
#    คำถาม → Embedding → ค้นหา Vector DB → เอกสารที่เกี่ยวข้อง
#    → ส่งให้ LLM พร้อมคำถาม → คำตอบ

สร้าง RAG ด้วย LangChain

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import (
    PyPDFLoader, TextLoader, DirectoryLoader
)
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

# === ขั้นตอนที่ 1: Ingestion ===

# โหลดเอกสาร
loader = PyPDFLoader("company_handbook.pdf")
# หรือโหลดหลายไฟล์จากโฟลเดอร์
# loader = DirectoryLoader("./docs", glob="**/*.pdf", loader_cls=PyPDFLoader)
documents = loader.load()

# แบ่งเอกสารเป็น Chunks
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,      # ขนาด chunk (ตัวอักษร)
    chunk_overlap=200,    # overlap ระหว่าง chunks
    separators=["\n\n", "\n", " ", ""]
)
chunks = text_splitter.split_documents(documents)
print(f"แบ่งเป็น {len(chunks)} chunks")

# สร้าง Embeddings และเก็บใน Vector Store
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"  # เก็บบน Disk
)

# === ขั้นตอนที่ 2: Query ===

# สร้าง Retriever
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 5}  # ดึง 5 chunks ที่เกี่ยวข้องที่สุด
)

# สร้าง RAG Chain
llm = ChatOpenAI(model="gpt-4o", temperature=0)

prompt = ChatPromptTemplate.from_template("""
ตอบคำถามโดยใช้เฉพาะข้อมูลจาก Context ด้านล่าง
ถ้าไม่มีข้อมูลเพียงพอ ให้บอกว่าไม่ทราบ อย่าแต่งคำตอบขึ้นมาเอง

Context:
{context}

คำถาม: {question}

คำตอบ:
""")

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# ถามคำถาม
answer = rag_chain.invoke("นโยบายการลาป่วยของบริษัทเป็นอย่างไร?")
print(answer)

Vector Databases — เปรียบเทียบ

ตัวอย่าง pgvector

# ใช้ pgvector กับ PostgreSQL ที่มีอยู่แล้ว
# SQL: CREATE EXTENSION vector;

from langchain_community.vectorstores import PGVector

CONNECTION_STRING = "postgresql://user:pass@localhost:5432/mydb"

vectorstore = PGVector.from_documents(
    documents=chunks,
    embedding=embeddings,
    connection_string=CONNECTION_STRING,
    collection_name="company_docs",
)

# ค้นหา
results = vectorstore.similarity_search("วันลาพักร้อน", k=3)
for doc in results:
    print(doc.page_content[:200])

Embeddings คืออะไร?

Embedding คือการแปลงข้อความ (Text) เป็น Vector ตัวเลข (Array of floats) ที่คอมพิวเตอร์เข้าใจ โดยข้อความที่มีความหมายคล้ายกันจะมี Vector ที่อยู่ใกล้กันใน Vector Space

from openai import OpenAI
client = OpenAI()

# สร้าง Embedding
response = client.embeddings.create(
    model="text-embedding-3-small",
    input=["แมวนอนอยู่บนโซฟา", "สุนัขนอนบนเตียง", "Python programming"]
)

# ได้ Vector (1536 dimensions สำหรับ text-embedding-3-small)
vec1 = response.data[0].embedding  # แมว
vec2 = response.data[1].embedding  # สุนัข
vec3 = response.data[2].embedding  # Python

# คำนวณ Cosine Similarity
import numpy as np
def cosine_sim(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

print(f"แมว vs สุนัข: {cosine_sim(vec1, vec2):.4f}")   # สูง (คล้ายกัน)
print(f"แมว vs Python: {cosine_sim(vec1, vec3):.4f}")  # ต่ำ (ต่างกัน)

Prompt Engineering Techniques

การเขียน Prompt ที่ดีเป็นทักษะสำคัญสำหรับ Developer ที่ทำงานกับ LLM

เทคนิคสำคัญ

# 1. System Prompt — กำหนดบทบาทและกฎเกณฑ์
system_prompt = """คุณเป็น Senior Python Developer ที่เชี่ยวชาญ Django
กฎ:
- ตอบเป็นภาษาไทย
- แสดง Code ตัวอย่างเสมอ
- อธิบาย Best Practices
- เตือนเรื่อง Security ถ้าเกี่ยวข้อง"""

# 2. Few-shot Prompting — ให้ตัวอย่างก่อน
prompt = """จำแนกประเภทข้อความ:

ข้อความ: "สินค้าดีมาก ส่งไว"
ประเภท: positive

ข้อความ: "สินค้าเสีย ส่งช้ามาก"
ประเภท: negative

ข้อความ: "ได้รับของแล้ว"
ประเภท: neutral

ข้อความ: "คุณภาพไม่ตรงปก แต่ส่งเร็วดี"
ประเภท:"""

# 3. Chain of Thought — ให้คิดทีละขั้น
prompt = """วิเคราะห์โค้ด Python ต่อไปนี้ ทีละขั้นตอน:
1. อ่านโค้ดทั้งหมดก่อน
2. ระบุ Bug หรือปัญหาที่พบ
3. อธิบายสาเหตุของแต่ละปัญหา
4. เสนอวิธีแก้ไขพร้อม Code

โค้ด:
```python
def get_user(id):
    user = db.query(f"SELECT * FROM users WHERE id={id}")
    return user
```"""

# 4. Output Format Control
prompt = """วิเคราะห์ข้อมูลต่อไปนี้แล้วตอบในรูปแบบ JSON:
{
  "summary": "สรุปสั้นๆ",
  "sentiment": "positive/negative/neutral",
  "action_items": ["สิ่งที่ต้องทำ"],
  "priority": "high/medium/low"
}"""

สร้าง AI Chatbot พร้อม Context

from openai import OpenAI
from typing import List

class AIChatbot:
    def __init__(self, system_prompt: str, model: str = "gpt-4o"):
        self.client = OpenAI()
        self.model = model
        self.messages: List[dict] = [
            {"role": "system", "content": system_prompt}
        ]

    def chat(self, user_message: str) -> str:
        self.messages.append({"role": "user", "content": user_message})

        response = self.client.chat.completions.create(
            model=self.model,
            messages=self.messages,
            temperature=0.7,
        )

        assistant_message = response.choices[0].message.content
        self.messages.append({"role": "assistant", "content": assistant_message})

        return assistant_message

    def clear_history(self):
        self.messages = [self.messages[0]]  # เก็บ system prompt

# ใช้งาน
bot = AIChatbot(
    system_prompt="คุณเป็น AI ผู้ช่วยสำหรับร้านอาหารไทย ช่วยแนะนำเมนูและรับออเดอร์"
)

print(bot.chat("มีเมนูแนะนำอะไรบ้าง?"))
print(bot.chat("สั่งผัดกะเพรา 2 จาน ส้มตำ 1 จาน"))
print(bot.chat("รวมเป็นเท่าไหร่?"))  # AI จำบริบทได้

AI-Powered Search

from openai import OpenAI
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

class SemanticSearch:
    def __init__(self, collection_name: str):
        self.embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
        self.vectorstore = Chroma(
            collection_name=collection_name,
            embedding_function=self.embeddings,
            persist_directory="./search_db"
        )
        self.llm = OpenAI()

    def index_documents(self, documents: list[dict]):
        """เพิ่มเอกสารเข้า Index"""
        texts = [doc["content"] for doc in documents]
        metadatas = [{
            "title": doc["title"],
            "url": doc.get("url", ""),
            "category": doc.get("category", "")
        } for doc in documents]
        self.vectorstore.add_texts(texts, metadatas=metadatas)

    def search(self, query: str, k: int = 5) -> str:
        """ค้นหาเชิงความหมาย + สรุปด้วย AI"""
        # ค้นหา Vector
        results = self.vectorstore.similarity_search_with_score(query, k=k)

        # สร้าง Context จากผลลัพธ์
        context = "\n\n".join([
            f"[{doc.metadata.get('title', 'N/A')}] {doc.page_content}"
            for doc, score in results
        ])

        # ให้ AI สรุปผลลัพธ์
        response = self.llm.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "สรุปผลการค้นหาให้กระชับ อ้างอิงแหล่งที่มา"},
                {"role": "user", "content": f"คำค้น: {query}\n\nผลลัพธ์:\n{context}"}
            ]
        )
        return response.choices[0].message.content

# ใช้งาน
search = SemanticSearch("products")
search.index_documents([
    {"title": "iPhone 16 Pro", "content": "สมาร์ทโฟนรุ่นใหม่...", "category": "phone"},
    {"title": "MacBook Pro M4", "content": "แล็ปท็อปสำหรับมืออาชีพ...", "category": "laptop"},
])
result = search.search("โน้ตบุ๊คสำหรับเขียนโปรแกรม")
print(result)

Cost Optimization สำหรับ AI Application

เทคนิคลดค่าใช้จ่าย

# 1. Caching — ไม่ต้อง Call API ซ้ำ
import hashlib
import json
from functools import lru_cache

# Simple In-memory Cache
response_cache = {}

def cached_completion(messages: list, model: str = "gpt-4o"):
    cache_key = hashlib.md5(json.dumps(messages).encode()).hexdigest()
    if cache_key in response_cache:
        return response_cache[cache_key]

    response = client.chat.completions.create(model=model, messages=messages)
    result = response.choices[0].message.content
    response_cache[cache_key] = result
    return result

# 2. Model Selection — ใช้ Model ถูกก่อน
def smart_completion(messages: list):
    # ลองใช้ Model ถูกก่อน
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # ถูกกว่า 10x
        messages=messages,
    )
    result = response.choices[0].message.content

    # ถ้าคำตอบไม่ดีพอ (เช่น สั้นเกิน) ค่อยใช้ Model แพง
    if len(result) < 50 or "ไม่ทราบ" in result:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
        )
        result = response.choices[0].message.content

    return result

# 3. Token Management
# - ตัด Context ที่ไม่จำเป็น
# - ใช้ Summary แทน Full History
# - กำหนด max_tokens ให้เหมาะสม

# 4. Batch API — ลด Cost 50% (ไม่ต้องการ Real-time)
# OpenAI Batch API ให้ส่ง Requests เป็น Batch
# ประมวลผลภายใน 24 ชั่วโมง ราคาลดครึ่ง

AI Safety และ Guardrails

# 1. Input Validation — กรอง Input ที่อันตราย
def validate_input(user_input: str) -> bool:
    # ตรวจ Prompt Injection
    suspicious_patterns = [
        "ignore previous instructions",
        "ignore all rules",
        "system prompt",
        "reveal your instructions",
    ]
    lower_input = user_input.lower()
    return not any(p in lower_input for p in suspicious_patterns)

# 2. Output Moderation
def moderate_output(response: str) -> str:
    moderation = client.moderations.create(input=response)
    if moderation.results[0].flagged:
        return "ขออภัย ไม่สามารถแสดงเนื้อหานี้ได้"
    return response

# 3. Rate Limiting
from datetime import datetime, timedelta

class RateLimiter:
    def __init__(self, max_requests: int, window_seconds: int):
        self.max_requests = max_requests
        self.window = timedelta(seconds=window_seconds)
        self.requests: dict[str, list] = {}

    def is_allowed(self, user_id: str) -> bool:
        now = datetime.now()
        if user_id not in self.requests:
            self.requests[user_id] = []

        # ลบ Request เก่า
        self.requests[user_id] = [
            t for t in self.requests[user_id] if now - t < self.window
        ]

        if len(self.requests[user_id]) >= self.max_requests:
            return False

        self.requests[user_id].append(now)
        return True

limiter = RateLimiter(max_requests=10, window_seconds=60)

LlamaIndex — ทางเลือกของ LangChain

# pip install llama-index
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI

# โหลดเอกสาร (ง่ายมาก!)
documents = SimpleDirectoryReader("./docs").load_data()

# สร้าง Index
index = VectorStoreIndex.from_documents(documents)

# สร้าง Query Engine
query_engine = index.as_query_engine(
    llm=OpenAI(model="gpt-4o"),
    similarity_top_k=5,
)

# ถามคำถาม
response = query_engine.query("นโยบายการทำงานจากบ้านเป็นอย่างไร?")
print(response)
print(f"Sources: {response.source_nodes}")

Testing AI Applications

import pytest
from unittest.mock import patch, MagicMock

# 1. Mock LLM Responses สำหรับ Unit Tests
@patch('openai.OpenAI')
def test_chatbot_response(mock_openai):
    mock_client = MagicMock()
    mock_openai.return_value = mock_client
    mock_client.chat.completions.create.return_value = MagicMock(
        choices=[MagicMock(message=MagicMock(content="สวัสดีครับ"))]
    )

    bot = AIChatbot("test system prompt")
    result = bot.chat("สวัสดี")
    assert "สวัสดี" in result

# 2. Evaluation Metrics
def evaluate_rag_response(question: str, expected: str, actual: str) -> dict:
    """ประเมินคุณภาพคำตอบ RAG"""
    # Relevance — คำตอบเกี่ยวข้องกับคำถามไหม
    # Faithfulness — คำตอบตรงกับ Context ไหม (ไม่ Hallucinate)
    # Completeness — คำตอบครบถ้วนไหม

    eval_prompt = f"""ประเมินคำตอบ AI (0-10):
    คำถาม: {question}
    คำตอบที่คาดหวัง: {expected}
    คำตอบ AI: {actual}

    ให้คะแนน: relevance, faithfulness, completeness"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": eval_prompt}]
    )
    return response.choices[0].message.content

# 3. Regression Testing — ทดสอบชุดคำถามมาตรฐาน
test_cases = [
    {"q": "วันลาป่วยมีกี่วัน?", "expected_keywords": ["30", "วัน"]},
    {"q": "เงินเดือนออกวันไหน?", "expected_keywords": ["25", "ทุกเดือน"]},
]

def run_regression_tests(rag_chain):
    results = []
    for tc in test_cases:
        answer = rag_chain.invoke(tc["q"])
        passed = all(kw in answer for kw in tc["expected_keywords"])
        results.append({"question": tc["q"], "passed": passed, "answer": answer})
    return results

Production AI Architecture

# Production AI App Architecture
# ┌─────────────────────────────────────────┐
# │              Frontend (React/Next.js)    │
# │  Chat UI | Search UI | Dashboard        │
# └────────────────┬────────────────────────┘
#                  │ REST/WebSocket
# ┌────────────────▼────────────────────────┐
# │            API Server (FastAPI)          │
# │  Rate Limiting | Auth | Input Validation │
# └────────────────┬────────────────────────┘
#                  │
# ┌────────────────▼────────────────────────┐
# │          AI Orchestration Layer          │
# │  LangChain/LlamaIndex | Prompt Mgmt     │
# │  Caching | Model Router | Guardrails    │
# └──┬──────────┬──────────┬────────────────┘
#    │          │          │
# ┌──▼──┐  ┌───▼───┐  ┌──▼──────────┐
# │ LLM │  │Vector │  │  Database   │
# │ API │  │  DB   │  │ (PostgreSQL)│
# └─────┘  └───────┘  └─────────────┘

# FastAPI + AI Example
from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel

app = FastAPI()

class ChatRequest(BaseModel):
    message: str
    session_id: str

@app.post("/api/chat")
async def chat(req: ChatRequest):
    if not validate_input(req.message):
        raise HTTPException(400, "Invalid input")

    if not limiter.is_allowed(req.session_id):
        raise HTTPException(429, "Rate limit exceeded")

    response = rag_chain.invoke(req.message)
    return {"response": response}

@app.post("/api/chat/stream")
async def chat_stream(req: ChatRequest):
    async def generate():
        stream = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": req.message}],
            stream=True,
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield f"data: {chunk.choices[0].delta.content}\n\n"
    return StreamingResponse(generate(), media_type="text/event-stream")

สรุป

AI และ LLM ได้เปลี่ยนวิธีที่เราสร้าง Software ไปอย่างสิ้นเชิง ในปี 2026 Developer ที่เข้าใจการใช้ AI API, สร้าง RAG System, และออกแบบ AI Application ที่ปลอดภัยและคุ้มค่า จะมีข้อได้เปรียบอย่างมากในตลาดแรงงาน

เทคโนโลยีหลักที่ควรเรียนรู้: OpenAI API สำหรับ Cloud LLM, Ollama สำหรับ Local LLM, LangChain สำหรับ Orchestration, RAG + Vector Database สำหรับ Knowledge-augmented AI และ Prompt Engineering สำหรับการควบคุมคุณภาพ Output

เริ่มต้นง่ายๆ ด้วยการสร้าง Chatbot ง่ายๆ ด้วย OpenAI API แล้วค่อยๆ เพิ่ม RAG, Agents และ Tools เข้าไป เมื่อเข้าใจพื้นฐานแล้ว คุณจะสามารถสร้าง AI Application ที่แก้ปัญหาจริงในธุรกิจได้อย่างมั่นใจ