Add llama.cpp parser backend for Space

.env.example

@@ -3,7 +3,7 @@ HISTORY_STORE=local_json
 LOCAL_HISTORY_PATH=data/completed_sessions.json
 
 PARSER_BACKEND=ollama
-OLLAMA_MODEL=qwen3:8b
+OLLAMA_MODEL=qwen3:1.7B
 # Private parser trace logs. These can include check-in text, so leave them off
 # unless debugging parser failures.
 PARSER_LOG_MESSAGES=0
@@ -11,10 +11,12 @@ PARSER_LOG_RESPONSES=0
 PARSER_LOG_PARSED_JSON=0
 
 # Hugging Face Space parser runtime.
-# PARSER_BACKEND=transformers
-# PARSER_MODEL_ID=Qwen/Qwen3-1.7B
-# PARSER_MAX_NEW_TOKENS=384
-# ZEROGPU_DURATION_SECONDS=120
+# PARSER_BACKEND=llama_cpp
+# LLAMA_CPP_MODEL_REPO=unsloth/Qwen3-1.7B-GGUF
+# LLAMA_CPP_MODEL_FILE=Qwen3-1.7B-Q4_K_M.gguf
+# LLAMA_CPP_MAX_TOKENS=384
+# LLAMA_CPP_N_CTX=2048
+# LLAMA_CPP_N_THREADS=2
 
 # Optional Hugging Face Dataset storage.
 # Keep real tokens in your local .env or Hugging Face Space secrets.

DECISIONS.md

@@ -74,8 +74,9 @@ with a one-line note on why.
   the planned session and stores ordered `LoggedExercise` entries. Each `LoggedSet`
   stores set number, actual reps, actual load, optional RPE, optional rest seconds before
   the set, and notes.
-- **Parser model:** local MVP parser uses Ollama `qwen3:4b`, which passed the current
-  parser acceptance fixtures after prompt optimization and deterministic parser cleanup.
+- **Parser model:** local MVP parser uses Ollama `qwen3:1.7B` by default for speed.
+  Earlier `qwen3:4b` runs passed the current parser acceptance fixtures after prompt
+  optimization and deterministic parser cleanup.
   The parser may infer safe structured facts and possible context signals, but it must
   not invent quantities or training actions. Pain information must use per-issue
   `pain_issues`; exercise filtering is performed by the deterministic engine.
@@ -85,11 +86,14 @@ with a one-line note on why.
   are acceptable before the engine builds a session.
 - **Local parser runtime:** use Ollama/llama.cpp for local evaluation and development
   because it is much faster on the Mac than local Transformers CPU/disk-offload.
-  `qwen3:4b` is the current local parser candidate for tiny/local badge fit.
-- **Space parser runtime:** Hugging Face Spaces use the Transformers parser backend,
-  configured with `PARSER_BACKEND=transformers`, `PARSER_MODEL_ID=Qwen/Qwen3-1.7B`,
-  and `PARSER_MAX_NEW_TOKENS=384`. Local development remains Ollama by default so the
-  app still runs locally without a cloud AI API.
+  `qwen3:1.7B` is the current local Ollama default for MVP speed.
+- **Space parser runtime:** Hugging Face Spaces use a GGUF llama.cpp backend,
+  configured with `PARSER_BACKEND=llama_cpp`,
+  `LLAMA_CPP_MODEL_REPO=unsloth/Qwen3-1.7B-GGUF`,
+  `LLAMA_CPP_MODEL_FILE=Qwen3-1.7B-Q4_K_M.gguf`, `LLAMA_CPP_MAX_TOKENS=384`,
+  `LLAMA_CPP_N_CTX=2048`, and a Space-specific `LLAMA_CPP_N_THREADS`. This replaces the
+  slow CPU Transformers runtime. The Transformers backend remains only as an explicit
+  local experiment/fallback path and is not installed by the default requirements.
 - **MVP training template:** use the supplied fixed 4-day exercise template for the
   first engine slice. Preserve exercise grouping, execution order, set counts, rep
   targets, and notes. For MVP simplicity, all exercise rests are normalized to 1 minute.

