LangGraph Agent × HolySheep AI: สอนสร้าง State Machine แบบ Production-Grade พร้อม Budget Monitoring

ในโลกของ AI Agent ปี 2026 การสร้างระบบ Multi-Step Agent ที่ทำงานได้จริงใน Production ไม่ใช่เรื่องง่าย หลายคนปวดหัวกับการจัดการ State ที่หลุด การ Retry Node ที่ล้มเหลว และการ Monitor ค่าใช้จ่าย API ที่พุ่งไม่หยุด

บทความนี้ผมจะพาทุกคนสร้าง LangGraph Agent ที่เชื่อมต่อกับ HolySheep AI ซึ่งมีต้นทุนต่ำกว่า OpenAI ถึง 95%+ พร้อม State Persistence, Node Retry และ Unified API Key Monitoring แบบครบวงจร

ทำไมต้อง HolySheep AI สำหรับ LangGraph Agent?

ก่อนจะเข้าสู่เนื้อหาเทคนิค มาดูตัวเลขจริงที่สำคัญมากสำหรับ Production System:

เปรียบเทียบต้นทุน API ปี 2026 (Output Token)

โมเดล	ราคา/MTok	10M Tokens/เดือน	ต่ำสุดในตลาด?
GPT-4.1	$8.00	$80.00	❌
Claude Sonnet 4.5	$15.00	$150.00	❌
Gemini 2.5 Flash	$2.50	$25.00	❌
DeepSeek V3.2 (HolySheep)	$0.42	$4.20	✅ ถูกที่สุด

สรุปการประหยัด: ใช้ DeepSeek V3.2 ผ่าน HolySheep แทน Claude Sonnet 4.5 ประหยัดได้ $145.80/เดือน หรือ 97%!

เริ่มต้นโปรเจกต์: Project Structure

langgraph-holysheep/
├── app/
│   ├── __init__.py
│   ├── main.py              # Entry point
│   ├── agents/
│   │   ├── __init__.py
│   │   ├── supervisor.py    # Supervisor Agent
│   │   ├── researcher.py    # Research Node
│   │   └── writer.py        # Writing Node
│   ├── state/
│   │   ├── __init__.py
│   │   └── persistence.py   # SQLite + Redis persistence
│   └── monitoring/
│       ├── __init__.py
│       └── api_tracker.py   # Budget & usage monitoring
├── tests/
├── .env
├── requirements.txt
└── README.md

ติดตั้ง Dependencies

# requirements.txt
langgraph>=0.2.0
langgraph-checkpoint>=2.0.0
openai>=1.50.0
redis>=5.0.0
sqlalchemy>=2.0.0
python-dotenv>=1.0.0
pydantic>=2.0.0
httpx>=0.27.0

# ติดตั้งด้วย pip
pip install -r requirements.txt

สร้างไฟล์ .env
cat > .env << 'EOF'
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
REDIS_URL=redis://localhost:6379
DATABASE_URL=sqlite:///./data/agent_state.db
MONTHLY_BUDGET_USD=50.00
LOG_LEVEL=INFO
EOF

Configuration และ HolySheep Client Setup

# app/config.py
import os
from pathlib import Path
from pydantic_settings import BaseSettings
from dotenv import load_dotenv

load_dotenv()

class Settings(BaseSettings):
    # HolySheep API Configuration
    # ⚠️ base_url ต้องเป็น https://api.holysheep.ai/v1 เท่านั้น
    HOLYSHEEP_BASE_URL: str = "https://api.holysheep.ai/v1"
    HOLYSHEEP_API_KEY: str
    
    # Model Configuration
    DEFAULT_MODEL: str = "deepseek-chat"  # DeepSeek V3.2
    FALLBACK_MODEL: str = "gpt-4o"
    
    # Persistence Configuration
    REDIS_URL: str = "redis://localhost:6379"
    DATABASE_URL: str = "sqlite:///./data/agent_state.db"
    
    # Budget Configuration
    MONTHLY_BUDGET_USD: float = 50.00
    TOKENS_PER_DOLLAR: dict = {
        "deepseek-chat": 1 / 0.00042,    # $0.42/MTok
        "gpt-4o": 1 / 0.008,              # $8/MTok
    }
    
    class Config:
        env_file = ".env"
        extra = "allow"

