Deploy 444e366 from GitHub Actions

README.md

@@ -12,4 +12,6 @@ ONTIC 공개 제품 미리보기에서 사용하는 합성 데모 및 사용자
 
 `/predict-upload`는 익명 숫자 행렬과 정답, 시계열 날짜를 받아 실제 TabICL 추론과 보류 검증을 실행한다. 입력 행은 저장하지 않는다. 분류·회귀는 최대 1,000개 과거 사례·30개 변수·100개 예측 대상, 시계열은 최대 1,000개 관측과 24개 미래 기간으로 제한한다.
 
-공개 채팅은 최초 내부 데모와 공유하는 `SessionRuntime`·역할 프롬프트·피처 프로그램 검증기를 사용한다. Llama가 조회·제안·설명을 수행하고, 승인 뒤 TabICL이 수치 예측을 수행한다. `python poc/deploy/build_space.py <출력 디렉터리>`로 공통 소스까지 포함한 HF 업로드 디렉터리를 만든다. 원래 배포 비밀키는 Worker에만 유지한다. 공개 데이터 스냅샷과 결과 DB 어댑터의 차이는 `docs/12_agent_role_restore_2026-10-02.md`에 기록한다.
+공개 채팅은 최초 내부 데모와 공유하는 `SessionRuntime`·역할 프롬프트·피처 프로그램 검증기를 사용한다. GPU 서버 Ollama의 `qwen3.8:27b`가 조회·제안·도구 호출·설명을 수행하고, 승인 뒤 TabICL이 수치 예측을 수행한다. 기존 홈 서버 runner가 Space로 작업을 가져가므로 GPU 서버를 공개하지 않는다. Qwen 연결이 끊기면 대기/오류를 표시하며 다른 LLM으로 자동 전환하지 않는다. `/demo`에서 대화를 시작하고 `/health`와 `/api/agent-ready`에서 연결 상태를 확인한다.
+
+`python poc/deploy/build_space.py <출력 디렉터리>`로 공통 소스까지 포함한 HF 업로드 디렉터리를 만든다. 공개 페이지와 API는 같은 Space에서 제공하며, runner 인증 비밀키는 환경변수로만 관리한다. 공개 데이터 스냅샷과 결과 DB 어댑터의 차이는 `docs/12_agent_role_restore_2026-10-02.md`에 기록한다.

app.py

