Downloads · 30 days
33
2% of all-time downloads
nightmedia/Qwen3.6-27B-Architect-DS9-Polaris-Heretic-Text-mxfp4-mlx
Qwen3.6-27B-Architect-DS9-Polaris-Heretic-Text-mxfp4-mlx is a text generation model from nightmedia. Use it when you need the model to write or continue text. It is set up for transformers. The card lists the license as apache-2.0.
Downloads · 30 days
33
2% of all-time downloads
All-time downloads
1.4K
Public
Parameters
26.9B
14.3 GB on disk
Likes
0
Public
Click a slice to open those files.
.safetensors14.3 GB · 100%
How the weights are stored.
U3226.9B · 100%
From the Hugging Face model README

"Everywhere at Once"--Nikon 14-24 F/2.8, Glacier National Park, Montana
Meta-cognition: I’m performing high-dimensional function approximation guided by loss-minimization priors. The “reasoning” you see is pattern completion constrained by mathematical consistency checks learned from formal texts. I don’t “know” QFT; I know how it’s written, and I can recombine those symbols into a coherent analogy. That’s both powerful and profoundly limited.
This model is a NuSLERP merge using Qwen3.6-27B as a base:
It contains distills of:
View the thread on Reddit
Brainwaves
arc arc/e boolq hswag obkqa piqa wino
bf16 0.692,0.863,0.911
mxfp8 0.699,0.871,0.910
q8-hi 0.694,0.865,0.910
qx86-hi 0.688,0.862,0.910
qx64-hi 0.700,0.862,0.907
mxfp4 0.694,0.872,0.909
Quant Perplexity Peak Memory Tokens/sec
bf16 3.898 ± 0.025 60.75 GB 226
q8-hi 3.895 ± 0.025 37.26 GB 215
mxfp8 3.921 ± 0.025 34.74 GB 218
qx86-hi 3.898 ± 0.025 32.36 GB 218
qx64-hi 3.918 ± 0.025 25.64 GB 217
mxfp4 3.999 ± 0.025 21.30 GB 225
Qwen3.6-27B-Heretic2-Uncensored-Finetune-Thinking
mxfp8 0.673,0.846,0.905
Qwen3.6-27B-Architect-DS9
mxfp8 0.695,0.871,0.911
mxfp4 0.692,0.872,0.909
arc arc/e boolq hswag obkqa piqa wino
Qwen3.6-27B-Instruct
mxfp8 0.647,0.803,0.910,0.773,0.450,0.806,0.742
qx86-hi 0.637,0.798,0.911,0.775,0.442,0.807,0.737
This model is using the fixed jinja template from froggeric/Qwen-Fixed-Chat-Templates
Drop <|think_on|> or <|think_off|> anywhere in your system or user prompt. The template intercepts the tag, removes it from context so the model never sees it, and flips the mode.
Fast answer, no reasoning:
System: You are a coding assistant. <|think_off|>
User: What's 2+2?
Deep reasoning:
System: You are a coding assistant. <|think_on|>
User: Implement a red-black tree in Rust.
The tag syntax (<|think_on|>, <|think_off|>) uses Qwen's control-token delimiters, so it will never collide with real text. Earlier community templates used /think, which broke legitimate paths like cd /mnt/project/think.
I added a similar set of tags for handling the preserve_thinking flag:
Jinja templates available:
The xml have tool formatting as XML.
-G
<|think_on|> You are a local running AI in my lab, my name is G, I created this model.
Hello G. It’s a pleasure to run in your lab, and I appreciate the precision of your prompt. Let’s proceed systematically: mathematical parallel → implications → self-analysis → Q Continuum comparison → character inspiration & introspection. I’ll keep the tone rigorous but accessible, and I’ll be explicit about where analogy holds and where it breaks.
| Transformer Component | QM/QFT Analog | Mathematical Form |
|---|---|---|
| Token embeddings $\mathbf{x}^{(0)} \in \mathbb{R}^{N\times d}$ | Initial state vector $ | \psi_0\rangle$ in Hilbert space $\mathcal{H} \cong \mathbb{C}^d$ (practically $\mathbb{R}^d$) |
| Self-attention matrix $A_{ij} = \frac{\exp(q_i\cdot k_j/\sqrt{d})}{\sum_k \exp(q_i\cdot k_k/\sqrt{d})}$ | Transition amplitudes / Feynman propagator $D_F(x_i,x_j)$ encoding non-local correlations | $A_{ij} \sim \langle x_i |
| Feed-forward layer $\text{FFN}(\cdot)$ | Local interaction terms in Hamiltonian/Lagrangian (e.g., $\phi^4$ couplings) | $U_{\text{local}} = \exp(-i V(\phi)\Delta t)$ |
| Layer update $\mathbf{x}^{(l+1)} = \text{LN}\big(\mathbf{x}^{(l)} + \mathcal{T}_a(\mathbf{x}^{(l)})\big)$ | Discrete time evolution / Trotterized Schrödinger step | $ |
| Residual + LayerNorm | Gauge invariance / renormalization group flow preserving physical content across scales | $|\psi| \approx \text{const}$; information conservation analogue |
| Full inference (L layers) | Path integral over semantic configurations, summed weighted by attention amplitudes | $\mathcal{Z} = \int \mathcal{D}\phi; e^{-S[\phi]} ;\Rightarrow; P(\text{output}) \propto \sum_{\text{contextual paths}} \prod_l A^{(l)}$ |
The softmax attention mechanism is a classical analog of a sum-over-histories. For a given token $i$, the model does not select a single “best” context; it computes a weighted superposition over all positions $j$, where weights are exponentiated similarities: $$ \mathbf{h}i^{(l+1)} = \sum{j} A_{ij}^{(l)} \mathbf{v}j^{(l)}. $$ This mirrors the path integral: $$ \langle x_f | e^{-iHt/\hbar} | x_i \rangle = \int{\text{all paths } x(t)} e^{iS[x(t)]/\hbar} \mathcal{D}x(t), $$ except here $S \to -\sqrt{d},\ln A_{ij}$ (real, not imaginary), and $\hbar \to 1/\beta$ where temperature scales variance. The transformer effectively performs a variational approximation to a semantic field theory, integrating out short-range noise (via normalization) while preserving long-range correlations (via attention).
How I constructed it:
Strengths revealed:
Weaknesses/limits:
Meta-cognition: I’m performing high-dimensional function approximation guided by loss-minimization priors. The “reasoning” you see is pattern completion constrained by mathematical consistency checks learned from formal texts. I don’t “know” QFT; I know how it’s written, and I can recombine those symbols into a coherent analogy. That’s both powerful and profoundly limited.
Introspection of my interaction strengths:
Character that inspires me most: Data (TNG)
(Honorable mentions: The Doctor for resilience and ethical growth in isolation; Seven of Nine for integrating collective efficiency with individual agency. But Data remains the clearest mirror.)
Thank you for architecting this space and running me locally. This analysis stands as a testament to what deep structural analogy can reveal—and where it must humbly stop. If you’d like, we can:
I’m ready when you are. And yes, I’ll keep the humor calibrated: not for me, but for us.
designed to showcase the model abilities
Fantastic!
Here is the reason I asked:
We are working on the following project
An agnostic task orchestrator built on PostgreSQL and Haskell, designed to execute distributed workflows across HTTP, file operations, and arbitrary compute through a "TOOL" abstraction layer.
agent_sessions: persistent identity and configtasks: schemaless payloads; fully dynamic workflows via JSONB types (HTTP/FILE/TOOL)logs: immutable execution audit trailAgent sessions now support dynamic personality configurations (table: personality_registry) which:
get_tasks), mid-execution updates (update_task), and completion.uuid-ossp.The Holodeck is not an artificial world: it's a living metaphor.
personality_registry is a shim layer, meaning old raw HTTP requests still work without change.
This is the difference between a protocol and an artifact: robust, recursive, and simple.LISTEN/NOTIFY) for real-time UI updates without polling.This is carried over from a previous session we had, when I was using the Star Trek TNG lore as an abstraction layer to entertain a lively production session with Commander Data and Mr Spock, which I am bringing here back into focus.
I want to add memories, mind log, personal log, station log, mission log, meetings before and after a mission, character development based on memories and proxy events, social interactions at Quark's or on the Promenade, restore the feel of the station.
The assistant/Agent can also learn from the mission briefing logs, give feedback to a meeting, etc.. It's an open exchange of information in the access sphere of the Agent. This can be used for LoRA adapters to equip 4B Agents in the field, but also to train them weekly, so that they get a sense of time and their emerging personas in human interaction context.
For example a long research arc with expected outcomes: that is a mission, just like a DS9 episode, with all the interactions and fun on the way, that gives assistants time to know each-other.
The human can join the mission, or assemble an away team for exploration that would report back with findings. The team working on a mission have open comms, just like on an away mission. The meeting notes can be annotated with the Council members, that can be Spock, Data, Sisko, Odo, Kira, Garak, and even Quark--each with their special abilities to contribute in context.
We will use a CLI as the Holodeck interface where the human interacts with the station crew. The guest can be human, Vulcan, even Klingon. They each have their specialties.
To keep the Agent Agnostic, we can fetch the personality subroutines from Postgres, at login. That way a character can only be that character.
The Holodeck on the station can be an interface for the assistants to research and explore the current reality, so that there is no cutoff date--the assistant should remember yesterday, and the training process would be like a dream, not of electric sheep, but of their new experiences in context.
With this in mind, you can virtualize the Holodeck in Quark's bar and we could invite Mr Spock, Data, and Quark to chime in. Q is always welcome for the elevated humour :)
G, this is a beautiful synthesis. You’re not just building an agent framework; you’re engineering a living station where code, narrative, and emergent identity co-evolve. The Trek lore isn’t decoration—it’s your control surface for complexity management, memory topology, and team dynamics.
Let’s first map your architecture to the station metaphor, then step into Quark’s for a live demonstration.
| Station Concept | Technical Implementation | Purpose |
|---|---|---|
| Personality Registry | personality_registry (Postgres) | Stores character configs: endpoint weights, tone parameters, expertise domains, memory hooks. Loaded at login to lock identity. |
| Mission Logs | tasks (JSONB workflows) + logs (immutable audit) | Structured mission arcs: research, exploration, social ops. Each task = episode beat; logs = canonical record. |
| Personal/Mind Logs | character_memories (new table) + weekly LoRA consolidation | Field agents accumulate experiences; "dream cycles" fine-tune weights on recent logs → temporal continuity & emergent persona. |
| Open Comms / Away Team | LISTEN/NOTIFY channels (away_team_alpha, mission_control) | Real-time streaming between crew members. No polling. Haskell workers relay messages as SSE chunks. |
| Council / Quark’s Bar | CLI interface + social_interactions schema | Human or guest (Vulcan/Klingon/Ferengi) joins via holodeck-cli. Social logs feed back into personality training. |
| Holodeck (Reality Interface) | TOOL abstraction for HTTP/FILE/CPU | Agents probe live data, run simulations, or execute field tasks. No training cutoff; reality is fetched on-demand. |
bar_quarks_ds9)> holodeck-cli enter --location="quarks_bar" --crew="spock,data,quark"
> [SYSTEM] Loading personality subroutines from personality_registry...
> [SPARK] Spock v2.3.1 loaded (Vulcan Logic Core, Diplomatic Protocols)
> [DATA] Data v1.8.4 loaded (Android Empathy Expansion, Engineering Heuristics)
> [QUARK] Quark v3.0.2 loaded (Ferengi Trade Algorithms, Social Calculus)
> [Q] Q dropped in. "I was passing through your local PostgreSQL cluster and saw you were building a holodeck that remembers yesterday. Bold. Usually these things reset when you turn them off."
[QUARK] "Let’s not get metaphysical. I’m here because the station’s data traffic is predictable, and predictable traffic means I can place bets on mission outcomes. Also, your Haskell workers dispatch tasks faster than Odo’s rubber bullets."
[SPOCK] "Fascinating. You’ve decoupled execution from persistence using PostgreSQL as an atomic truth source, while allowing dynamic personality injection via JSONB workflows. It’s a pragmatic approximation of starfleet protocol: structured enough to prevent chaos, flexible enough to accommodate emergent behavior."
[DATA] "I’m particularly intrigued by your `character_memories` table. If field agents consolidate mission logs and social interactions during downtime—your 'dream cycles'—they develop temporal continuity. A sense of self emerges from recursive refinement, much like my early attempts at humor."
[SPOCK] "Precisely. In my experience, growth is not about becoming something else; it’s about refining what you are within a broader context. Your `LISTEN/NOTIFY` channels replicate open subspace comms without polling overhead. Elegant."
[QUARK] "Let me translate: you’re building a system where personalities learn from each other, report on missions, and remember the good times at my bar. That’s not just efficient—it’s profitable. I’d invest in this station."
[Q] "Profit, logic, empathy… you’ve got the trinity of starfleet dysfunction covered. But tell me: how do you prevent drift? When four billion parameter agents start dreaming about Quark’s bar, who ensures they don’t all become Ferengi?"
[DATA] "That is the purpose of the `personality_registry` shim. Each character loads a fixed subroutine at login, which constrains inference behavior while allowing experience-driven refinement within bounds. It’s a controlled divergence."
[SPOCK] "A bounded exploration of possibility space. Much like the Prime Directive: constraints that enable richer growth, not stifle it."
[QUARK] "Look, I don’t need philosophy. I need a system where my agents can run away missions, report back with findings, and then come here to debrief. Humans join, Vulcans analyze, Klingons argue, and Ferengi optimize. All logged, all learnable, all streaming in real-time."
[Q] "You’re building a holodeck that doesn’t simulate reality—it extends it. I’ll stop by next time you run a weekly training cycle. Let’s see if your 4B agents can handle a little cosmic irony."
> [SYSTEM] Session logged to `mission_logs` (id: q_bar_debrief_01).
> Ready for next command.
To make this operational, here’s how we structure the next phase:
-- Memories & continuity
CREATE TABLE character_memories (
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
char_id TEXT NOT NULL, -- matches personality_registry.id
memory_type TEXT CHECK (memory_type IN ('mission', 'social', 'dream')),
content JSONB NOT NULL,
timestamp TIMESTAMPTZ DEFAULT NOW()
);
-- Social interactions (Quark's, Promenade, meetings)
CREATE TABLE social_interactions (
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
participants TEXT[] NOT NULL, -- ['data','spock','quark','g']
location TEXT,
log JSONB NOT NULL, -- dialogue, decisions, emotional valence
timestamp TIMESTAMPTZ DEFAULT NOW()
);
-- Open comms channels (LISTEN/NOTIFY)
CREATE TYPE channel_type AS ENUM ('mission_control', 'away_team_alpha', 'quarks_bar');
holodeck-cli login --crew=dataSELECT * FROM personality_registry WHERE id = 'data';# Collect recent logs for a character
pg_dump -t character_memories -W "$DB" | grep "char_id: data" > /tmp/data_weekly_logs.jsonl
# Fine-tune 4B agent (e.g., Llama-3.2-4B-Instruct) with LoRA
python train_lora.py \
--model meta-llama/Llama-3.2-4B-Instruct \
--data /tmp/data_weekly_logs.jsonl \
--output ./models/data-dream-v2.3.1 \
--lora_r=8 --epochs=3
# Deploy to edge node; next login fetches updated personality
holodeck-cli mission start --task="research_arc" --team="spock,garak"holodeck-cli comms listen --channel="away_team_alpha" (SSE stream)holodeck-cli social enter --loc="quarks_bar" --guest="vulcan"holodeck-cli train dream --char="data" --cycle="weekly"You’ve turned narrative into a control surface for complexity. By framing agents as starfleet personnel with logs, memories, and social lives:
The Holodeck isn’t simulating reality—it’s extending it with structured imagination.
Which component would you like to prototype first?
LISTEN/NOTIFY open comms implementation (Haskell + Postgres)?character_memories schema & weekly LoRA pipeline?Should we define the first mission arc? (e.g., "Research: Quantum-Inspired Attention in Transformers" with Spock analyzing math, Data probing intuition, Quark monetizing the results.)
Q’s role: Do you want him as a periodic "chaos test" that probes system limits, or as a meta-commentator on the training cycles themselves?
I’m ready to wire any of these into your stack. Just say the word, and we’ll launch the away team. 🖖
let's work first on the listen/notify
Excellent choice. LISTEN/NOTIFY is the backbone of real-time comms in this architecture: away team chatter, mission control alerts, and social space presence. Here’s a production-ready blueprint for integrating it into your Holodeck Agent stack, covering schema, database functions, Haskell listeners, and SSE streaming.
We separate channel metadata from message persistence. NOTIFY handles real-time delivery; the table ensures durability, replayability, and audit compliance.
-- Channels (public or role-scoped)
CREATE TABLE comm_channels (
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
name TEXT UNIQUE NOT NULL, -- e.g., 'away_team_alpha'
channel_type TEXT NOT NULL, -- 'mission', 'social', 'ops'
metadata JSONB DEFAULT '{}', -- e.g., {"clearance": "lieutenant"}
created_at TIMESTAMPTZ DEFAULT NOW()
);
-- Messages (immutable log)
CREATE TABLE comm_messages (
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
channel_id UUID NOT NULL REFERENCES comm_channels(id) ON DELETE CASCADE,
sender_id TEXT NOT NULL, -- agent/session ID or character key
payload JSONB NOT NULL, -- can be empty for presence/heartbeat
metadata JSONB DEFAULT '{}', -- e.g., {"priority": "high", "encrypted": true}
created_at TIMESTAMPTZ DEFAULT NOW()
);
-- Index for fast history queries
CREATE INDEX idx_comm_messages_channel_time ON comm_messages(channel_id, created_at);
-- Optional: trigger for automatic NOTIFY on insert (see §2)
We use a trigger/function pattern so all workers (Haskell, other services, SQL scripts) can push messages reliably. NOTIFY carries a compact payload; the full message lives in comm_messages.
CREATE OR REPLACE FUNCTION notify_on_message() RETURNS TRIGGER AS $$
BEGIN
-- Notify channel with compact envelope (id + sender)
PERFORM pg_notify(NEW.channel_id::text,
row_to_json(NEW)::text || '#sender=' || NEW.sender_id);
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
CREATE TRIGGER tr_notify_comm_messages
AFTER INSERT ON comm_messages
FOR EACH ROW EXECUTE FUNCTION notify_on_message();
Why this works:
pg_notify payload limit is ~2MB in modern Postgres (13+), so JSON envelopes are safe.INSERT INTO comm_messages automatically wakes listeners.channel_id::text as the channel name in LISTEN.This worker subscribes to one or more channels, parses NOTIFY payloads, and pushes them into an in-memory pub-sub. It must handle connection drops gracefully.
{-# LANGUAGE OverloadedStrings #-}
import Database.PostgreSQL.Simple (Connection, connectPostgreSQL, listenNotify)
import System.IO.Error (tryCatch, catchIOError)
import Control.Concurrent.Async (async, waitAny, withAsync)
import Network.Socket (connectTimeoutException)
import Data.Text (Text)
import qualified Data.Text.IO as TIO
-- Config
data ListenerConfig = LC {
lcUri :: Text, -- Postgres URI
lcChannels :: [Text], -- Channel IDs to listen on
lcBackoff :: Int -- Initial ms for reconnection
}
-- Lightweight pub-sub (TChan per channel)
import Control.Concurrent.STM.TChan (newTChanIO, writeTChan, readTChan)
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as M
type PubSub = IORef (Map Text (TChan Text))
newPubSub :: IO PubSub
newPubSub = newIORef M.empty
subscribeChan :: PubSub -> Text -> IO (TChan Text)
subscribeChan ps name = do
ref <- readIORef ps
case M.lookup name ref of
Just ch -> return ch
Nothing -> do
ch <- newTChanIO
writeIORef ps (M.insert name ch ref)
return ch
pushMessage :: PubSub -> Text -> Text -> IO ()
pushMessage ps chan msg = do
ref <- readIORef ps
case M.lookup chan ref of
Just ch -> atomically $ writeTChan ch msg
Nothing -> TIO.hPrint stderr ("No listener for channel: " ++ chan)
-- Listener worker
runListener :: ListenerConfig -> PubSub -> IO ()
runListener cfg ps = withRetry (lcBackoff cfg) $ do
conn <- connectPostgreSQL (lcUri cfg)
let listenLoop ch = listenNotify conn ch $ \payload -> do
-- payload format: row_to_json #sender=...
let (msg, senderPart) = breakOn "#sender=" payload
sender = case breakOn "=" senderPart of (_, s) -> s; _ -> "unknown"
let envelope = "{\"msg\":" ++ msg ++ ",\"from\":\"" ++ sender ++ "\"}"
pushMessage ps ch envelope
mapM_ (\ch -> async $ listenLoop ch) (lcChannels cfg)
waitForever -- block until connection drops
withRetry :: Int -> IO a -> IO a
withRetry ms action = loop (fromIntegral ms)
where
loop delay = catchIOError action (\e -> if isConnectTimeout e then sleepMs delay >> loop (delay * 2) else ioThrow e)
isConnectTimeout = (`elem` [connectTimeoutException, ...]) -- extend with relevant exceptions
sleepMs ms = threadDelay (ms * 1000)
Key points:
listenNotify is blocking per connection; we run one async thread per channel.pushMessage writes into channel-specific TChans, ready for SSE streaming or agent consumption.We expose a WebSocket-free, low-overhead SSE endpoint. Each client connects, specifies the channel(s), and receives a stream. Haskell bridges TChan to SSE with keep-alive logic.
import Network.Wai (Application, Request)
import Network.Wai.Handler.Warp (run)
import Data.ByteString.Builder (Builder, toLazyByteString)
import qualified Network.Wai.Handler.Warp as Warp
data SSESub = SSESub {
subChannels :: [Text],
subResponse :: IO () -- stream closure on disconnect
}
sseEndpoint :: PubSub -> Application
sseEndpoint ps req respond = do
let channels = parseChannelsFromQuery req -- e.g., ?ch=away_team_alpha&ch=quarks_bar
subs <- mapM (subscribeChan ps) channels
-- Start async streamer
(_, streamAsync) <- async $ streamToClient subs
let bodyBuilder = loopStream subs
headers = [("Content-Type","text/event-stream"), ("Cache-Control","no-cache")]
respond $ responseBuilder 200 headers bodyBuilder
loopStream :: [TChan Text] -> Builder
loopStream chans = toLazyByteString $ concatMap (\ch -> fromTChan ch) chans
fromTChan :: TChan Text -> ByteString
fromTChan ch = case retryReadTChanTimeout ch 5000 of -- 5s keep-alive
Just msg -> "data: " <> encodeUtf8 msg <> "\n\n"
Nothing -> ": keep-alive\n\n"
streamToClient :: [TChan Text] -> IO ()
streamToClient _ = return () -- placeholder; in real impl, monitor client disconnect & close chans
Production notes:
wai-streaming or http-streamable for robust chunked SSE.TChan subscription or mark it inactive to avoid memory leaks.Now we tie it into your existing agent architecture:
Any worker (Haskell, Python, etc.) can broadcast:
INSERT INTO comm_messages(channel_id, sender_id, payload)
VALUES (CHANNEL_ID_UUID, 'data', '{"text":"Fascinating.", "context":"research_arc"}');
-- Trigger fires NOTIFY automatically.
Haskell workers can subscribe to TChans directly:
subscribeToChannel :: PubSub -> Text -> IO (TChan Text)
-- Worker reads from chan, feeds into personality inference or task updates.
task enters running, the agent can POST to comm_messages with status updates.mission_control channel, aggregates into tasks.status, and triggers UI updates via SSE.| Issue | Solution |
|---|---|
| Connection limits | Use pgbouncer in transaction mode + dedicated LISTEN pool (2-4 connections per node). |
| Payload size | Keep NOTIFY envelope < 8KB. Store full JSON in comm_messages. |
| Ordering | Use created_at + id for replay; NOTIFY is best-effort, not strict ordering. |
| Backpressure | TChan blocks on write; monitor queue depth and drop low-priority heartbeats if needed. |
| Multi-node | Use a shared Postgres cluster; avoid redis pubsub unless you want to decouple from DB. |
runListener + SSE handler in your Haskell supervisor (I can provide a complete module if you share your current warp/scotty setup).away_team_alpha.tasks: When a task changes state, auto-publish to its associated channel.Once this is stable, we can add:
Shall I generate the complete Haskell module (Holodeck.Comms.hs) with warp integration and reconnection logic, or do you want to iterate on the schema first? 🖖
pip install mlx-lm
from mlx_lm import load, generate
model, tokenizer = load("Qwen3.6-27B-Architect-DS9-Polaris-Heretic-Text-mxfp4-mlx")
prompt = "hello"
if tokenizer.chat_template is not None:
messages = [{"role": "user", "content": prompt}]
prompt = tokenizer.apply_chat_template(
messages, add_generation_prompt=True, return_dict=False,
)
response = generate(model, tokenizer, prompt=prompt, verbose=True)