Ollama Local LLM Feature Flag Management

Ollama Local LLM Feature Flag Management คืออะไร

Ollama เป็น open source tool สำหรับรัน Large Language Models (LLMs) บนเครื่อง local ได้ง่ายๆ รองรับโมเดลยอดนิยมเช่น Llama 3, Mistral, Phi-3, Gemma และ Code Llama Feature Flag Management คือการควบคุมการเปิด-ปิด features ในซอฟต์แวร์โดยไม่ต้อง deploy ใหม่ การรวมสองแนวคิดนี้ช่วยให้สร้างระบบ AI-powered feature flag ที่ใช้ LLM วิเคราะห์ feature performance, สร้าง targeting rules อัตโนมัติ และตัดสินใจ rollout strategies โดยรัน LLM ทั้งหมดบน local เพื่อความปลอดภัยของข้อมูล

Ollama Setup & Basics

# ollama_setup.py — Ollama local LLM setup
import json

class OllamaSetup:
    INSTALL = {
        "macos": "curl -fsSL https://ollama.com/install.sh | sh",
        "linux": "curl -fsSL https://ollama.com/install.sh | sh",
        "windows": "Download from ollama.com/download/windows",
        "docker": "docker run -d -v ollama:/root/.ollama -p 11434:11434 ollama/ollama",
    }

    MODELS = {
        "llama3.1": {"name": "Llama 3.1 8B", "size": "4.7GB", "use": "General purpose, reasoning", "speed": "Fast"},
        "mistral": {"name": "Mistral 7B", "size": "4.1GB", "use": "General purpose, instruction following", "speed": "Fast"},
        "codellama": {"name": "Code Llama 7B", "size": "3.8GB", "use": "Code generation, analysis", "speed": "Fast"},
        "phi3": {"name": "Phi-3 Mini 3.8B", "size": "2.3GB", "use": "Lightweight, edge deployment", "speed": "Very Fast"},
        "gemma2": {"name": "Gemma 2 9B", "size": "5.4GB", "use": "Google model, multilingual", "speed": "Medium"},
    }

    COMMANDS = """
# Ollama CLI commands
ollama pull llama3.1          # Download model
ollama run llama3.1           # Interactive chat
ollama list                    # List downloaded models
ollama show llama3.1          # Show model info
ollama rm llama3.1            # Remove model
ollama serve                   # Start API server (port 11434)

# API usage
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1",
  "prompt": "What is a feature flag?",
  "stream": false
}'
"""

    def show_install(self):
        print("=== Installation ===\n")
        for os_name, cmd in self.INSTALL.items():
            print(f"  [{os_name}] {cmd}")

    def show_models(self):
        print(f"\n=== Popular Models ===")
        for key, model in self.MODELS.items():
            print(f"  [{model['name']}] {model['size']} | {model['use']} | {model['speed']}")

    def show_commands(self):
        print(f"\n=== Commands ===")
        print(self.COMMANDS[:400])

setup = OllamaSetup()
setup.show_install()
setup.show_models()
setup.show_commands()

Feature Flag Fundamentals

# feature_flags.py — Feature flag fundamentals
import json

