Why “Pulling Manifest” Is the Canary for Half-Proxied Stacks

In 2026, Ollama stays the shorthand path from zero to local inference: wrap weights, quantization, and a tiny HTTP daemon into one ergonomically blunt command line so teams can iterate before they commit to heavyweight serving stacks. Progress feels inevitable until someone runs ollama pull qwen:latest and watches the spinner park on “pulling manifest” or a tag-list preamble that never resolves. The failure is deceptive because chats, Markdown docs, even marketing pages hosted on unrelated CDNs remain snappy enough to convince people the WAN is broadly “fine.” Underneath, Clash (especially Mihomo-class cores) evaluates split rules per connection. If your subscription quietly elevates catch-all GEOIP directives or merges someone else’s domestic-direct shortcuts, the slender HTTPS probes that authenticate against the upstream registry can walk a different WAN policy than chunky blob transfers that happen moments later—or never start because the handshake never clears.

The mental model parallels other developer-artifact guides on this site, but swap the CDN shapes. Compared with downloading Python wheels or Git LFS objects in the Hugging Face Hub split-rule article, Ollama’s CLI keeps more of the choreography behind a curated binary. Compared with toolchain managers that choke on CDN-only tarballs (npm), Ollama centralizes manifests and layers around the same vendor namespace. Compared with pulling container images strictly from registry-1.docker.io when you intentionally run Ollama in Docker Desktop, overlap exists only if layer fetches—not model manifests—sit on Docker Hub; differentiate those flows using Docker Desktop’s proxy layering guide so daemon-level routing does not collide with CLI expectations on the bare host.

First-match discipline remains the hinge. Readers who skim the core rule-split guide already accept that order beats cleverness; this article repeats the lesson specifically where MATCH and GEOIP reordering masquerades as flaky software.

What Happens During ollama pull Before Layers Move

Although end users rightly treat ollama pull as downloading a folder of tensors, implementations lean on Docker Registry V2-compatible semantics internally. The handshake requests a digest manifest keyed by repo and tag, negotiates authorization headers if any, validates parent references, enumerates blobs, and only afterward fans out chunked downloads onto storage edges that sometimes share certificates with the canonical API frontend and sometimes appear as geographically proximate CDNs depending on rollout. Tiny JSON responses mask huge consequence: stalled manifest IO means bandwidth graphs never twitch; users mistake that for corrupted mirrors rather than unanswered HTTPS.

Because each hop inherits whatever policy matched first inside Clash, a profile that mistakenly routes pulling manifest probes through overloaded residential exits—or worse forces them DIRECT through an ISP upstream that RSTs CONNECT—appears intermittently identical to upstream outage. Conversely, blobs may succeed intermittently via HTTP/3 paths while manifest calls remain HTTP/2-only quirks. Documenting deterministic suffix coverage sidesteps superstitions about swapping models.

For teams running scripted CI, systemd units, launchd plist jobs, or WSL wrappers, parity matters: whichever environment instantiates ollama serve must expose the identical proxy knobs as interactive shells.

Hostnames You Actually See Behind registry.ollama.ai, ollama.com, and Friends

Operational reality begins with authoritative suffixes tied to vendor infrastructure. Releases and CDN arrangements evolve quicker than evergreen blog snippets, yet two durable anchors recur in connection logs collected across regions: workloads hitting registry.ollama.ai-style canonical registry hosts alongside marketing and documentation shells under ollama.com. Prefer DOMAIN-SUFFIX umbrellas over brittle single-host assumptions so minor subdomain churn does not regress your nightly automation.

Blob delivery sometimes surfaces additional storage-like subdomains tied to commodity CDNs behind TLS names you may not memorize. Fight the temptation to paste gigantic domain lists scraped from unrelated years; Mihomo exposes enough logging to cite the definitive hostname from the failing handshake. Extend YAML only after the log warrants it. When Cloudflare-ish edges appear, remember that Mihomo sniffers infer application metadata from payloads only when tuning is prudent—see Sniffer hygiene later.

Mirror operators—often internal IT or regional academic mirrors—expose entirely different apex domains. Routing only .ollama.ai while environment variables secretly retarget HTTPS to mirror.example.edu guarantees silent mismatches unless you carve both suffix groups intentionally.

Proxies Outside Clash Still Need Agreement