settings = Settings()

Validate configuration
def validate_config():
    """Validate critical configuration settings"""
    errors = []
    
    if settings.HOLYSHEEP_API_KEY == "YOUR_HOLYSHEEP_API_KEY":
        errors.append("❌ กรุณาตั้งค่า HOLYSHEEP_API_KEY ในไฟล์ .env")
    
    if "api.openai.com" in settings.HOLYSHEEP_BASE_URL or \
       "api.anthropic.com" in settings.HOLYSHEEP_BASE_URL:
        errors.append("❌ base_url ต้องเป็น https://api.holysheep.ai/v1 เท่านั้น")
    
    if errors:
        raise ValueError("\n".join(errors))
    
    return True

validate_config()
print(f"✅ Configuration validated")
print(f"📍 API Endpoint: {settings.HOLYSHEEP_BASE_URL}")
print(f"💰 Budget: ${settings.MONTHLY_BUDGET_USD}/เดือน")

State Machine Definition พร้อม Persistence

# app/agents/state.py
from typing import TypedDict, Annotated, Literal
from langgraph.graph import StateGraph, END
import operator

class AgentState(TypedDict):
    """Shared state สำหรับทุก node ใน graph"""
    
    # Conversation context
    messages: Annotated[list, operator.add]
    
    # Task management
    current_task: str | None
    completed_tasks: list[str]
    failed_tasks: list[str]
    
    # Research data
    research_results: dict
    
    # Writing output
    draft_content: str | None
    final_output: str | None
    
    # Retry tracking
    retry_count: dict
    node_errors: dict
    
    # Budget tracking
    tokens_used: int
    cost_accumulated: float
    
    # Metadata
    session_id: str
    user_id: str

def create_initial_state(session_id: str, user_id: str = "default") -> AgentState:
    """สร้าง initial state สำหรับเริ่ม conversation ใหม่"""
    return AgentState(
        messages=[],
        current_task=None,
        completed_tasks=[],
        failed_tasks=[],
        research_results={},
        draft_content=None,
        final_output=None,
        retry_count={},
        node_errors={},
        tokens_used=0,
        cost_accumulated=0.0,
        session_id=session_id,
        user_id=user_id
    )

Supervisor Agent พร้อม LLM Calls

# app/agents/supervisor.py
from app.config import settings
from openai import OpenAI
import httpx
from typing import Optional

class HolySheepClient:
    """
    HolySheep AI Client - OpenAI Compatible
    base_url: https://api.holysheep.ai/v1
    """
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        # ⚠️ สำคัญ: base_url ต้องเป็น https://api.holysheep.ai/v1
        self.base_url = "https://api.holysheep.ai/v1"
        
        self.client = OpenAI(
            api_key=self.api_key,
            base_url=self.base_url,
            http_client=httpx.Client(
                timeout=60.0,
                follow_redirects=True
            )
        )
    
    def chat_completion(
        self,
        messages: list,
        model: str = "deepseek-chat",
        temperature: float = 0.7,
        max_tokens: int = 4096,
        **kwargs
    ) -> dict:
        """
        ส่ง request ไปยัง HolySheep API
        รองรับทุกโมเดล: DeepSeek, GPT, Claude ผ่าน unified API
        """
        response = self.client.chat.completions.create(
            model=model,
            messages=messages,
            temperature=temperature,
            max_tokens=max_tokens,
            **kwargs
        )
        
        return {
            "content": response.choices[0].message.content,
            "usage": {
                "prompt_tokens": response.usage.prompt_tokens,
                "completion_tokens": response.usage.completion_tokens,
                "total_tokens": response.usage.total_tokens
            },
            "model": response.model,
            "finish_reason": response.choices[0].finish_reason
        }

Singleton instance
_client: Optional[HolySheepClient] = None

def get_holysheep_client() -> HolySheepClient:
    global _client
    if _client is None:
        _client = HolySheepClient(api_key=settings.HOLYSHEEP_API_KEY)
    return _client