class FeatureFlags:
    CONCEPTS = {
        "feature_flag": {
            "name": "Feature Flag (Feature Toggle)",
            "description": "ตัวแปร boolean/config ที่ควบคุมว่า feature จะเปิด/ปิดใน production",
            "benefit": "Deploy code โดยไม่ enable feature ทันที — ค่อยๆ rollout",
        },
        "types": {
            "release": {"name": "Release Flag", "use": "ควบคุม feature rollout (on/off)"},
            "experiment": {"name": "Experiment Flag", "use": "A/B testing (variant A vs B)"},
            "ops": {"name": "Ops Flag", "use": "Kill switch สำหรับ circuit breaker"},
            "permission": {"name": "Permission Flag", "use": "Feature access ตาม user role/plan"},
        },
        "targeting": {
            "name": "Targeting Rules",
            "description": "กฎที่กำหนดว่า user ไหนเห็น feature",
            "examples": ["User ID targeting", "% rollout (canary)", "Country/region", "User attribute (plan, role)"],
        },
    }

    TOOLS = {
        "launchdarkly": {"name": "LaunchDarkly", "type": "SaaS", "price": "$10/seat/month+"},
        "flagsmith": {"name": "Flagsmith", "type": "Open source / SaaS", "price": "Free (self-hosted)"},
        "unleash": {"name": "Unleash", "type": "Open source / SaaS", "price": "Free (self-hosted)"},
        "openfeature": {"name": "OpenFeature", "type": "Standard/SDK", "price": "Free (CNCF project)"},
        "custom": {"name": "Custom (JSON/DB)", "type": "DIY", "price": "Free"},
    }

    PYTHON_FLAGS = """
# simple_flags.py — Simple feature flag system
import json
from datetime import datetime

class FeatureFlagManager:
    def __init__(self, config_file="flags.json"):
        with open(config_file) as f:
            self.flags = json.load(f)
    
    def is_enabled(self, flag_name, user=None):
        flag = self.flags.get(flag_name)
        if not flag:
            return False
        
        if not flag.get("enabled", False):
            return False
        
        # Check targeting rules
        rules = flag.get("rules", [])
        if not rules:
            return True  # No rules = enabled for all
        
        for rule in rules:
            if self._evaluate_rule(rule, user):
                return True
        
        # Check percentage rollout
        rollout = flag.get("rollout_percentage", 100)
        if user and rollout < 100:
            user_hash = hash(f"{flag_name}:{user.get('id', '')}") % 100
            return user_hash < rollout
        
        return False
    
    def _evaluate_rule(self, rule, user):
        if not user:
            return False
        attribute = rule.get("attribute")
        operator = rule.get("operator")
        value = rule.get("value")
        user_value = user.get(attribute)
        
        if operator == "eq":
            return user_value == value
        elif operator == "in":
            return user_value in value
        elif operator == "gte":
            return user_value >= value
        return False

# flags.json
flags_config = {
    "new_dashboard": {
        "enabled": True,
        "rollout_percentage": 25,
        "rules": [
            {"attribute": "plan", "operator": "eq", "value": "enterprise"}
        ]
    },
    "ai_suggestions": {
        "enabled": True,
        "rollout_percentage": 10,
    }
}

fm = FeatureFlagManager()
user = {"id": "user123", "plan": "enterprise", "country": "TH"}
print(f"new_dashboard: {fm.is_enabled('new_dashboard', user)}")
"""

    def show_concepts(self):
        print("=== Feature Flag Concepts ===\n")
        print(f"[{self.CONCEPTS['feature_flag']['name']}]")
        print(f"  {self.CONCEPTS['feature_flag']['description']}")
        print()
        print("Types:")
        for key, t in self.CONCEPTS["types"].items():
            print(f"  [{t['name']}] {t['use']}")

    def show_tools(self):
        print(f"\n=== Tools ===")
        for key, tool in self.TOOLS.items():
            print(f"  [{tool['name']}] {tool['type']} | {tool['price']}")

ff = FeatureFlags()
ff.show_concepts()
ff.show_tools()

AI-Powered Feature Flags with Ollama

# ai_flags.py — AI-powered feature flag management
import json

class AIFeatureFlags:
    OLLAMA_INTEGRATION = """
# ollama_flag_advisor.py — LLM-powered feature flag advisor
import requests
import json

class OllamaFlagAdvisor:
    def __init__(self, model="llama3.1", base_url="http://localhost:11434"):
        self.model = model
        self.base_url = base_url
    
    def query(self, prompt, system="You are a feature flag management expert."):
        resp = requests.post(
            f"{self.base_url}/api/generate",
            json={
                "model": self.model,
                "prompt": prompt,
                "system": system,
                "stream": False,
                "options": {"temperature": 0.3},
            },
        )
        return resp.json().get("response", "")
    
    def analyze_rollout(self, feature_name, metrics):
        prompt = f'''
        Analyze the following feature flag rollout metrics and recommend next steps:
        
        Feature: {feature_name}
        Current rollout: {metrics.get("rollout_pct")}%
        Error rate (control): {metrics.get("error_rate_control")}%
        Error rate (treatment): {metrics.get("error_rate_treatment")}%
        Latency (control): {metrics.get("latency_control")}ms
        Latency (treatment): {metrics.get("latency_treatment")}ms
        Conversion (control): {metrics.get("conversion_control")}%
        Conversion (treatment): {metrics.get("conversion_treatment")}%
        
        Should we: increase rollout, decrease rollout, or kill the feature?
        Provide a brief analysis and recommendation.
        '''
        return self.query(prompt)
    
    def generate_targeting_rules(self, feature_description, user_segments):
        prompt = f'''
        Generate feature flag targeting rules for:
        Feature: {feature_description}
        Available segments: {json.dumps(user_segments)}
        
        Output JSON targeting rules.
        '''
        return self.query(prompt)
    
    def suggest_rollout_strategy(self, feature_name, risk_level):
        prompt = f'''
        Suggest a rollout strategy for feature "{feature_name}" 
        with risk level: {risk_level}
        
        Include: phases, percentage, duration, metrics to watch.
        '''
        return self.query(prompt)

# Usage
advisor = OllamaFlagAdvisor()

# Analyze rollout metrics
metrics = {
    "rollout_pct": 10,
    "error_rate_control": 0.5,
    "error_rate_treatment": 0.8,
    "latency_control": 120,
    "latency_treatment": 145,
    "conversion_control": 3.2,
    "conversion_treatment": 4.1,
}
analysis = advisor.analyze_rollout("new_checkout_flow", metrics)
print(analysis)
"""

    def show_integration(self):
        print("=== Ollama Feature Flag Advisor ===")
        print(self.OLLAMA_INTEGRATION[:700])

    def use_cases(self):
        print(f"\n=== AI Feature Flag Use Cases ===")
        cases = [
            {"name": "Rollout Analysis", "description": "LLM วิเคราะห์ metrics แล้วแนะนำ increase/decrease/kill"},
            {"name": "Rule Generation", "description": "LLM สร้าง targeting rules จาก feature description"},
            {"name": "Incident Detection", "description": "LLM ตรวจจับ anomalies หลัง feature enable"},
            {"name": "Strategy Planning", "description": "LLM แนะนำ rollout strategy ตาม risk level"},
            {"name": "Documentation", "description": "LLM สร้าง changelog/docs สำหรับ flag changes"},
        ]
        for c in cases:
            print(f"  [{c['name']}] {c['description']}")