Upstream maintainers rightly remind operators that sanctioned networks use HTTP_PROXY / HTTPS_PROXY wherever daemons detach from GNOME/macOS toggles. If your service unit wipes environment imports, Clash listens perfectly while systemd-launched servers never CONNECT. Conversely, injecting proxy env without widening NO_PROXY traps loopback dashboards with misrouted websocket calls. Harmonize systemd Environment= lines, NSSwitch behavior, corporate PAC files, corporate SSL inspection middleware, Clash HTTPS listeners on loopback versus LAN binding, Windows service contexts, all before swapping exit countries.

Do not confuse OLLAMA_HOST—commonly documenting how clients dial your local inference listener—with changing which upstream warehouse supplies weights. Operators who paste random mirror tutorials without restarting the supervising unit confuse themselves most often here.

When HTTPS_PROXY points at Mihomo mixed ports, enforce consistent authentication (none versus basic) and forbid double-proxy loops where Mihomo proxies back into Mihomo unintentionally.

Give Ollama a Dedicated Proxy-Group

Even if early iterations simply mirror your generic PROXY pool, name matters: OL_REGISTRY (or similarly explicit) communicates intent to future merges. Separation lets you widen url-test intervals for multi-gigabyte pulls without risking gaming/streaming staleness regressions unrelated to GPUs.

Inside the group bias toward throughput stability—not vanity ping leaderboards chasing synthetic datacenters continents away from Ollama’s storage footprints. Idle TLS teardown on aggressive churned nodes manifests as spooky resume resets mid-layer download right after manifests finally succeeded.

Where corporate policy restricts cross-border exits, annotate nodes with geo tags proactively so incident responders instantly know permissible swaps.

YAML Skeleton: Place Ahead of GEOIP Breadth Rules

The skeleton below anchors consistent manifest + blob traversal; broaden only once logs prove omission.

# Extend with mirrors or provider-specific overlays from your Mihomo logs
proxy-groups:
  - name: OL_REGISTRY
    type: select
    proxies:
      - NODE-STABLE-1
      - NODE-STABLE-2
      - PROXY

rules:
  # Official registry/documentation umbrella
  - DOMAIN-SUFFIX,ollama.ai,OL_REGISTRY
  - DOMAIN-SUFFIX,ollama.com,OL_REGISTRY

  # If logs show CDN-specific hosts unreachable via generic suffix, add scoped DOMAIN rows
  # - DOMAIN,cdn-edge.example.invalid,OL_REGISTRY

  # Organization mirror example (never guess—copy from traceroute/log)
  # - DOMAIN-SUFFIX,your-internal-mirror.tld,OL_REGISTRY_MIRROR

  # ... keep subscription GEOIP or MATCH AFTER these explicit developer rows ...

If merge tooling from providers injects GEOIP-before-custom ordering, escalate to user-controlled overlays or guarded rule-providers with precedence you dictate. Automated merges that silently shuffle priority cause the worst ghost bugs because manifests fail probabilistically whenever subscription authors reshuffle YAML.

DNS, Fake-IP, Sniffer—and When Transparent TUN Helps

Readers already wrestling with ambiguous resolver paths should skim the TUN mode guide for interplay between adapters and capture scope. Transparent capture alone never replaces explicit domain coverage for CLI daemons spawning short-lived lookups via libc resolvers differing from Chromium’s caching.

Under fake-ip, domain rules hinge on consistent interception of OS queries toward Mihomo listeners. Bypasses—Firefox DoH knobs, systemd-resolved quirks, stale VPN DNS locks—produce correct answers on paper yet wrong egress selection as soon as the kernel dials synthesized addresses your rules cannot match cleanly until Sniffer fingerprints succeed or fail.

Sniffer sensitivity settings demand caution: excessively permissive guesses mislabel generic HTTPS CDNs carrying unrelated SaaS payloads. Pair sniffed labels with corroborating SNI captures from Mihomo dashboards before rewriting entire policies around inferred process metadata.

Splitting Official Registry Traffic from Sanctioned Mirrors

Many write-ups hawk copy-pasta environment variables referencing third-party HTTPS mirrors duplicating blobs. Assume nothing: confirm legal standing, cryptographic trust, TTL policies, freshness SLAs—then bake explicit YAML for that mirror apex separate from OL_REGISTRY defaults. Mirrors often live closer geographically yet still traverse harsh inspection boxes; blindly forcing DIRECT to them “for speed” can recreate worse stalls than thoughtfully proxied WAN paths selected by stable nodes inside OL_REGISTRY.