MVP_COMPROMISES.md

@@ -47,8 +47,9 @@ forgetting what is missing afterward.
 - **Multi-round clarification over one-shot perfection.** The small model proposes
   structured follow-up questions, and deterministic cleanup removes obvious duplicates,
   already-answered questions, and unsupported activity/body-area follow-ups.
-- **Local development uses Ollama.** This is fast and useful locally, but deployment may
-  need a different runtime path on Hugging Face Spaces.
+- **Local development uses Ollama.** This is fast and useful locally. Hugging Face
+  Spaces use a GGUF llama.cpp backend so CPU deployment does not rely on slow PyTorch
+  Transformers generation.
 - **Acceptance fixtures are test coverage, not product proof.** They help catch obvious
   regressions, but real value still comes from logged sessions.
 

PLAN.md

@@ -129,14 +129,14 @@ exists.
 
 **Decision status:**
 
-- [x] Choose local parser model: Ollama `qwen3:4b`.
-- [x] Keep Transformers path as the Hugging Face Spaces deployment fallback.
+- [x] Choose local parser model: Ollama `qwen3:1.7B`.
+- [x] Replace the Hugging Face Spaces Transformers parser with a GGUF llama.cpp path.
 
 **Acceptance rule:**
 
 - Local development/evaluation now prefers Ollama because quantized llama.cpp/Metal
   inference is much faster on the Mac than local Transformers CPU/disk-offload.
-- Current local parser model: `qwen3:4b`, which passed the current acceptance fixtures.
+- Current local parser default: `qwen3:1.7B`, chosen for MVP parser speed.
 
 **Tasks:**
 
@@ -147,8 +147,9 @@ exists.
 - [x] Fix parser keys and enum values through schema validation.
 - [x] Validate model JSON into `ParsedCheckIn`.
 - [x] Add optional local Transformers runtime wrapper.
-- [x] Add parser backend selector for local Ollama vs Space Transformers runtime.
+- [x] Add parser backend selector for local Ollama vs Space llama.cpp runtime.
 - [x] Add Ollama local runtime wrapper with JSON-schema structured outputs.
+- [x] Add GGUF llama.cpp runtime wrapper for Hugging Face Spaces CPU deployment.
 - [x] Run the model on one fixture and parse raw text into `ParsedCheckIn`.
 - [x] Run the model against all acceptance fixtures.
 - [x] Remove overfit fixture-shaped prompt examples.
@@ -328,7 +329,7 @@ progression have real history.
 - [ ] Tiny Titan route.
 - [ ] Research-reader.
 - [ ] Fine-tuning.
-- [ ] llama.cpp route.
+- [x] llama.cpp route.
 - [ ] Custom UI polish.
 
 ---

README.md

@@ -11,7 +11,7 @@ pinned: false
 license: apache-2.0
 short_description: Small Models Big Adventures Hackaton - Weightlifting Trainer
 preload_from_hub:
-  - Qwen/Qwen3-1.7B
+  - unsloth/Qwen3-1.7B-GGUF Qwen3-1.7B-Q4_K_M.gguf
 ---
 
 # Strength Training Coach
@@ -116,25 +116,31 @@ Local development defaults to Ollama:
 
 ```txt
 PARSER_BACKEND=ollama
-OLLAMA_MODEL=qwen3:8b
+OLLAMA_MODEL=qwen3:1.7B
 ```
 
-Hugging Face Spaces should use the Transformers runtime:
+Hugging Face Spaces should use the GGUF llama.cpp runtime:
 
 ```txt
-PARSER_BACKEND=transformers
-PARSER_MODEL_ID=Qwen/Qwen3-1.7B
-PARSER_MAX_NEW_TOKENS=384
-ZEROGPU_DURATION_SECONDS=120
+PARSER_BACKEND=llama_cpp
+LLAMA_CPP_MODEL_REPO=unsloth/Qwen3-1.7B-GGUF
+LLAMA_CPP_MODEL_FILE=Qwen3-1.7B-Q4_K_M.gguf
+LLAMA_CPP_MAX_TOKENS=384
+LLAMA_CPP_N_CTX=2048
+LLAMA_CPP_N_THREADS=2
 ```
 