def supervisor_node(state: dict) -> dict:
    """
    Supervisor Agent: ตัดสินใจว่าจะไป node ไหนต่อ
    """
    client = get_holysheep_client()
    
    messages = state["messages"]
    current_task = state.get("current_task")
    
    system_prompt = """คุณคือ Supervisor Agent ที่ทำหน้าที่ตัดสินใจว่าจะให้ทำขั้นตอนอะไรต่อไป

ตัวเลือก:
1. "research" - ค้นหาข้อมูลเพิ่มเติม
2. "write" - เขียนเนื้อหาจากข้อมูลที่มี
3. "review" - ตรวจสอบและแก้ไข
4. "finish" - เสร็จสิ้นกระบวนการ

ตอบเฉพาะคำว่า: research, write, review, หรือ finish"""
    
    response = client.chat_completion(
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": f"Task: {current_task}\n\nHistory: {messages[-3:]}"}
        ],
        model="deepseek-chat",
        temperature=0.3,
        max_tokens=50
    )
    
    next_step = response["content"].strip().lower()
    
    # Update tokens used
    state["tokens_used"] += response["usage"]["total_tokens"]
    state["cost_accumulated"] += calculate_cost(response["usage"]["total_tokens"])
    
    return {
        "messages": [response["content"]],
        "next_step": next_step
    }

def calculate_cost(tokens: int, model: str = "deepseek-chat") -> float:
    """คำนวณค่าใช้จ่ายจริงจากจำนวน tokens"""
    price_per_mtok = {
        "deepseek-chat": 0.42,    # $0.42/MTok
        "gpt-4o": 8.0,             # $8/MTok
    }
    return (tokens / 1_000_000) * price_per_mtok.get(model, 8.0)

Research Node พร้อม Retry Logic

# app/agents/researcher.py
from app.agents.supervisor import get_holysheep_client, calculate_cost
from typing import Optional
import time

class RetryableError(Exception):
    """Custom exception สำหรับ errors ที่ควร retry"""
    pass

def researcher_node(state: dict, max_retries: int = 3) -> dict:
    """
    Research Node: ค้นหาข้อมูลจาก web และ knowledge base
    พร้อม exponential backoff retry
    """
    client = get_holysheep_client()
    current_task = state.get("current_task", "")
    retry_count = state.get("retry_count", {}).get("researcher", 0)
    
    # Exponential backoff: 1s, 2s, 4s
    backoff_time = (2 ** retry_count)
    
    try:
        response = client.chat_completion(
            messages=[
                {"role": "system", "content": "คุณคือ Research Agent ที่ค้นหาข้อมูลอย่างละเอียด"},
                {"role": "user", "content": f"ค้นหาข้อมูลเกี่ยวกับ: {current_task}"}
            ],
            model="deepseek-chat",
            temperature=0.5,
            max_tokens=2048
        )
        
        research_data = {
            "topic": current_task,
            "findings": response["content"],
            "sources": extract_sources(response["content"]),
            "timestamp": time.time()
        }
        
        # Update state
        state["research_results"] = research_data
        state["tokens_used"] += response["usage"]["total_tokens"]
        state["cost_accumulated"] += calculate_cost(
            response["usage"]["total_tokens"]
        )
        state["completed_tasks"].append("research")
        
        return {"research_results": research_data, "completed_tasks": state["completed_tasks"]}
        
    except RetryableError as e:
        if retry_count < max_retries:
            print(f"⏳ Retrying researcher (attempt {retry_count + 1}/{max_retries}) after {backoff_time}s")
            time.sleep(backoff_time)
            
            new_retry_count = state.get("retry_count", {})
            new_retry_count["researcher"] = retry_count + 1
            
            return {"retry_count": new_retry_count, "node_errors": {"researcher": str(e)}}
        else:
            state["failed_tasks"].append("research")
            state["node_errors"]["researcher"] = f"Max retries exceeded: {str(e)}"
            return state
            
    except Exception as e:
        state["failed_tasks"].append("research")
        state["node_errors"]["researcher"] = str(e)
        return state

def extract_sources(content: str) -> list[str]:
    """Extract URLs หรือ references จาก content"""
    import re
    url_pattern = r'https?://[^\s<>"{}|\\^`\[\]]+'
    return re.findall(url_pattern, content)