When mirrored hosts share CDNs with broader SaaS footprints, sloppy DIRECT lines risk leaking unrelated developer traffic unintended for domestic inspection. Surgical DOMAIN rows outperform wildcard shortcuts.

Hybrid organizations sometimes pull internal manifests from artifact registries resembling generic Docker setups but unrelated to Docker Hub layering; keep mental separation even if tooling syntax feels familiar.

Docker Hub and Containerized Ollama vs Native CLI Paths

Container operators still fetch base OS layers from canonical registries like registry-1.docker.io; those flows deserve rules documented for Docker—not copy-pasted Ollama suffix rows. Conversely, GPU-enabled hosts running native systemd services seldom touch Docker pulls when debugging manifest stalls. Mentioning Docker Hub avoids category errors where engineers tune the wrong outbound group chasing imaginary manifest bugs that were actually dangling layer retries.

Where WSL interoperability shares networking with Windows Desktop engines, reconcile both articles so neither half masks half-open sockets.

If Kubernetes sidecars wrap Ollama, ensure CNI overlays still honor whichever Service IP ranges should remain NO_PROXY; cluster East-West chatter must not traverse Clash by accident simply because manifests finally succeeded externally.

Verification Playbook Beyond Random Node Cycling

Operate like an SRE—not a gambler chasing lucky exits.

1. Reproduce the stall while Mihomo verbose logging exposes policy-group decisions and dial latency for the manifest hop.
2. Extract the precise hostname powering the stalled TLS handshake.
3. Grep YAML orders for GEOIP merges shadowing OL_REGISTRY directives.
4. Hit the same HTTPS endpoint via curl -Iv through identical proxy env shells or TUN scopes to bifurcate TLS trust issues versus routing.
5. Only after deterministic routing aligns, tune nodes—stretch url-test tolerate fields, prefer steady ASNs aligned with CDN exit geography.
6. Stress-test chunked downloads observing partial resume behavior verifying long idle TLS survives.
7. If systemd restarts intervene, replay full sequence post-boot to uncover race conditions resetting env imports.
8. For desktop GUIs spawning hidden helper daemons on macOS Gatekeeper quirks, inspect Console logs alongside Mihomo overlays.
9. WSL users cross-check Win32 proxy registry keys versus distro-level resolv.conf after each Windows patch Tuesday.
10. Close by documenting authoritative remediations in internal runbooks tying YAML revision IDs with subscription merge hashes—future you suffers fewer mystery regressions.

Correlation beats vibes: annotate timestamps across Ollama server logs (if debug logging enabled responsibly) and Mihomo session exports so network and application teams converge on one narrative.

Short Answers Operators Actually Search

Manifest stuck but browser fine—always DNS?

Often, yes; sometimes TLS MITM fingerprints differ per process; occasionally IPv6 precedence paths bifurcate from IPv4-heavy browser stacks. Logs determine which—not intuition.

Should GEOIP-CN lines stay below OL_REGISTRY inserts?

Preferably OL_REGISTRY anchors above catch-all GEOIP domestic shortcuts targeting domestic optimization; explicit developer exceptions should preempt broad CN routing when registry endpoints require foreign exits sanctioned by policy.

Sniffer mandatory?

Optional accelerant when IPs dominate logs lacking SNI fidelity; misuse injects hallucinated process labels—treat sniffing like medication with contraindications.

Does clearing models directory fix manifest timeouts?

Very rarely versus misaligned routing; wiping caches lengthens reproducibility without addressing HTTPS handshake regressions repeating identically afterward.

Choosing Engineering Clarity Over Ad-Hoc Workarounds

An ocean of brittle one-liners floats around forum threads promising magic mirror exports or blindly toggling system proxies without acknowledging first-match YAML, yet those fragments rarely survive the next subscription merge or systemd security hardening clampdown. Compared with juggling disconnected browser extensions plus hand-written SOCKS forwards that forget half your daemons entirely, disciplined profiles keep Ollama registry traffic seated beside the remainder of developer networking guardrails—which is precisely where Mihomo excels when operators treat pulling manifest timeouts as deliberate policy failures instead of folklore. That same clarity underpins Clash Official Site: curated clients, repeatable update paths, and documentation that insists on observable evidence before rewriting rules. When you prefer not to gamble every model download on brittle tips, pivot to consolidated tooling ready for reproducible infra—grab Clash Official Site’s maintained client builds and wire them using the playbook above instead of patching symptoms alone.