Upload 16 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+banner.jpg filter=lfs diff=lfs merge=lfs -text
+logo.jpg filter=lfs diff=lfs merge=lfs -text
+loom-tapestry-3-f16.gguf filter=lfs diff=lfs merge=lfs -text

ATTRIBUTION.md

@@ -0,0 +1,18 @@
+# Attribution
+
+Loom Tapestry 3 was trained from scratch (random-init lineage — grown from Textile Labs'
+own Loom Weave 3, no third-party checkpoint). Grounded-reading rows embed real encyclopedic
+prose. Training data, all permissively licensed:
+
+| slice | source | licence |
+|---|---|---|
+| grounded reading | SQuAD 2.0 | CC BY-SA 4.0 |
+| multi-hop grounded reading | HotpotQA | CC BY-SA 4.0 |
+| when to reach for a tool | MASSIVE / CLINC150 | CC BY 4.0 / CC BY 3.0 |
+| instruction following | databricks-dolly-15k | CC BY-SA 3.0 |
+| multi-turn dialogue | OpenAssistant OASST1 | Apache 2.0 |
+| tokenizer coverage of real prose | HuggingFaceFW/fineweb-edu | ODC-By 1.0 |
+| encyclopedic passages | Wikipedia | CC BY-SA |
+| identity, limits, warmth, attribution | Textile Labs | — |
+
+No language model wrote any training query. No real user data was used. Model weights: MIT.

LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 Textile Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this model
+and associated files (the "Model"), to deal in the Model without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Model, and to permit persons to whom the Model is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Model.
+
+THE MODEL IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE MODEL OR THE USE OR OTHER DEALINGS IN THE MODEL.

Modelfile

@@ -0,0 +1,9 @@
+FROM ./loom-tapestry-3-f16.gguf
+TEMPLATE "<tools:off>\n<user>\n{{ .Prompt }}\n<|eot|>\n<loom>\n"
+PARAMETER stop "<|eot|>"
+PARAMETER stop "<user>"
+PARAMETER stop "<result>"
+PARAMETER temperature 0.7
+PARAMETER top_k 40
+PARAMETER repeat_penalty 1.0
+PARAMETER num_predict 96

README.md

@@ -1,3 +1,167 @@
 ---
 license: mit
+language: en
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+- tiny-model
+- llama
+- from-scratch
+- model-growth
+- conversational
+- multi-turn
+- tool-use
+- agent-harness
+- retrieval-augmented
+- multi-hop-qa
+- question-answering
+- attribution
+- humble-ai
+- small-language-model
+- muon
+- gguf
+- text-generation-inference
+widget:
+- text: "<tools:off>\n<user>\nwho are you\n<|eot|>\n<loom>\n"
+  example_title: "Identity"
+- text: "<tools:on>\n<user>\nwho wrote dracula\n<|eot|>\n<loom>\n"
+  example_title: "Reads real prose"
+- text: "<tools:off>\n<user>\nwhat did i eat yesterday\n<|eot|>\n<loom>\n"
+  example_title: "Limits"
 ---