Writer Node และ Review Node

# app/agents/writer.py
from app.agents.supervisor import get_holysheep_client, calculate_cost
from typing import Optional

def writer_node(state: dict) -> dict:
    """
    Writer Node: เขียนเนื้อหาจาก research results
    """
    client = get_holysheep_client()
    research = state.get("research_results", {})
    findings = research.get("findings", "ไม่มีข้อมูล")
    
    response = client.chat_completion(
        messages=[
            {"role": "system", "content": """คุณคือ Professional Writer Agent
เขียนเนื้อหาที่มีคุณภาพสูง กระชับ และมีประโยชน์"""},
            {"role": "user", "content": f"""เขียนบทความจากข้อมูลต่อไปนี้:

{findings}

คำแนะนำ:
- ใช้ภาษาที่เข้าใจง่าย
- มีหัวข้อที่ชัดเจน
- มีตัวอย่างประกอบ"""}
        ],
        model="deepseek-chat",
        temperature=0.7,
        max_tokens=4096
    )
    
    state["draft_content"] = response["content"]
    state["tokens_used"] += response["usage"]["total_tokens"]
    state["cost_accumulated"] += calculate_cost(response["usage"]["total_tokens"])
    state["completed_tasks"].append("write")
    
    return {"draft_content": response["content"]}

def review_node(state: dict) -> dict:
    """
    Review Node: ตรวจสอบคุณภาพและแก้ไข
    """
    client = get_holysheep_client()
    draft = state.get("draft_content", "")
    
    response = client.chat_completion(
        messages=[
            {"role": "system", "content": "คุณคือ Senior Editor ที่ตรวจสอบคุณภาพงานเขียน"},
            {"role": "user", "content": f"ตรวจสอบและปรับปรุงเนื้อหาต่อไปนี้:\n\n{draft}"}
        ],
        model="deepseek-chat",
        temperature=0.5,
        max_tokens=4096
    )
    
    state["final_output"] = response["content"]
    state["tokens_used"] += response["usage"]["total_tokens"]
    state["cost_accumulated"] += calculate_cost(response["usage"]["total_tokens"])
    state["completed_tasks"].append("review")
    
    return {"final_output": response["content"]}

Graph Construction พร้อม Persistence

# app/agents/graph.py
from app.agents.state import AgentState, create_initial_state
from app.agents.supervisor import supervisor_node
from app.agents.researcher import researcher_node
from app.agents.writer import writer_node, review_node
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.sqlite import SqliteSaver
from langgraph.checkpoint.redis import RedisSaver
from app.config import settings
import redis

class PersistentAgentGraph:
    """
    LangGraph Agent พร้อม State Persistence
    รองรับ SQLite และ Redis
    """
    
    def __init__(self, use_redis: bool = False):
        self.use_redis = use_redis
        self.checkpointer = self._setup_checkpointer()
        self.graph = self._build_graph()
        
    def _setup_checkpointer(self):
        """Setup checkpoint storage"""
        if self.use_redis:
            # Redis for distributed systems
            r = redis.from_url(settings.REDIS_URL)
            return RedisSaver(r)
        else:
            # SQLite for single instance
            return SqliteSaver.from_conn_string("./data/agent_state.db")
    
    def _build_graph(self) -> StateGraph:
        """Build LangGraph workflow"""
        
        workflow = StateGraph(AgentState)
        
        # Register nodes
        workflow.add_node("supervisor", supervisor_node)
        workflow.add_node("researcher", researcher_node)
        workflow.add_node("writer", writer_node)
        workflow.add_node("reviewer", review_node)
        
        # Define routing function
        def should_continue(state: dict) -> str:
            """กำหนดว่าจะไป node ไหนต่อ"""
            next_step = state.get("next_step", "supervisor")
            
            if next_step == "research":
                return "researcher"
            elif next_step == "write":
                return "writer"
            elif next_step == "review":
                return "reviewer"
            else:
                return END
        
        # Set entry point
        workflow.set_entry_point("supervisor")
        
        # Add conditional edges
        workflow.add_conditional_edges(
            "supervisor",
            should_continue,
            {
                "researcher": "researcher",
                "writer": "writer",
                "reviewer": "reviewer",
                END: END
            }
        )
        
        # All nodes return to supervisor for next decision
        workflow.add_edge("researcher", "supervisor")
        workflow.add_edge("writer", "supervisor")
        workflow.add_edge("reviewer", "supervisor")
        
        # Compile with checkpointer
        return workflow.compile(checkpointer=self.checkpointer)