-For GPU parser inference on Hugging Face, set the Space hardware to ZeroGPU. The
-Transformers generation path is decorated with `spaces.GPU`; outside ZeroGPU the
-decorator is a no-op.
+The Space README frontmatter preloads only the selected GGUF file at build time so the
+app does not need to download model weights during the first parser request. Set
+`LLAMA_CPP_N_THREADS` to the Space CPU thread count.
 
-If `PARSER_BACKEND` is not set, the app chooses `transformers` when the Hugging Face
+If `PARSER_BACKEND` is not set, the app chooses `llama_cpp` when the Hugging Face
 `SPACE_ID` environment variable exists, otherwise `ollama`.
 
+The old Transformers parser backend still exists for explicit local experiments, but it
+is not installed by the default deployment requirements and is no longer the Space
+runtime path.
+
 ## Rule Source
 
 The canonical training-rule source is:

requirements.txt

@@ -1,7 +1,4 @@
 gradio==6.17.3
 huggingface_hub>=0.36.0
 pydantic>=2.11.10,<2.13
-accelerate>=1.0.0
-spaces>=0.35.0
-torch>=2.8.0
-transformers>=4.48.0
+llama-cpp-python>=0.3.16

tests/test_env.py

@@ -15,8 +15,8 @@ class EnvTests(unittest.TestCase):
                 "\n".join(
                     [
                         "# comment",
-                        "PARSER_BACKEND=transformers",
-                        "OLLAMA_MODEL='qwen3:8b'",
+                        "PARSER_BACKEND=llama_cpp",
+                        "OLLAMA_MODEL='qwen3:1.7B'",
                         "EXISTING=value-from-file",
                     ]
                 )
@@ -25,8 +25,8 @@ class EnvTests(unittest.TestCase):
             with patch.dict(os.environ, {"EXISTING": "value-from-env"}, clear=True):
                 load_local_env(env_path)
 
-                self.assertEqual(os.environ["PARSER_BACKEND"], "transformers")
-                self.assertEqual(os.environ["OLLAMA_MODEL"], "qwen3:8b")
+                self.assertEqual(os.environ["PARSER_BACKEND"], "llama_cpp")
+                self.assertEqual(os.environ["OLLAMA_MODEL"], "qwen3:1.7B")
                 self.assertEqual(os.environ["EXISTING"], "value-from-env")
 
 

tests/test_parser_llama_cpp.py

