Local AI API

နားလည်ထားရမယ့် အချက်

Ollama, LM Studio ရဲ့ server mode, llama.cpp ရဲ့ server အားလုံးက local HTTP API တစ်ခုကို ဖော်ပြထားတယ်ဆိုတာ နားလည်ပြီဆိုရင် HTTP request လုပ်နိုင်တဲ့ programming language ဘယ်ခုကနေမဆို local model ကို ခေါ်သုံးနိုင်ပါပြီ, chat window ကနေသာ မဟုတ်တော့ပါဘူး။ ဒီ puzzle ရဲ့ အပိုင်းတွေကို အတိအကျ နာမည်ပေးထားသင့်ပါတယ်။

• Localhost — hostname အထူးတစ်ခုဖြစ်ပြီး address 127.0.0.1 က နောက်ကွယ်မှာ ရှိနေပြီး “ဒီစက်တစ်ခုတည်း” ကို အမြဲ ဆိုလိုပါတယ်, ဒါကြောင့် localhost ဆီ ပို့တဲ့ request တစ်ခုက သင့်ကွန်ပျူတာကနေ ဘယ်တော့မှ မထွက်ဘဲ network ကိုလည်း ဘယ်တော့မှ မထိပါဘူး။
• Port — 11434 (သို့) 1234 လို ဂဏန်းတစ်ခုဖြစ်ပြီး request ကို ဘယ် program တစ်ခုက လက်ခံသင့်လဲ identify ပေးပါတယ်, ဘာဖြစ်လို့လဲဆိုတော့ program အများကြီးက machine တစ်ခုတည်းပေါ်မှာ တစ်ချိန်တည်း listen လုပ်နေနိုင်လို့ပါ။
• Endpoint — server ပေါ်က job တစ်ခုတည်းအတွက် သီးသန့် URL path တစ်ခုဖြစ်ပြီး conversation တစ်ခုအတွက် /api/chat, text ကို vector အဖြစ်ပြောင်းဖို့ /api/embeddings လိုမျိုးပါ; server တစ်ခုတည်းကပဲ task မတူညီတာတွေအတွက် endpoint အများကြီးကို ဖော်ပြနိုင်ပါတယ်။
• Request — သင့် application ပို့တဲ့ message ပါ — endpoint ဘယ်ခုလဲ, model name ဘာလဲ, ယခုအထိ conversation ဘာတွေရှိလဲ, ပုံမှန်အားဖြင့် JSON နဲ့ encode လုပ်ထားတယ်, JSON ဆိုတာ လူနဲ့ program နှစ်ခုစလုံး ဖတ်နိုင်တဲ့ structured data အတွက် plain-text format တစ်ခုပါ။
• Response — server က request ကို runtime နဲ့ model ကနေတဆင့် process လုပ်ပြီး JSON နဲ့ ပြန်ပို့ပါတယ်, generate လုပ်ထားတဲ့ text နဲ့ token count လို metadata တွေ ပါလေ့ရှိပါတယ်။

ဒီ request-response cycle over HTTP ဟာ web app တစ်ခုက weather service လို remote API တစ်ခုနဲ့ ဘယ်လို စကားပြောလဲဆိုတာနဲ့ အတိအကျ တူပါတယ်; local AI API ရဲ့ ကွာခြားချက်ကတော့ server က internet ပေါ်က တခြားနေရာမှာ မဟုတ်ဘဲ သင့်ကိုယ်ပိုင် machine ပေါ်မှာ ရှိတာပါပဲ။

localhost

address 127.0.0.1 ကို နောက်ကွယ်မှာ ကိုင်ထားတဲ့ hostname အထူးတစ်ခုဖြစ်ပြီး request ကို ဘယ်ကနေ လာလာ machine တစ်ခုတည်းကို အမြဲ ရည်ညွှန်းလို့ external network ပေါ်ကို ဘယ်တော့မှ မသွားပါဘူး။

Endpoint

server ပေါ်က job တစ်ခုတည်းအတွက် သီးသန့် URL path တစ်ခုဖြစ်ပြီး conversation တစ်ခုအတွက် /api/chat, text ကို vector ပြောင်းဖို့ /api/embeddings လိုမျိုး, server တစ်ခုတည်းကနေ endpoint အများကြီး ဖော်ပြနိုင်ပါတယ်။

API

server တစ်ခုက ဖော်ပြထားတဲ့ rule နဲ့ endpoint အစုအဝေးဖြစ်ပြီး software တခြားတွေက request ပို့ပြီး structured response (ပုံမှန် JSON) ရရှိနိုင်စေလို့ လူတစ်ယောက်က click နှိပ်စရာမလိုဘဲ software နဲ့ software ချင်း စကားပြောလို့ ရပါတယ်။