@@ -255,7 +255,8 @@ app.add_api_route("/api/predict-upload", predict_upload, methods=["POST"], depen
 
 @app.get("/api/agent-ready")
 def agent_ready() -> dict:
-    return {"ready": True}
+    if public_agent.qwen_ready():return {"ready": True}
+    return JSONResponse({"ready":False,"state":"gpu_offline","message":"GPU 서버의 Qwen 연결을 기다리고 있습니다."},status_code=503)
 
 
 @app.get("/api/agent-info")

public_agent.py

@@ -33,14 +33,13 @@ from feature_program import Executor, FeatureProgram, validate
 from semantic_model import SemanticModel
 
 DATA = json.loads(Path(__file__).with_name('public_datasets.json').read_text())
-# LLM and TabFM calls go to the home-server runner (GPU box, outbound-only polling) while it polls, else to this fallback.
+# LLM calls use the configured GPU Ollama model only. TabFM retains its CPU fallback.
 RUNNER_TOKEN = os.environ.get('ONTIC_RUNNER_TOKEN', '')
-FALLBACK = {'base': os.environ.get('ONTIC_FALLBACK_BASE_URL', 'https://openrouter.ai/api/v1').rstrip('/'), 'key': os.environ.get('OPENROUTER_API_KEY', ''), 'model': os.environ.get('ONTIC_FALLBACK_MODEL', 'nvidia/nemotron-3-ultra-550b-a55b:free')}
-MODEL = FALLBACK['model']
+MODEL = os.environ.get('ONTIC_LLM_MODEL', 'qwen3.8:27b')
 CHECKPOINT = 'tabicl-classifier-v2-20260212.ckpt'
 TABFM_URL = os.environ.get('ONTIC_TABFM_URL', '').rstrip('/')
 # What the screen says about the agent comes from here, not from page text (a local run overrides it).
-LLM = {'model':MODEL,'name':os.environ.get('ONTIC_FALLBACK_NAME','Nemotron 3 Ultra'),'provider':'OpenRouter'}
+LLM = {'model':MODEL,'name':os.environ.get('ONTIC_LLM_NAME','Qwen3.8 27B'),'provider':'Ollama'}
 STEPS = {'describe_data':1,'show_view':1,'query_ontology':1,'propose_features':2,'execute_features':4,'predict':5,'explain':6,'publish_results':7}
 MODEL_LOCK = threading.Lock()
 RESULT_LOCK = threading.Lock()
@@ -54,30 +53,41 @@ def runner_alive():
     return bool(RUNNER_TOKEN) and time.monotonic() - RUNNER['seen'] < 40
 
 
+def qwen_ready():
+    return runner_alive() and (RUNNER.get('llm') or {}).get('model') == MODEL
+
+
 def current_llm():
-    return RUNNER['llm'] if runner_alive() and RUNNER['llm'] else LLM
+    return dict(LLM, available=qwen_ready(), route='gpu-runner')
 
 
-def dispatch(kind, payload, claim=15, timeout=180):
-    """Hand a job to the runner. None when no runner polls, nobody claims it in `claim` s, or no answer in time: the caller falls back."""
-    if not runner_alive():
+class GPUQwenUnavailable(RuntimeError):
+    def __init__(self, reason):
+        self.reason = reason
+        super().__init__('GPU 서버의 Qwen 연결을 확인하지 못했습니다. 연결이 복구된 뒤 다시 시도해 주세요.')
+
+
+def dispatch(kind, payload, claim=15, timeout=180, strict=False):
+    """Hand a job to the runner. Strict LLM jobs fail explicitly; TabFM may fall back to CPU."""
+    def unavailable(reason):
+        if strict:raise GPUQwenUnavailable(reason)
         return None
+    if not runner_alive():
+        return unavailable('runner_offline')
+    if strict and not qwen_ready():return unavailable('model_mismatch')
     jid = secrets.token_hex(16); job = {'claimed': threading.Event(), 'ready': threading.Event(), 'result': None}
     PENDING[jid] = job; JOBS.put({'id': jid, 'kind': kind, 'payload': payload})
     try:
-        if not job['claimed'].wait(claim) or not job['ready'].wait(timeout):
-            return None
+        if not job['claimed'].wait(claim):return unavailable('job_not_claimed')
+        if not job['ready'].wait(timeout):return unavailable('model_timeout')
         result = job['result']
-        return None if not isinstance(result, dict) or 'error' in result else result
+        if not isinstance(result, dict) or 'error' in result:return unavailable('model_failed')
+        if strict and result.get('model',MODEL) != MODEL:return unavailable('model_mismatch')
+        return result
     finally:
         PENDING.pop(jid, None)
 
 
-def fallback_completion(data):
-    r = httpx.post(FALLBACK['base'] + '/chat/completions', json=dict(data, model=FALLBACK['model'], stream=False), headers={'authorization': 'Bearer ' + FALLBACK['key']}, timeout=120)
-    return r.json() if r.status_code == 200 else {'error': f'fallback LLM HTTP {r.status_code}'}
-
-
 def credentials(token):
     if not token:
         raise RuntimeError('Agent session is missing')
@@ -395,6 +405,7 @@ class ChatInput(BaseModel):
 
 @router.post('/turn')
 def turn(inp:ChatInput,request:Request):
+    if not qwen_ready():raise HTTPException(503,'GPU 서버의 Qwen 연결을 기다리고 있습니다. 잠시 후 다시 시도해 주세요.')
     with SESSIONS_LOCK:
         for sid,s in list(SESSIONS.items()):
             if time.monotonic()-s.touched>1800 and not s.busy():del SESSIONS[sid]
@@ -445,9 +456,10 @@ async def local_completion(request:Request):
     session=SESSIONS.get(sid)
     if not session:raise HTTPException(401,'Unknown local agent session')
     data=await request.json()
-    result=await asyncio.to_thread(dispatch,'llm',dict(data,stream=False))
-    if result is None:result=await asyncio.to_thread(fallback_completion,data)
-    if 'error' in result:return JSONResponse(result,status_code=502)
+    if data.get('model') != MODEL:return JSONResponse({'error':{'message':'Configured Qwen model required','code':'MODEL_MISMATCH'}},status_code=400)
+    try:result=await asyncio.to_thread(dispatch,'llm',dict(data,model=MODEL,stream=False),strict=True)
+    except GPUQwenUnavailable as exc:
+        return JSONResponse({'error':{'message':str(exc),'type':'gpu_qwen_unavailable','code':'GPU_QWEN_UNAVAILABLE','reason':exc.reason}},status_code=503)
     if not data.get('stream'):return result
     choice=result['choices'][0];message=choice['message'];delta=dict(message)
     if message.get('tool_calls'):delta['tool_calls']=[dict(t,index=i) for i,t in enumerate(message['tool_calls'])]
@@ -464,7 +476,9 @@ def runner_auth(request:Request):
 @runner_router.get('/next')
 def runner_next(request:Request,model:str='',name:str='',provider:str=''):
     """Long poll (25 s) for the home-server runner; polling is also its heartbeat."""
-    runner_auth(request);RUNNER['seen']=time.monotonic()
+    runner_auth(request)
+    if model != MODEL:raise HTTPException(409,'Configured Qwen model required')
+    RUNNER['seen']=time.monotonic()
     if model:RUNNER['llm']={'model':model,'name':name or model,'provider':provider}
     deadline=time.monotonic()+25
     while (left:=deadline-time.monotonic())>0:

web/agent-connection.js

@@ -9,9 +9,10 @@ export async function waitForAgent({signal,status,fetchFn=fetch,wait=delay,attem
  for(let i=0;i<attempts;i++){
   if(signal?.aborted)throw new DOMException('Cancelled','AbortError');
   const response=await fetchFn('/api/agent-ready',{signal});
-  if(response.ok&&(await response.json()).ready===true)return;
-  status?.('모델 서버를 깨우고 있어요. 입력한 질문은 준비가 끝나면 이어서 전송합니다.');
+  let state={};try{state=await response.json();}catch{}
+  if(response.ok&&state.ready===true)return;
+  status?.(state.state==='gpu_offline'?'GPU 서버의 Qwen 연결을 기다리고 있어요. 입력한 질문은 연결되면 이어서 전송합니다.':'모델 서버를 깨우고 있어요. 입력한 질문은 준비가 끝나면 이어서 전송합니다.');
   if(i+1<attempts)await wait(10000,signal);
  }
- throw new Error('모델 서버가 아직 준비 중입니다. 잠시 후 다시 시도해 주세요.');
+ throw new Error('Qwen 모델 서버에 연결하지 못했습니다. 잠시 후 다시 시도해 주세요.');
 }