ai = AIFeatureFlags()
ai.show_integration()
ai.use_cases()

Automated Rollout Pipeline

# pipeline.py — Automated rollout pipeline
import json
import random

class RolloutPipeline:
    STAGES = {
        "canary": {"name": "1. Canary (1%)", "duration": "24h", "criteria": "Error rate < 1%, latency < 200ms"},
        "early_adopter": {"name": "2. Early Adopter (10%)", "duration": "48h", "criteria": "Error rate < 0.5%, positive feedback"},
        "beta": {"name": "3. Beta (25%)", "duration": "1 week", "criteria": "No regressions, metrics stable"},
        "ga_50": {"name": "4. GA 50%", "duration": "1 week", "criteria": "Business metrics positive"},
        "ga_100": {"name": "5. GA 100%", "duration": "Permanent", "criteria": "All metrics green, cleanup flag"},
    }

    AUTOMATION = """
# auto_rollout.py — Automated progressive rollout
import requests
import time

class AutoRollout:
    def __init__(self, flag_name, ollama_advisor, flag_manager):
        self.flag_name = flag_name
        self.advisor = ollama_advisor
        self.fm = flag_manager
        self.stages = [1, 10, 25, 50, 100]
    
    def get_metrics(self):
        # Fetch metrics from monitoring system
        return {
            "error_rate_control": 0.3,
            "error_rate_treatment": 0.4,
            "latency_control": 100,
            "latency_treatment": 110,
            "conversion_control": 3.0,
            "conversion_treatment": 3.5,
        }
    
    def run(self):
        for pct in self.stages:
            print(f"Setting rollout to {pct}%...")
            self.fm.set_rollout(self.flag_name, pct)
            
            # Wait for data
            time.sleep(3600 * 24)  # 24 hours
            
            metrics = self.get_metrics()
            metrics["rollout_pct"] = pct
            
            # Ask LLM for analysis
            analysis = self.advisor.analyze_rollout(self.flag_name, metrics)
            
            if "kill" in analysis.lower() or "rollback" in analysis.lower():
                print(f"ROLLBACK! LLM recommends killing feature at {pct}%")
                self.fm.set_rollout(self.flag_name, 0)
                return False
            elif "decrease" in analysis.lower():
                print(f"DECREASE! Holding at {pct}%")
                continue
            else:
                print(f"PROCEED to next stage from {pct}%")
        
        print("Feature fully rolled out!")
        return True
"""

    def show_stages(self):
        print("=== Rollout Stages ===\n")
        for key, stage in self.STAGES.items():
            print(f"[{stage['name']}] Duration: {stage['duration']}")
            print(f"  Criteria: {stage['criteria']}")

    def show_automation(self):
        print(f"\n=== Auto Rollout Script ===")
        print(self.AUTOMATION[:500])

    def simulate(self):
        print(f"\n=== Rollout Simulation ===")
        stages = [1, 10, 25, 50, 100]
        for pct in stages:
            error = random.uniform(0.1, 1.0)
            latency = random.randint(80, 200)
            decision = "PROCEED" if error < 0.8 and latency < 180 else "HOLD"
            print(f"  [{pct:>3}%] Error: {error:.2f}% | Latency: {latency}ms → {decision}")