@@ -0,0 +1,156 @@
+import json
+import unittest
+from unittest.mock import patch
+
+from training_coach.parser_llama_cpp import (
+    DEFAULT_LLAMA_CPP_MAX_TOKENS,
+    DEFAULT_LLAMA_CPP_MODEL_FILE,
+    DEFAULT_LLAMA_CPP_MODEL_REPO,
+    DEFAULT_LLAMA_CPP_N_CTX,
+    LlamaCppRuntimeUnavailableError,
+    _load_llama_cpp,
+    generate_parser_response_llama_cpp,
+    llama_cpp_response_grammar,
+    load_llama_cpp_model,
+    parse_check_in_with_llama_cpp,
+)
+
+
+class FakeLlama:
+    from_pretrained_calls = []
+    completion_calls = []
+
+    @classmethod
+    def from_pretrained(cls, **kwargs):
+        cls.from_pretrained_calls.append(kwargs)
+        return cls()
+
+    def create_chat_completion(self, **kwargs):
+        self.completion_calls.append(kwargs)
+        return {
+            "choices": [
+                {
+                    "message": {
+                        "content": json.dumps(
+                            {
+                                "check_in": {
+                                    "raw_text": "60 min",
+                                    "time_available_minutes": 60,
+                                }
+                            }
+                        )
+                    }
+                }
+            ]
+        }
+
+
+class FakeGrammar:
+    schemas = []
+
+    @classmethod
+    def from_json_schema(cls, schema, verbose=True):
+        cls.schemas.append((schema, verbose))
+        return {"schema": schema, "verbose": verbose}
+
+
+class LlamaCppParserTest(unittest.TestCase):
+    def setUp(self):
+        load_llama_cpp_model.cache_clear()
+        llama_cpp_response_grammar.cache_clear()
+        FakeLlama.from_pretrained_calls = []
+        FakeLlama.completion_calls = []
+        FakeGrammar.schemas = []
+
+    def tearDown(self):
+        load_llama_cpp_model.cache_clear()
+        llama_cpp_response_grammar.cache_clear()
+
+    def test_llama_cpp_defaults_are_locked(self):
+        self.assertEqual(DEFAULT_LLAMA_CPP_MODEL_REPO, "unsloth/Qwen3-1.7B-GGUF")
+        self.assertEqual(DEFAULT_LLAMA_CPP_MODEL_FILE, "Qwen3-1.7B-Q4_K_M.gguf")
+        self.assertEqual(DEFAULT_LLAMA_CPP_MAX_TOKENS, 384)
+        self.assertEqual(DEFAULT_LLAMA_CPP_N_CTX, 2048)
+
+    def test_runtime_can_import_llama_cpp_or_reports_clear_error(self):
+        try:
+            loaded = _load_llama_cpp()
+        except LlamaCppRuntimeUnavailableError as error:
+            self.assertIn("Install llama-cpp-python", str(error))
+        else:
+            self.assertEqual(len(loaded), 2)
+
+    def test_load_model_uses_repo_file_and_runtime_settings(self):
+        with patch(
+            "training_coach.parser_llama_cpp._load_llama_cpp",
+            return_value=(FakeLlama, FakeGrammar),
+        ):
+            load_llama_cpp_model(
+                repo_id="repo/model",
+                filename="model.gguf",
+                n_ctx=4096,
+                n_threads=2,
+            )
+
+        self.assertEqual(
+            FakeLlama.from_pretrained_calls,
+            [
+                {
+                    "repo_id": "repo/model",
+                    "filename": "model.gguf",
+                    "n_ctx": 4096,
+                    "verbose": False,
+                    "n_threads": 2,
+                }
+            ],
+        )
+
+    def test_generate_parser_response_uses_schema_grammar(self):
+        with patch(
+            "training_coach.parser_llama_cpp._load_llama_cpp",
+            return_value=(FakeLlama, FakeGrammar),
+        ):
+            response = generate_parser_response_llama_cpp(
+                "60 min",
+                repo_id="repo/model",
+                filename="model.gguf",
+                max_tokens=128,
+                n_ctx=2048,
+                n_threads=None,
+            )
+
+        completion_call = FakeLlama.completion_calls[0]
+        self.assertEqual(completion_call["max_tokens"], 128)
+        self.assertEqual(completion_call["temperature"], 0)
+        self.assertEqual(completion_call["grammar"]["verbose"], False)
+        self.assertEqual(FakeGrammar.schemas[0][1], False)
+        self.assertIn("ParsedCheckIn", FakeGrammar.schemas[0][0])
+        self.assertIn("60 min", completion_call["messages"][1]["content"])
+        self.assertIn("check_in", response)
+
+    def test_parse_check_in_with_llama_cpp_reads_env_and_validates_response(self):
+        with patch.dict(
+            "os.environ",
+            {
+                "LLAMA_CPP_MODEL_REPO": "repo/model",
+                "LLAMA_CPP_MODEL_FILE": "model.gguf",
+                "LLAMA_CPP_MAX_TOKENS": "128",
+                "LLAMA_CPP_N_CTX": "4096",
+                "LLAMA_CPP_N_THREADS": "2",
+            },
+            clear=True,
+        ), patch(
+            "training_coach.parser_llama_cpp._load_llama_cpp",
+            return_value=(FakeLlama, FakeGrammar),
+        ):
+            parsed = parse_check_in_with_llama_cpp("60 min")
+
+        self.assertEqual(parsed.check_in.time_available_minutes, 60)
+        self.assertEqual(FakeLlama.from_pretrained_calls[0]["repo_id"], "repo/model")
+        self.assertEqual(FakeLlama.from_pretrained_calls[0]["filename"], "model.gguf")
+        self.assertEqual(FakeLlama.from_pretrained_calls[0]["n_ctx"], 4096)
+        self.assertEqual(FakeLlama.from_pretrained_calls[0]["n_threads"], 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_parser_ollama.py

@@ -27,7 +27,7 @@ class _FakeResponse:
 
 class OllamaParserTest(unittest.TestCase):
     def test_ollama_model_choices_are_locked(self):
-        self.assertEqual(OLLAMA_MODEL, "qwen3:8b")
+        self.assertEqual(OLLAMA_MODEL, "qwen3:1.7B")
         self.assertEqual(OLLAMA_TINY_CANDIDATE, "qwen3:4b")
 
     def test_build_ollama_prompt_includes_schema_and_check_in(self):
@@ -66,7 +66,7 @@ class OllamaParserTest(unittest.TestCase):
 
         sent_request = urlopen.call_args.args[0]
         body = json.loads(sent_request.data.decode("utf-8"))
-        self.assertEqual(body["model"], "qwen3:8b")
+        self.assertEqual(body["model"], "qwen3:1.7B")
         self.assertEqual(body["stream"], False)
         self.assertEqual(body["think"], False)
         self.assertEqual(body["format"]["title"], "ParsedCheckIn")

tests/test_parser_service.py

@@ -12,7 +12,7 @@ class ParserServiceTest(unittest.TestCase):
 
     def test_parser_backend_defaults_to_transformers_on_space(self):
         with patch.dict("os.environ", {"SPACE_ID": "LucasMah/app"}, clear=True):
-            self.assertEqual(parser_backend(), "transformers")
+            self.assertEqual(parser_backend(), "llama_cpp")
 
     def test_parser_backend_env_override_wins(self):
         with patch.dict(
@@ -33,7 +33,20 @@ class ParserServiceTest(unittest.TestCase):
                 result = parse_check_in_with_configured_backend("60 min")
 
         self.assertEqual(result, parsed)
-        parse_ollama.assert_called_once_with("60 min", model_name="qwen3:8b")
+        parse_ollama.assert_called_once_with("60 min", model_name="qwen3:1.7B")
+
+    def test_configured_parser_uses_llama_cpp_backend(self):
+        parsed = ParsedCheckIn(check_in=CheckIn(raw_text="60 min"))
+
+        with patch.dict("os.environ", {"PARSER_BACKEND": "llama_cpp"}, clear=True):
+            with patch(
+                "training_coach.parser_service.parse_check_in_with_llama_cpp",
+                return_value=parsed,
+            ) as parse_llama_cpp:
+                result = parse_check_in_with_configured_backend("60 min")
+
+        self.assertEqual(result, parsed)
+        parse_llama_cpp.assert_called_once_with("60 min")
 
     def test_configured_parser_uses_transformers_backend(self):
         parsed = ParsedCheckIn(check_in=CheckIn(raw_text="60 min"))

training_coach/parser_llama_cpp.py

@@ -0,0 +1,156 @@
+from functools import lru_cache
+import json
+import logging
+import os
+from time import perf_counter
+
+from training_coach.models import ParsedCheckIn
+from training_coach.parser import (
+    build_parser_messages,
+    expected_response_format,
+    log_parser_messages,
+    log_parser_response_text,
+    parse_model_response,
+)
+
+
+DEFAULT_LLAMA_CPP_MODEL_REPO = "unsloth/Qwen3-1.7B-GGUF"
+DEFAULT_LLAMA_CPP_MODEL_FILE = "Qwen3-1.7B-Q4_K_M.gguf"
+DEFAULT_LLAMA_CPP_MAX_TOKENS = 384
+DEFAULT_LLAMA_CPP_N_CTX = 2048
+logger = logging.getLogger(__name__)
+
+
+class LlamaCppRuntimeUnavailableError(RuntimeError):
+    pass
+
+
+def _load_llama_cpp():
+    try:
+        from llama_cpp import Llama, LlamaGrammar
+    except ImportError as error:
+        raise LlamaCppRuntimeUnavailableError(
+            "Install llama-cpp-python to run the GGUF parser backend."
+        ) from error
+
+    return Llama, LlamaGrammar
+
+
+def _optional_int_env(name: str) -> int | None:
+    raw_value = os.getenv(name, "").strip()
+    if not raw_value:
+        return None
+    return int(raw_value)
+
+
+@lru_cache(maxsize=1)
+def load_llama_cpp_model(
+    repo_id: str = DEFAULT_LLAMA_CPP_MODEL_REPO,
+    filename: str = DEFAULT_LLAMA_CPP_MODEL_FILE,
+    n_ctx: int = DEFAULT_LLAMA_CPP_N_CTX,
+    n_threads: int | None = None,
+):
+    start_time = perf_counter()
+    logger.info(
+        "event=parser_llama_cpp_model_load_start repo=%s file=%s n_ctx=%s n_threads=%s",
+        repo_id,
+        filename,
+        n_ctx,
+        n_threads,
+    )
+    Llama, _LlamaGrammar = _load_llama_cpp()
+    kwargs = {
+        "repo_id": repo_id,
+        "filename": filename,
+        "n_ctx": n_ctx,
+        "verbose": False,
+    }
+    if n_threads is not None:
+        kwargs["n_threads"] = n_threads
+
+    model = Llama.from_pretrained(**kwargs)
+    logger.info(
+        "event=parser_llama_cpp_model_load_complete repo=%s file=%s elapsed_ms=%s",
+        repo_id,
+        filename,
+        round((perf_counter() - start_time) * 1000),
+    )
+    return model
+
+
+@lru_cache(maxsize=1)
+def llama_cpp_response_grammar():
+    _Llama, LlamaGrammar = _load_llama_cpp()
+    return LlamaGrammar.from_json_schema(
+        json.dumps(expected_response_format()),
+        verbose=False,
+    )
+
+
+def generate_parser_response_llama_cpp(
+    raw_text: str,
+    *,
+    repo_id: str = DEFAULT_LLAMA_CPP_MODEL_REPO,
+    filename: str = DEFAULT_LLAMA_CPP_MODEL_FILE,
+    max_tokens: int = DEFAULT_LLAMA_CPP_MAX_TOKENS,
+    n_ctx: int = DEFAULT_LLAMA_CPP_N_CTX,
+    n_threads: int | None = None,
+) -> str:
+    start_time = perf_counter()
+    messages = build_parser_messages(raw_text)
+    logger.info(
+        "event=parser_llama_cpp_generate_start repo=%s file=%s text_chars=%s max_tokens=%s",
+        repo_id,
+        filename,
+        len(raw_text),
+        max_tokens,
+    )
+    log_parser_messages(
+        backend="llama_cpp",
+        model_name=f"{repo_id}/{filename}",
+        messages=messages,
+    )
+    model = load_llama_cpp_model(
+        repo_id=repo_id,
+        filename=filename,
+        n_ctx=n_ctx,
+        n_threads=n_threads,
+    )
+    response = model.create_chat_completion(
+        messages=messages,
+        max_tokens=max_tokens,
+        temperature=0,
+        grammar=llama_cpp_response_grammar(),
+    )
+    response_text = response["choices"][0]["message"]["content"].strip()
+    logger.info(
+        "event=parser_llama_cpp_generate_complete repo=%s file=%s "
+        "response_chars=%s elapsed_ms=%s",
+        repo_id,
+        filename,
+        len(response_text),
+        round((perf_counter() - start_time) * 1000),
+    )
+    log_parser_response_text(
+        backend="llama_cpp",
+        model_name=f"{repo_id}/{filename}",
+        response_text=response_text,
+    )
+    return response_text
+
+
+def parse_check_in_with_llama_cpp(raw_text: str) -> ParsedCheckIn:
+    repo_id = os.getenv("LLAMA_CPP_MODEL_REPO", DEFAULT_LLAMA_CPP_MODEL_REPO)
+    filename = os.getenv("LLAMA_CPP_MODEL_FILE", DEFAULT_LLAMA_CPP_MODEL_FILE)
+    max_tokens = int(os.getenv("LLAMA_CPP_MAX_TOKENS", str(DEFAULT_LLAMA_CPP_MAX_TOKENS)))
+    n_ctx = int(os.getenv("LLAMA_CPP_N_CTX", str(DEFAULT_LLAMA_CPP_N_CTX)))
+    n_threads = _optional_int_env("LLAMA_CPP_N_THREADS")
+    response_text = generate_parser_response_llama_cpp(
+        raw_text,
+        repo_id=repo_id,
+        filename=filename,
+        max_tokens=max_tokens,
+        n_ctx=n_ctx,
+        n_threads=n_threads,
+    )
+    return parse_model_response(response_text)

training_coach/parser_ollama.py

@@ -14,7 +14,7 @@ from training_coach.models import ParsedCheckIn
 
 
 OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
-OLLAMA_MODEL = "qwen3:8b"
+OLLAMA_MODEL = "qwen3:1.7B"
 OLLAMA_TINY_CANDIDATE = "qwen3:4b"
 logger = logging.getLogger(__name__)
 

training_coach/parser_service.py

@@ -2,12 +2,14 @@ import logging
 import os
 
 from training_coach.models import ParsedCheckIn
+from training_coach.parser_llama_cpp import parse_check_in_with_llama_cpp
 from training_coach.parser_ollama import parse_check_in_with_ollama
 from training_coach.parser_runtime import parse_check_in_with_model
 
 
 DEFAULT_LOCAL_BACKEND = "ollama"
-DEFAULT_SPACE_BACKEND = "transformers"
+DEFAULT_SPACE_BACKEND = "llama_cpp"
+DEFAULT_OLLAMA_MODEL = "qwen3:1.7B"
 logger = logging.getLogger(__name__)
 
 
@@ -30,7 +32,7 @@ def parse_check_in_with_configured_backend(raw_text: str) -> ParsedCheckIn:
     if backend == "ollama":
         parsed = parse_check_in_with_ollama(
             raw_text,
-            model_name=os.getenv("OLLAMA_MODEL", "qwen3:8b"),
+            model_name=os.getenv("OLLAMA_MODEL", DEFAULT_OLLAMA_MODEL),
         )
         logger.info(
             "event=parser_complete backend=%s missing_fields=%s follow_up_questions=%s",
@@ -39,6 +41,15 @@ def parse_check_in_with_configured_backend(raw_text: str) -> ParsedCheckIn:
             len(parsed.follow_up_questions),
         )
         return parsed
+    if backend == "llama_cpp":
+        parsed = parse_check_in_with_llama_cpp(raw_text)
+        logger.info(
+            "event=parser_complete backend=%s missing_fields=%s follow_up_questions=%s",
+            backend,
+            len(parsed.missing_fields),
+            len(parsed.follow_up_questions),
+        )
+        return parsed
     if backend == "transformers":
         parsed = parse_check_in_with_model(raw_text)
         logger.info(
@@ -50,6 +61,5 @@ def parse_check_in_with_configured_backend(raw_text: str) -> ParsedCheckIn:
         return parsed
     logger.error("event=parser_unsupported_backend backend=%s", backend)
     raise ValueError(
-        "Unsupported PARSER_BACKEND. Use 'ollama' for local Ollama or "
-        "'transformers' for Hugging Face Spaces."
+        "Unsupported PARSER_BACKEND. Use 'ollama', 'llama_cpp', or 'transformers'."
     )