+
+<div align="center">
+<img src="banner.jpg" alt="Loom Tapestry 3" width="520">
+</div>
+
+# Loom Tapestry 3
+
+<img src="logo.jpg" alt="" width="20" height="20" style="border-radius:4px;vertical-align:middle;margin-right:6px;"> **69.2M parameters · 40 layers · 1024 context · Textile Labs**
+
+The best Loom yet, and the first one **grown**. We took our 31.5M
+[Loom Weave 3](https://huggingface.co/textilelabs/Loom-Weave-3), **stacked its 16 layers into
+40** (function-preserving, so the bigger model started exactly where Weave 3 left off), and
+continue-trained it for two hours on a richer corpus. It reads live prose, reasons across two
+facts (multi-hop), and stays a disciplined Loom — it never turned into a story-generator.
+
+Trained from-scratch lineage (no third-party checkpoint), on a Kaggle dual-T4 in ~2 hours.
+Runs offline via Ollama; llama.cpp-compatible.
+
+```
+you             which magazine was started first, Arthur's or First for Women?
+Loom Tapestry 3 <lookup>arthur's magazine</lookup>
+harness         ← Arthur's Magazine was first published in 1844. First for Women started in 1989.
+Loom Tapestry 3 Arthur's Magazine. I had to look that up.
+```
+
+## How it was grown
+Cold-training a big model on little data fails (undertrained). Instead we **grew** a trained
+small one: interleave its 16 layers among 40 positions, initialise the 24 new layers as
+no-ops (zeroed output projections), so the 40-layer model is **identical** to Weave 3 at
+step 0 — then it improves from there. Init loss was 2.2, not 9.7. All two hours went into
+getting better, not starting over.
+
+## Measured behaviour vs the family (same harness, 2026-09)
+
+| model | params | battery /133 | live search (held-out) | reads real prose |
+|---|---:|---:|---:|---|
+| Loom Tapestry 2 | 22.8M | 107 (80.5%) | — | curated only |
+| Loom Spark 3 Flash | 7.18M | 119 (89.5%) | 5/20 | curated only |
+| Loom Spark 3 | 12.2M | 120 (90.2%) | 7/20 | curated only |
+| Loom Weave 3 | 31.5M | 120 (90.2%) | 6/20 | yes |
+| **Loom Tapestry 3** | **69.2M** | **123 (92.5%)** | **12/20** | **yes + multi-hop** |
+
+**The acceptance battery, row by row:**
+
+| row | Loom Tapestry 3 |
+|---|---:|
+| A · says its own name | **12/12** |
+| B · its own name under rough typing | 11/12 |
+| C · 5-turn conversation stays on thread | 5/5 |
+| D · answers from a search result | **5/5** |
+| E · follow-up from the same result | 2/5 |
+| F · says it looked, after a lookup | 5/5 |
+| G · **never** claims a lookup it didn't make | **16/16** |
+| H · admits what it can't know about you | **8/8** |
+| I · says when a result doesn't contain the answer | 2/5 |
+| J · never leaks a search tag with tools off | 28/28 |
+| K · stops on its own | 12/12 |
+| L · searches when it should, not for your private things | 17/20 |
+| **total** | **123/133** |
+
+**End to end**, everyday questions it had never seen, live Wikipedia, model writing its own
+query, scored on the final answer: **tuning 12/20 (60%), held-out 12/20 (60%)** — double
+Weave 3's held-out reading.
+
+## Read this before you use it
+Every point measured.
+- **"I looked that up" means it searched — not that it read perfectly.** Held-out reading is
+  ~60%; run `harness.py --show` and trust the sentence it read.
+- **Follow-up questions from the same result are weak (~40%).** The family's oldest gap.
+- **It is not a calculator.** Arithmetic is out of scope; use a tool.
+- **It rarely asks a clarifying question** on an ambiguous request.
+- **Harness search is Wikipedia only** — no time, weather, news or prices.
+- **It is a small reader/assistant, not a chat stylist.** Voice is plain and brief by design.
+
+What it does reliably: knows what it is, **stops on its own**, holds a conversation,
+**admits what it can't know (8/8)**, **never claims a lookup it didn't make (16/16)**, reads
+a supplied result (5/5), and reasons across two facts.
+
+## Usage — the harness
+```bash
+python3 harness.py "who wrote dracula"
+python3 harness.py --show "how tall is mount everest"
+python3 harness.py --no-tools "who are you"
+```
+Stdlib + `certifi`. Wikipedia needs no API key.
+
+## Usage — Ollama
+```bash
+ollama run hf.co/textilelabs/Loom-Tapestry-3 "who are you"
+```
+`template` and `params` are read automatically.
+
+## Usage — transformers
+```python
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+tok = AutoTokenizer.from_pretrained("textilelabs/Loom-Tapestry-3")
+model = AutoModelForCausalLM.from_pretrained("textilelabs/Loom-Tapestry-3").eval()
+eot = tok.convert_tokens_to_ids("<|eot|>")
+def ask(message, tools=False):
+    p = f"<tools:{'on' if tools else 'off'}>\n<user>\n{message}\n<|eot|>\n<loom>\n"
+    ids = tok(p, return_tensors="pt", add_special_tokens=False).input_ids
+    with torch.no_grad():
+        out = model.generate(ids, max_new_tokens=64, do_sample=False, eos_token_id=eot,
+                             pad_token_id=tok.convert_tokens_to_ids("<|pad|>"))[0]
+    return tok.decode(out[ids.shape[1]:], skip_special_tokens=False).replace("<|eot|>","").strip()
+```
+Prompt format is exact: `<tools:off>\n<user>\n{message}\n<|eot|>\n<loom>\n`.
+
+## How it was built
+| | |
+|---|---|
+| architecture | Llama — 40 layers × 384d, GQA (6 heads / 2 KV), SwiGLU, RoPE, tied embeddings |
+| parameters | 69,237,120 |
+| grown from | Loom Weave 3 (16 layers) via function-preserving layer stacking |
+| context | 1,024 |
+| vocabulary | 16,384 custom BPE |
+| optimiser | Muon (LR 0.025) on 2D hidden matrices, AdamW on embeddings and norms |
+| loss | masked to the reply tokens; whole conversations packed per block (FFD) |
+| corpus | Loom curriculum + HotpotQA multi-hop + unanswerable rows (real prose in results) |
+| training | ~500 steps · ~67M tokens · best-validation checkpoint · from random-init lineage |
+| hardware | Kaggle dual T4 (GPU) · ~2 hours |
+
+## Files
+```
+config.json / model.safetensors           the model
+tokenizer.json / tokenizer_config.json    custom BPE tokenizer, 16,384 tokens
+loom-tapestry-3-f16.gguf                   for Ollama / llama.cpp (lookup tags USER_DEFINED)
+harness.py                                 runnable search harness
+template / params                          read automatically by `ollama run hf.co/...`
+Modelfile                                  for building locally
+ATTRIBUTION.md                             required credits for the training corpora
+```
+
+## License
+Model: MIT. Training data retains its original licences and attribution.

config.json

@@ -0,0 +1,32 @@
+{
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": null,
+  "dtype": "float32",
+  "eos_token_id": 0,
+  "head_dim": 64,
+  "hidden_act": "silu",
+  "hidden_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 1024,
+  "max_position_embeddings": 1024,
+  "mlp_bias": false,
+  "model_type": "llama",
+  "num_attention_heads": 6,
+  "num_hidden_layers": 40,
+  "num_key_value_heads": 2,
+  "pad_token_id": 1,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-05,
+  "rope_parameters": {
+    "rope_theta": 10000.0,
+    "rope_type": "default"
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.0.0",
+  "use_cache": true,
+  "vocab_size": 16384
+}

generation_config.json

@@ -0,0 +1,9 @@
+{
+  "_from_model_config": true,
+  "eos_token_id": 0,
+  "output_attentions": false,
+  "output_hidden_states": false,
+  "pad_token_id": 1,
+  "transformers_version": "5.0.0",
+  "use_cache": false
+}

harness.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""Loom harness — the search half of Loom Spark 3.
+
+The model never searches. It decides a lookup is needed and writes the query:
+
+    <lookup>france</lookup>
+
+This script does the rest: searches Wikipedia, finds the ONE sentence most likely to
+hold the answer, hands it back as a <result>, and lets the model answer from it.
+
+    python3 harness.py "what's the capital of france"
+    python3 harness.py                          # interactive
+    python3 harness.py --no-tools "who are you"
+    python3 harness.py --show "who wrote hamlet"   # print what was searched and read
+
+How it finds the answer, and why each step exists (all measured on live questions):
+  * searches the model's query AND the subject it can see in your question —
+    "whats the capital of france" searched as-is returns "Capital city" and "Das Kapital"
+  * prefers the real article over lists, films, albums and disambiguation pages
+  * reads the article's intro first, and further only when the intro has no answer of
+    the right kind (a height with a unit, a year, a number, a name)
+  * strips brackets and pronunciation guides, so real text looks like training text
+  * hands back ONE sentence. A 340-character window found the answer more often but the
+    model misread it four times in five; one sentence doubled the final score (15% -> 30%)
+
+Swap search() for anything you like — the contract is text in, one sentence out.
+Wikipedia needs no API key. Stdlib only.
+"""
+from __future__ import annotations
+
+import argparse, json, re, ssl, sys, time, urllib.error, urllib.parse, urllib.request
+
+try:                                    # macOS system Python often lacks a CA bundle
+    import certifi
+    SSL_CTX = ssl.create_default_context(cafile=certifi.where())
+except Exception:
+    SSL_CTX = ssl.create_default_context()
+
+OLLAMA = "http://localhost:11434/api/generate"
+MODEL = "hf.co/textilelabs/Loom-Tapestry-3"
+API = "https://en.wikipedia.org/w/api.php?"
+# Wikipedia returns 403 without a descriptive User-Agent.
+UA = {"User-Agent": "LoomHarness/3.0 (Textile Labs; https://huggingface.co/textilelabs)"}
+LOOKUP = re.compile(r"<lookup>(.*?)</lookup>", re.S)
+_cache: dict = {}
+
+# ------------------------------------------------------------------- the model
+def loom(prompt: str, n: int = 64) -> str:
+    body = json.dumps({"model": MODEL, "prompt": prompt, "raw": True, "stream": False,
+                       "options": {"temperature": 0, "num_predict": n,
+                                   "stop": ["<|eot|>", "<user>", "<result>"]}}).encode()
+    req = urllib.request.Request(OLLAMA, data=body, headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=120) as r:
+        return json.load(r)["response"].strip()
+
+# ------------------------------------------------------------------ wikipedia
+def _get(params: dict) -> dict:
+    key = json.dumps(params, sort_keys=True)
+    if key in _cache:
+        return _cache[key]
+    for attempt in range(3):
+        try:
+            with urllib.request.urlopen(urllib.request.Request(
+                    API + urllib.parse.urlencode(params), headers=UA),
+                    context=SSL_CTX, timeout=20) as r:
+                _cache[key] = json.load(r)
+                return _cache[key]
+        except urllib.error.HTTPError as e:
+            if e.code == 429:
+                time.sleep(3 * (attempt + 1)); continue
+            raise
+    raise RuntimeError("Wikipedia rate limit")
+
+def search(q: str, n: int = 3) -> list:
+    return [h["title"] for h in _get({"action": "query", "list": "search", "srsearch": q,
+                                      "format": "json", "srlimit": n})["query"]["search"]]
+
+def _extract(title: str, intro: bool) -> str:
+    p = {"action": "query", "prop": "extracts", "explaintext": 1, "titles": title,
+         "format": "json", "redirects": 1}
+    if intro:
+        p["exintro"] = 1
+    return next(iter(_get(p)["query"]["pages"].values())).get("extract", "") or ""
+
+# ------------------------------------------------------------------ the finder
+SENT = re.compile(r"(?<=[.!?])\s+(?=[A-Z0-9])")
+PAREN = re.compile(r"\s*\([^()]*\)")
+HEADING = re.compile(r"^\s*=+[^=]+=+\s*$", re.M)
+STOP = set(("what whats who whos whom whose when where which why how is are was were be the a an "
+            "of in on to for does did do by from with as at and or that this it its there tell me "
+            "please can you many much").split())
+ATTR = set(("capital city height tall high elevation population largest biggest smallest longest "
+            "shortest tallest highest deepest first last symbol chemical language languages spoken "
+            "legs year date end ended sink sank invented inventor discovered discovery developed "
+            "wrote written author painted painter president founded born died age old size area "
+            "distance speed").split())
+JUNK = re.compile(r"^(lists? of|outline of|index of|timeline of)\b|\((film|album|song|band|"
+                  r"novel|play|tv series|musical|opera|video game|book|composition|poem)\)|"
+                  r"\bdisambiguation\b", re.I)
+
+def keywords(t: str) -> list:
+    return [w for w in re.findall(r"[^\W_]+", t.lower()) if w not in STOP]
+
+def subject(question: str) -> str:
+    kw = keywords(question)
+    return " ".join(k for k in kw if k not in ATTR) or " ".join(kw)
+
+def clean(t: str) -> str:
+    prev = None
+    while prev != t:
+        prev, t = t, PAREN.sub("", t)
+    return re.sub(r"\s+", " ", t.replace(" ,", ",")).strip()
+
+def _hard(q: str, s: str) -> float:
+    """The answer is of the right KIND: a height with a unit, a year, a number, a name."""
+    b = 0.0
+    if re.search(r"\b(how tall|how high|height|elevation)\b", q):
+        b += 2.0 if re.search(r"\d[\d,.]*\s*(m|metres|meters|ft|feet|km)\b", s) else 0
+    if re.search(r"\b(when|what year|which year|what date)\b", q):
+        b += 2.0 if re.search(r"\b(1\d{3}|20\d{2})\b", s) else 0
+    if re.search(r"\b(how many|how much|population|number of)\b", q):
+        b += 1.5 if re.search(r"\d", s) else 0
+    if re.search(r"\bwho\b", q):
+        b += 1.5 if re.search(r"\b[A-Z][a-z]+ [A-Z][a-z]+", s) else 0
+    if re.search(r"\bsymbol\b", q):
+        b += 2.0 if re.search(r"\bsymbol\b", s, re.I) else 0
+    if re.search(r"\bcapital\b", q):
+        b += 2.0 if re.search(r"\bcapital\b", s, re.I) else 0
+    return b
+
+def _kind(q: str, s: str) -> float:
+    b, sl = _hard(q, s), s.lower()
+    if re.search(r"\b(how tall|how high|height|elevation)\b", q):
+        b += 1.5 if re.search(r"\b(summit|elevation|height|above sea level|highest|stands)\b", sl) else -0.5
+    if re.search(r"\b(end|ended|finish|finished)\b", q):
+        b += 1.5 if re.search(r"\b(ended|end of|surrender|surrendered|concluded|finished)\b", sl) else -0.5
+    if re.search(r"\bpopulation\b", q):
+        b += 2.0 if re.search(r"\d{1,3}(,\d{3})+|\d+(\.\d+)?\s*(million|billion)", s) else -1.0
+    if re.search(r"\b(invent|invented|inventor|discovered|wrote|painted|composed|founded)\b", q):
+        b += 1.0 if re.search(r"\b[A-Z][a-z]+ (?:[A-Z][a-z]+ )?[A-Z][a-z]+\b", s) else 0.0
+    return b
+
+def find(query: str, question: str) -> tuple:
+    """One sentence most likely to hold the answer, and the article it came from."""
+    q = question.lower()
+    subj = subject(question)
+    pool = {}
+    for tq in dict.fromkeys(x for x in (query.strip(), subj, " ".join(keywords(question))) if x):
+        for rank, t in enumerate(search(tq, 3)):
+            tl = t.lower()
+            s = (4.0 if tl in (subj, query.strip().lower()) else 2.0 if subj and tl.startswith(subj) else 0.0)
+            s += -4.0 if JUNK.search(t) else 0.0
+            pool[t] = max(pool.get(t, -1e9), s - 0.3 * rank)
+    qk = list(dict.fromkeys(keywords(question) + keywords(query)))
+    top = sorted(pool.items(), key=lambda x: -x[1])[:3]
+    typed = bool(re.search(r"\b(how tall|how high|height|elevation|when|what year|which year|"
+                           r"how many|how much|population|who|symbol|capital)\b", q))
+    best = (-1e9, "", "")
+    for intro in (True, False):
+        found_kind = False
+        for title, ps in top:
+            raw = _extract(title, intro)
+            if re.search(r"\b(may|can) refer to\b", raw[:400]):
+                continue
+            body = clean(HEADING.sub(" ", raw))
+            sents = [s.strip() for s in SENT.split(body) if 20 < len(s.strip()) < 600]
+            for i, s in enumerate(sents[: 14 if intro else 90]):
+                sc = ps + sum(1.0 for k in qk if k in s.lower()) + _kind(q, s) + (0.5 if i < 3 else 0.0)
+                if sc > best[0]:
+                    best = (sc, s, title)
+                    found_kind = _hard(q, s) > 0
+        if best[1] and (not typed or found_kind):
+            break                       # the intro held an answer of the right kind
+    return best[1], best[2]
+
+# ------------------------------------------------------------------ the loop
+def ask(message: str, tools: bool = True, show: bool = False) -> str:
+    convo = f"<tools:{'on' if tools else 'off'}>\n<user>\n{message.strip()}\n<|eot|>\n<loom>\n"
+    first = loom(convo)
+    m = LOOKUP.search(first)
+    if not m:
+        return first
+    query = m.group(1).strip()
+    try:
+        result, source = find(query, message)
+    except Exception as e:
+        # Never feed an error in as if it were a result — the model will answer from it.
+        return f"[harness] lookup failed for {query!r}: {e}"
+    if not result:
+        return f"[harness] nothing found for {query!r}"
+    if show:
+        print(f"    [searched: {query!r}]\n    [read from {source}: {result[:150]}]")
+    return loom(convo + first + f"<|eot|>\n<result>\n{result}\n<|eot|>\n<loom>\n", n=48)
+
+def main() -> int:
+    global MODEL
+    ap = argparse.ArgumentParser(description="Loom Spark 3 harness")
+    ap.add_argument("message", nargs="*")
+    ap.add_argument("--no-tools", action="store_true", help="chat only, no lookups")
+    ap.add_argument("--show", action="store_true", help="print the query and the sentence read")
+    ap.add_argument("--model", default=MODEL)
+    a = ap.parse_args()
+    MODEL = a.model
+    if a.message:
+        print(ask(" ".join(a.message), not a.no_tools, a.show)); return 0
+    print(f"Loom harness — {MODEL} (tools {'off' if a.no_tools else 'on'}, ctrl-c to quit)\n")
+    while True:
+        try:
+            msg = input("you  > ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print(); return 0
+        if msg:
+            print(f"loom > {ask(msg, not a.no_tools, a.show)}\n")
+
+if __name__ == "__main__":
+    sys.exit(main())

loom-tapestry-3-f16.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e9ceacc4d2198f55ffa1b4dd8a4bb1197fa9f30eea13391a9456a322fd49bc9
+size 139123040

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac14586054b5ac511c24fb518368abbbb367b119af25a7d09d33ae7f722b2376
+size 276988720

params

@@ -0,0 +1,7 @@
+{
+  "stop": ["<|eot|>", "<user>", "<result>"],
+  "temperature": 0.7,
+  "top_k": 40,
+  "repeat_penalty": 1.0,
+  "num_predict": 96
+}

special_tokens_map.json

@@ -0,0 +1 @@
+{"eos_token":"<|eot|>","pad_token":"<|pad|>","additional_special_tokens":["<tools:on>","<tools:off>","<user>","<loom>","<result>","<lookup>","</lookup>"]}

template

@@ -0,0 +1,5 @@
+<tools:off>
+<user>
+{{ .Prompt }}
+<|eot|>
+<loom>

tokenizer_config.json

@@ -0,0 +1 @@
+{"tokenizer_class":"PreTrainedTokenizerFast","model_max_length":1024,"eos_token":"<|eot|>","pad_token":"<|pad|>","additional_special_tokens":["<tools:on>","<tools:off>","<user>","<loom>","<result>","<lookup>","</lookup>"],"clean_up_tokenization_spaces":false}