pipeline = RolloutPipeline()
pipeline.show_stages()
pipeline.show_automation()
pipeline.simulate()

Privacy & Security

# security.py — Privacy and security with local LLM
import json

class LocalLLMSecurity:
    BENEFITS = {
        "data_privacy": {
            "name": "Data Privacy (ข้อมูลไม่ออกนอกองค์กร)",
            "detail": "Ollama รันบน local — ข้อมูล feature flags, metrics, user data ไม่ส่งไป cloud",
        },
        "compliance": {
            "name": "Compliance (GDPR, PDPA)",
            "detail": "ไม่มี data transfer ไป third party — ง่ายต่อการ comply กับ PDPA/GDPR",
        },
        "cost": {
            "name": "Cost (ไม่มีค่า API)",
            "detail": "ไม่ต้องจ่ายค่า API calls — Ollama ฟรี, รันบน hardware ที่มี",
        },
        "latency": {
            "name": "Low Latency (ไม่ต้องเรียก cloud)",
            "detail": "Local inference เร็วกว่า cloud API — ไม่มี network latency",
        },
        "offline": {
            "name": "Offline Capable",
            "detail": "ทำงานได้แม้ไม่มี internet — เหมาะ air-gapped environments",
        },
    }

    def show_benefits(self):
        print("=== Local LLM Security Benefits ===\n")
        for key, benefit in self.BENEFITS.items():
            print(f"[{benefit['name']}]")
            print(f"  {benefit['detail']}")
            print()

    def hardware_reqs(self):
        print("=== Hardware Requirements ===")
        reqs = [
            {"model": "Phi-3 3.8B", "ram": "4GB", "gpu": "Optional", "speed": "Very fast on CPU"},
            {"model": "Llama 3.1 8B", "ram": "8GB", "gpu": "Recommended (6GB VRAM)", "speed": "Fast"},
            {"model": "Mistral 7B", "ram": "8GB", "gpu": "Recommended", "speed": "Fast"},
            {"model": "Llama 3.1 70B", "ram": "48GB+", "gpu": "Required (48GB VRAM)", "speed": "Slow on CPU"},
        ]
        for r in reqs:
            print(f"  [{r['model']}] RAM: {r['ram']} | GPU: {r['gpu']} | {r['speed']}")

sec = LocalLLMSecurity()
sec.show_benefits()
sec.hardware_reqs()

FAQ - คำถามที่พบบ่อย

Q: Ollama กับ OpenAI API อันไหนดี?

A: Ollama: ฟรี, private, offline, latency ต่ำ แต่ model quality อาจต่ำกว่า GPT-4 OpenAI: model quality สูงสุด แต่มีค่าใช้จ่าย, data ส่งออก, ต้อง internet ใช้ Ollama: data sensitive, budget จำกัด, offline requirement ใช้ OpenAI: ต้องการ quality สูงสุด, budget เพียงพอ Hybrid: Ollama สำหรับ routine tasks + OpenAI สำหรับ complex analysis

Q: Feature flag ต้องใช้ tool อะไร?

A: เริ่มต้น: JSON config + custom code (ฟรี, ง่าย) Growing: Flagsmith หรือ Unleash (open source, self-hosted) Enterprise: LaunchDarkly (SaaS, advanced targeting, analytics) Standard: OpenFeature SDK (CNCF, vendor-agnostic) สำคัญ: เลือก tool ที่ team ใช้ได้จริง ไม่ over-engineer

Q: AI ช่วย feature flag management ได้จริงไหม?

A: ช่วยได้ในหลายด้าน: 1. วิเคราะห์ rollout metrics → แนะนำ proceed/rollback 2. สร้าง targeting rules จาก natural language 3. ตรวจจับ anomalies หลัง feature enable 4. สร้าง documentation อัตโนมัติ แต่: LLM ไม่ควรตัดสินใจ rollback เองทั้งหมด — ใช้เป็น advisor ให้คนตัดสินใจ

Q: Ollama รันบนเครื่องอะไรได้?

A: CPU only: ได้ แต่ช้า (Phi-3 3.8B ใช้ได้ดี, Llama 8B พอใช้) GPU (NVIDIA): เร็วมาก (RTX 3060+ แนะนำ) Apple Silicon (M1/M2/M3): เร็วมาก (Metal acceleration) RAM: minimum 8GB สำหรับ 7-8B models Docker: รันใน container ได้ (map GPU ด้วย --gpus all)