APP TO MODEL VIA LOCAL API
--------------------------
------------------------------------------------------------
  YOUR APP
     |
     |  HTTP request to
     |  http://localhost:PORT/endpoint
     |  (JSON body: model name + messages)
     v
  LOCAL RUNTIME  (Ollama / llama.cpp server / LM Studio server)
     |
     |  loads and runs
     v
  MODEL
     |
     |  generates text
     v
  JSON RESPONSE  (generated text + metadata)
     |
     |  sent back over the same connection
     v
  YOUR APP  (reads the response, uses the text)

လက်တွေ့ scenario နဲ့ ချိတ်ကြည့်မယ်

local run နေတဲ့ model တစ်ခုကို သုံးပြီး meeting note တွေကို summarize လုပ်ပေးမယ့် Python script ငယ်လေးကို offline ဖြစ်ပြီး အပြည့်အဝ အလုပ်လုပ်စေချင်တယ်လို့ ယူဆကြည့်ပါ။

အောက်က code example က Python ရဲ့ `requests` library ကို သုံးပြီး ဒီ pattern အတိအကျ ပြသထားပါတယ်, endpoint URL နဲ့ message content ကို Ollama-compatible local server ဘယ်ခုအတွက်မဆို ချိန်ညှိသုံးနိုင်ပါတယ်။

• localhost, port, endpoint သုံးခုပေါင်းလိုက်ရင် local program ဘယ်ခု, job ဘယ်ခုက request ကို handle လုပ်သင့်လဲ အတိအကျ identify ပေးပါတယ်။
• request နဲ့ response နှစ်ခုစလုံးက JSON structure နဲ့ ရှိပြီး remote web API ဘယ်ခုကိုမဆို ခေါ်သုံးတဲ့ pattern တူတူပါပဲ။
• local API call ပတ်ပတ်လည်က ခိုင်မာတဲ့ code ဟာ success path တစ်ခုတည်းမကဘဲ connection error, timeout, HTTP error status တွေကိုပါ handle လုပ်ပါတယ်။

အတူတူ စမ်းရေးကြည့်မယ်

import requests

OLLAMA_CHAT_URL = "http://localhost:11434/api/chat"


def summarize_notes(model_name, meeting_notes):
    payload = {
        "model": model_name,
        "messages": [
            {
                "role": "system",
                "content": (
                    "You are a concise assistant. Summarize the given "
                    "meeting notes in three bullet points."
                ),
            },
            {"role": "user", "content": meeting_notes},
        ],
        "stream": False,
    }

    try:
        response = requests.post(OLLAMA_CHAT_URL, json=payload, timeout=60)
        response.raise_for_status()
    except requests.exceptions.ConnectionError:
        print("Could not reach the local model server. Is Ollama running?")
        return None
    except requests.exceptions.Timeout:
        print("The request timed out waiting for a reply.")
        return None
    except requests.exceptions.HTTPError as error:
        print(f"The server returned an error: {error}")
        return None

    data = response.json()
    return data["message"]["content"]


if __name__ == "__main__":
    notes = (
        "Team agreed to ship the search feature next sprint. "
        "Backend needs the new /api/search endpoint. "
        "Design will deliver mockups by Thursday."
    )
    summary = summarize_notes("llama3.2", notes)
    if summary is not None:
        print(summary)

ဒီ code ကို ဒီနေရာမှာ run မထားပါဘူး, local Ollama server run နေဖို့ လိုအပ်လို့ပါ။ Ollama run နေပြီး `llama3.2` pull လုပ်ပြီးသားဆိုရင် `summarize_notes` က note တွေကို `/api/chat` ဆီ ပို့ပြီး server က assistant ရဲ့ reply text ပါတဲ့ `message` field ပါတဲ့ JSON object နဲ့ response ပြန်ပါတယ်; function က ဒီ text ကို return ပြန်ပြီး `print` statement က model generate ထုတ်ခဲ့တဲ့ bullet သုံးချက် summary ကို ပြပါလိမ့်မယ် — အတိအကျ စာလုံးက model အပေါ်မူတည်ပြီး hardcode (သို့) predict လုပ်သင့်တာ မဟုတ်ပါဘူး။ Ollama run မနေရင် `ConnectionError` branch က crash မဖြစ်ဘဲ message တစ်ခု print ထုတ်ပါတယ်။

Ollama API documentation — Local AI / Local LLM