Usage Example
def run_agent(session_id: str, task: str):
    """Run agent with persistence"""
    
    agent = PersistentAgentGraph(use_redis=False)
    
    # Create initial state
    initial_state = create_initial_state(session_id=session_id)
    initial_state["current_task"] = task
    
    # Run with thread_id (for persistence)
    config = {"configurable": {"thread_id": session_id}}
    
    # Stream results
    for event in agent.graph.stream(initial_state, config):
        print(f"📍 Event: {event}")
    
    # Get final state
    final_state = agent.graph.get_state(config)
    return final_state

Unified API Key Monitoring System

# app/monitoring/api_tracker.py
from app.config import settings
from datetime import datetime, timedelta
from typing import Optional
import sqlite3
import threading
from dataclasses import dataclass, field
from collections import defaultdict
import time

@dataclass
class UsageRecord:
    """Record การใช้งาน API สำหรับ billing"""
    timestamp: datetime
    model: str
    prompt_tokens: int
    completion_tokens: int
    total_tokens: int
    cost_usd: float
    session_id: str
    node_name: str

class APIMonitor:
    """
    Unified API Key Monitoring System
    Track usage, budget alerts, และ cost optimization
    """
    
    def __init__(self, db_path: str = "./data/api_usage.db"):
        self.db_path = db_path
        self._lock = threading.Lock()
        self._session_usage = defaultdict(int)
        self._daily_usage = defaultdict(float)
        self._setup_database()
        
    def _setup_database(self):
        """Initialize SQLite database for usage tracking"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS api_usage (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp TEXT NOT NULL,
                model TEXT NOT NULL,
                prompt_tokens INTEGER,
                completion_tokens INTEGER,
                total_tokens INTEGER,
                cost_usd REAL,
                session_id TEXT,
                node_name TEXT,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        """)
        
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS budget_alerts (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp TEXT NOT NULL,
                budget_type TEXT,
                threshold_percent REAL,
                actual_spend REAL,
                alerted BOOLEAN DEFAULT FALSE
            )
        """)
        
        cursor.execute("""
            CREATE INDEX IF NOT EXISTS idx_session 
            ON api_usage(session_id)
        """)
        
        cursor.execute("""
            CREATE INDEX IF NOT EXISTS idx_timestamp 
            ON api_usage(timestamp)
        """)
        
        conn.commit()
        conn.close()
        
    def track_usage(
        self,
        model: str,
        prompt_tokens: int,
        completion_tokens: int,
        session_id: str,
        node_name: str
    ) -> UsageRecord:
        """Track API usage and calculate cost"""
        
        total_tokens = prompt_tokens + completion_tokens
        
        # Calculate cost based on model
        price_per_mtok = {
            "deepseek-chat": 0.42,    # $0.42/MTok
            "gpt-4o": 8.0,             # $8/MTok
            "gpt-4-turbo": 10.0,       # $10/MTok
        }
        
        price = price_per_mtok.get(model, 8.0)
        cost_usd = (total_tokens / 1_000_000) * price
        
        record = UsageRecord(
            timestamp=datetime.now(),
            model=model,
            prompt_tokens=prompt_tokens,
            completion_tokens=completion_tokens,
            total_tokens=total_tokens,
            cost_usd=cost_usd,
            session_id=session_id,
            node_name=node_name
        )
        
        # Save to database
        self._save_record(record)
        
        # Update in-memory counters
        with self._lock:
            self._session_usage[session_id] += cost_usd
            today = datetime.now().strftime("%Y-%m-%d")
            self._daily_usage[today] += cost_usd
            
        # Check budget threshold
        self._check_budget_alert(cost_usd)
        
        return record
    
    def _save_record(self, record: UsageRecord):
        """Save usage record to database"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute("""
            INSERT INTO api_usage 
            (timestamp, model, prompt_tokens, completion_tokens, 
             total_tokens, cost_usd, session_id, node_name)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        """, (
            record.timestamp.isoformat(),
            record.model,
            record.prompt_tokens,
            record.completion_tokens,
            record.total_tokens,
            record.cost_usd,
            record.session_id,
            record.node_name
        ))
        
        conn.commit()
        conn.close()
    
    def _check_budget_alert(self, new_cost: float):
        """Check if spending exceeds budget thresholds"""
        
        today = datetime.now().strftime("%Y-%m-%d")
        today_spend = self._daily_usage[today]
        
        thresholds = [0.5, 0.75, 0.90, 1.0]  # 50%, 75%, 90%, 100%
        
        for threshold in thresholds:
            alert_level = threshold * settings.MONTHLY_BUDGET_USD
            if today_spend >= alert_level and (today_spend - new_cost) < alert_level:
                print(f"⚠️  คำเตือน: ใช้งานเกิน {int(threshold*100)}% ของงบประมาณ")
                print(f"   งบประมาณ: ${settings.MONTHLY_BUDGET_USD}")
                print(f"   ใช้ไปแล้ว: ${today_spend:.2f}")
    
    def get_usage_report(
        self, 
        session_id: Optional[str] = None,
        days: int = 30
    ) -> dict:
        """Generate usage report"""
        
        conn = sqlite3.connect(self.db_path)
        
        if session_id:
            query = """
                SELECT 
                    model,
                    SUM(total_tokens) as total_tokens,
                    SUM(cost_usd) as total_cost,
                    COUNT(*) as request_count
                FROM api_usage
                WHERE session_id = ?
                GROUP BY model
            """
            df = pd.read_sql_query(query, conn, params=(session_id,))
        else:
            start_date = (datetime.now() - timedelta(days=days)).isoformat()
            query = """
                SELECT 
                    model,
                    SUM(total_tokens) as total_tokens,
                    SUM(cost_usd) as total_cost,
                    COUNT(*) as request_count
                FROM api_usage
                WHERE timestamp >= ?
                GROUP BY model
            """
            df = pd.read_sql_query(query, conn, params=(start_date,))
        
        conn.close()
        
        return {
            "summary": df.to_dict(orient="records") if not df.empty else [],
            "total_cost": df["total_cost"].sum() if not df.empty else 0,
            "total_tokens": df["total_tokens"].sum() if not df.empty else 0,
            "request_count": df["request_count"].sum() if not df.empty else 0
        }

Singleton instance
api_monitor = APIMonitor()

Main Application Entry Point

# app/main.py
from app.agents.graph import PersistentAgentGraph, run_agent
from app.monitoring.api_tracker import api_monitor
from app.agents.state import create_initial_state
from app.config import settings
import uuid

async def main():
    """Main entry point สำหรับ LangGraph Agent"""
    
    print("=" * 60)
    print("🚀 HolySheep AI × LangGraph Agent")
    print("=" * 60)
    print(f"📍 API Endpoint: {settings.HOLYSHEEP_BASE_URL}")
    print(f"💰 Budget: ${settings.MONTHLY_BUDGET_USD}/เดือน")
    print(f"⚡ Latency target: <50ms")
    print("=" * 60)
    
    # Generate session ID
    session_id = str(uuid.uuid4())
    print(f"📋 Session ID: {session_id}")
    
    # Sample task
    task = "เขียนบ
แหล่งข้อมูลที่เกี่ยวข้อง
📚 บทช่วยสอน AI API
💰 ดูราคา
📖 เอกสารสำหรับนักพัฒนา
🚀 สมัครฟรี
บทความที่เกี่ยวข้อง
รีวิว HolySheep AI: แพลตฟอร์ม Remote Psychological Counselin
HolySheep 港口理货 AI 助手: คู่มือฉบับสมบูรณ์สำหรับ GPT-5 การรู้จำ
รีวิวเชิงลึก: HolySheep AI Legal Assistant — เปรียบเทียบ Cla