Duplicate from Cactus-Compute/needle2

Co-authored-by: Henry Ndubuaku <hmunachii@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,88 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+android-arm64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+android-arm64/needle filter=lfs diff=lfs merge=lfs -text
+android-armv7/libneedle.a filter=lfs diff=lfs merge=lfs -text
+android-armv7/needle filter=lfs diff=lfs merge=lfs -text
+android-riscv64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+android-riscv64/needle filter=lfs diff=lfs merge=lfs -text
+ios-arm64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+ios-sim-arm64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+linux-arm64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+linux-arm64/needle filter=lfs diff=lfs merge=lfs -text
+linux-armv7/libneedle.a filter=lfs diff=lfs merge=lfs -text
+linux-armv7/needle filter=lfs diff=lfs merge=lfs -text
+linux-riscv64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+linux-riscv64/needle filter=lfs diff=lfs merge=lfs -text
+linux-x86_64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+linux-x86_64/needle filter=lfs diff=lfs merge=lfs -text
+macos-arm64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+macos-arm64/needle filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.0-py3-none-macosx_11_0_arm64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.0-py3-none-manylinux2014_aarch64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.0-py3-none-manylinux2014_x86_64.whl filter=lfs diff=lfs merge=lfs -text
+tvos-arm64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+watchos-arm64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+windows-arm64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+windows-arm64/needle.exe filter=lfs diff=lfs merge=lfs -text
+windows-x86_64/libneedle.a filter=lfs diff=lfs merge=lfs -text
+windows-x86_64/needle.exe filter=lfs diff=lfs merge=lfs -text
+banner.png filter=lfs diff=lfs merge=lfs -text
+linux-mipsel/libneedle.a filter=lfs diff=lfs merge=lfs -text
+linux-mipsel/needle filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.0-py3-none-macosx_11_0_x86_64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.0-py3-none-musllinux_1_2_aarch64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.0-py3-none-musllinux_1_2_x86_64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.0-py3-none-win_amd64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.0-py3-none-win_arm64.whl filter=lfs diff=lfs merge=lfs -text
+assets/architecture.png filter=lfs diff=lfs merge=lfs -text
+needle2.cact filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.1-py3-none-macosx_11_0_arm64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.1-py3-none-macosx_11_0_x86_64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.1-py3-none-manylinux2014_aarch64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.1-py3-none-manylinux2014_x86_64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.1-py3-none-musllinux_1_2_aarch64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.1-py3-none-musllinux_1_2_x86_64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.1-py3-none-win_amd64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.1-py3-none-win_arm64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.2-py3-none-macosx_11_0_arm64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.2-py3-none-macosx_11_0_x86_64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.2-py3-none-manylinux2014_aarch64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.2-py3-none-manylinux2014_x86_64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.2-py3-none-musllinux_1_2_aarch64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.2-py3-none-musllinux_1_2_x86_64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.2-py3-none-win_amd64.whl filter=lfs diff=lfs merge=lfs -text
+python/cactus_needle-2.0.2-py3-none-win_arm64.whl filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,309 @@
+---
+library_name: cactus-needle
+pipeline_tag: text-generation
+license: apache-2.0
+tags:
+  - tool-calling
+  - function-calling
+  - on-device
+  - edge
+  - quantization
+  - webassembly
+---
+
+![Needle 2](assets/banner.png)
+
+# Needle 2
+
+Needle 2 is an open 45M-parameter model for tool calling, device use and structured extraction. The whole model is a single 14MB binary that runs a full session in 28MB of RAM. It is built on our Simple Attention Network findings, compressed to CQ2-bit with Cactus Quants, and baked into its own engine. On the benchmarks below, Needle 2 trades wins with other small models like FunctionGemma 270M, LFM2.5 230M and Apple FM, at 5x to 70x smaller, and 2 bits against their f16. Needle hits 500 tokens/sec decode speed on a Raspberry Pi 5, between 400-1,500 tokens/sec on VR devices like Meta Quest 3S and Apple Vision Pro, and ranges 300-700 on sub-$200 phones such as the Samsung A-Series. With a peak session RAM around 28MB, Needle reaches microcontrollers like the ESP32-P4; others have reported running it on an ESP32-S3 in about 11MB.
+
+- **Self-contained**: model baked into the binary, no runtime, no downloads, no network.
+- **Runs everywhere**: ARM64, x86-64, ARMv7, RISC-V, and WebAssembly, on Apple, Windows, Linux, Android, Raspberry Pi.
+- **Simple contract**: tool calls come back as structured data, text in, JSON out; a byte-level grammar compiled from your schemas constrains every token.
+- **Confidence-gated**: every response carries a calibrated confidence score from a learned head; set a threshold, act above it, escalate below it.
+- **Tool retrieval**: declare a large catalogue and a built-in retrieval head renders only the top five tools per turn, with the grammar constrained to that subset.
+- **Bounded memory**: a 256-token sliding window with the tools pinned as KV sinks, so total memory stays near 28MB no matter how long the conversation runs.
+
+Source, engine, and training code: [github.com/cactus-compute/needle](https://github.com/cactus-compute/needle).
+
+![Size-quality frontier: mobile-class and below](assets/frontier.png)
+
+## Simple Attention Network
+
+Needle 2 is a Simple Attention Network, our dense small-model recipe: a Hadamard MLP in place of the FFN, GQA attention, engram key-value memory, and multi-lane hyper-connections. See the paper for the design and ablations: [arXiv:2607.18363](https://arxiv.org/abs/2607.18363).
+
+![Simple Attention Network architecture](assets/architecture.png)
+
+Each block carries its update rule. Here x̂ is the RMS-normalised flattening of the four residual streams, H the orthonormal Walsh-Hadamard transform (a fixed matrix, applied in n log n time with no weights to read), (kₜ, vₜ) rows gathered from hashed n-gram tables, and P the doubly-stochastic normalisation of the routing logits A, computed by Sinkhorn iteration; a, b, g and all σ-gates are learned and input-dependent. Both attention and MLP residuals are sandwich-normed and gated, the engram sites fire at two layers, and decoding is constrained by a byte-level grammar compiled from the declared schemas.
+
+## Quickstart with Python
+
+```sh
+pip install cactus-needle
+```
+
+Needle reads your tool descriptions to decide what to call and how to fill arguments, so describing them well is the whole game. You can do it three ways, from least to most control.
+
+**Simple**: decorate a function. The signature gives the argument types, the docstring is the tool description, and `run()` completes the loop: model picks the call, Needle executes your function, feeds the result back, and returns the model's final answer.
+
+```python
+import needle
+
+@needle.tool
+def get_weather(city: str):
+    "Get the current weather for a city."
+    return {"city": city, "temp_c": 27, "sky": "clear"}
+
+agent = needle.Needle(tools=[get_weather])
+print(agent.run("what's it like in Lagos right now?")["reasoning"])
+```
+
+**Medium**: describe each argument and offer choices. Needle reads a Google-style `Args:` block for per-parameter descriptions; a default makes an argument optional; a `Literal` becomes a fixed set the model must choose from (it cannot emit anything else).
+
+```python
+from typing import Literal
+
+@needle.tool
+def set_thermostat(temperature: int, mode: Literal["heat", "cool", "auto"] = "auto"):
+    """Set the thermostat.
+
+    Args:
+        temperature: target temperature in Celsius
+        mode: heating strategy to use
+    """
+    return {"temperature": temperature, "mode": mode}
+
+agent = needle.Needle(tools=[set_thermostat])
+agent.run("make it 21 and cool the room")
+```
+
+**Advanced**: constrain the values with `needle.Field`, attached inline via `Annotated`. Ranges, patterns, lengths, and item counts are compiled into the decode grammar, so the model can only ever emit values that satisfy them.
+
+```python
+from typing import Annotated
+
+@needle.tool
+def send_money(
+    amount: Annotated[float, needle.Field(gt=0, le=10000, description="USD, up to 10,000")],
+    to:     Annotated[str,   needle.Field(pattern=r"^@[a-z0-9_]+$", description="recipient handle")],
+    memo:   Annotated[str,   needle.Field(max_length=80)] = "",
+):
+    "Send money to a handle."
+    return {"sent": amount, "to": to}
+```
+
+`Field` supports `description`, `enum`, `const`, `ge`/`le`/`gt`/`lt`, `multiple_of`, `min_length`/`max_length`, `pattern`, `format`, `min_items`/`max_items`, and `unique_items`.
+
+**Extraction**: to pull structured data out of text, declare the shape and call `extract()`. Pass a Pydantic model and you get a typed object back.
+
+```python
+from pydantic import BaseModel
+
+class Invoice(BaseModel):
+    vendor: str
+    total: float
+    due_date: str
+
+invoice = needle.extract("Invoice from Acme Corp, $1,200.00, due 2026-09-01", Invoice)
+print(invoice.vendor, invoice.total)   # -> Acme Corp 1200.0
+```
+
+**By hand** - the decorator just builds a JSON schema; you can pass that schema directly, which is exactly what Needle consumes. This is how you set descriptions and constraints without the decorator (and `tools.json` for the CLI is the same shape):
+
+```python
+tools = [{
+    "name": "set_lights",
+    "description": "Turn a room's lights on or off and set brightness",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "room": {"type": "string", "description": "which room to control"},
+            "on": {"type": "boolean"},
+            "brightness": {"type": "integer", "minimum": 0, "maximum": 100},
+        },
+        "required": ["room", "on"],
+    },
+}]
+agent = needle.Needle(tools=tools)
+```
+
+Prefer to drive the loop yourself instead of `run()`? `complete()` returns the raw call and you execute it:
+
+```python
+import json
+response = agent.complete("dim the living room to 30")
+if response["type"] == "call":
+    result = set_lights(**response["function_calls"][0]["arguments"])
+    response = agent.complete(json.dumps(result))   # feed the result back
+```
+
+With a large catalogue, persist tool embeddings across runs with `needle.Needle(tools=..., tool_index_path="tools.idx")`. Every turn returns one JSON object:
+
+```json
+{
+  "type": "call",
+  "success": true,
+  "error": null,
+  "error_code": null,
+  "function_calls": [ { "name": "set_lights", "arguments": { "room": "living room", "on": true, "brightness": 30 } } ],
+  "reasoning": "'living room' -> room; 'dim' -> on true, brightness 30",
+  "confidence": 0.94,
+  "prefill_tps": 4300.0,
+  "decode_tps": 850.0,
+  "peak_ram_mb": 28.0
+}
+```
+
+## Behaviour
+
+Needle solves every problem as a function call. The context declares what may be called; the model answers with calls. Performing an action and extracting structured data are the same operation, the only difference is what you declare.
+
+- A request no declared tool can serve is refused with the empty call `[]`. That is the whole contract for off-topic input; there is no free-text fallback.
+- Arguments contain only values evidenced by the input. An optional field with no evidence is omitted, not guessed; omission is the field-level `[]`.
+- `reasoning` is the model's short derivation of each argument from its source span (`'ten minutes' -> minutes 10`). It is generated unconstrained; only the call itself is grammar-constrained, so the JSON cannot be malformed while the derivation stays legible.
+- After you execute a call, pass the result back as the next `complete()`. The model continues from it, and later arguments may depend on earlier results: `search_for_contact` first, then `send_instant_message` with the returned `contact_id`. A final step may answer in plain text from the results: `"type": "respond"` with empty `function_calls`.
+- A session shares one toolset. Later turns are bare queries against the same tools; `reset()` rewinds the conversation and keeps the tools loaded.
+
+## System facts
+
+An optional system turn carries environment state as facts, never instructions:
+
+```
+date: 2026-07-21 Tue 14:30; locale: en-US; device: phone; battery: 62%
+```
+
+Recognized keys are `date`, `locale`, `device`, `battery`, `network`, `location`, `user`, and `assistant`. The model resolves relative language against them: "tomorrow at 7" becomes an absolute time only when a `date:` fact licenses it, otherwise the human phrase passes through verbatim. `assistant:` declares the identity the model binds to. Pass the turn with `--system system.txt` on the CLI or `needle.Needle(tools=tools, system="date: ...")` in Python. Needle trains with and without the turn, so omitting it is safe; instructions placed there do not steer the model.
+
+## Deploy Needle
+
+Download the folder for your platform from the release:
+
+| your device | folder | command-line | library |
+| --- | --- | --- | --- |
+| Mac (Apple Silicon) | `macos-arm64` | `needle` | `libneedle.a` |
+| Linux x86-64 (PC, server, AMD) | `linux-x86_64` | `needle` | `libneedle.a` |
+| Linux ARM64 (Raspberry Pi, server) | `linux-arm64` | `needle` | `libneedle.a` |
+| Linux ARMv7 (32-bit) | `linux-armv7` | `needle` | `libneedle.a` |
+| Linux RISC-V | `linux-riscv64` | `needle` | `libneedle.a` |
+| Linux MIPS32el (Ingenic cameras, routers) | `linux-mipsel` | `needle` | `libneedle.a` |
+| Windows x64 | `windows-x86_64` | `needle.exe` | `libneedle.a` |
+| Windows ARM | `windows-arm64` | `needle.exe` | `libneedle.a` |
+| Android | `android-arm64` / `android-armv7` / `android-riscv64` | `needle` | `libneedle.a` |
+| iOS / watchOS / tvOS | `ios-arm64` / `watchos-arm64` / `tvos-arm64` | - | `libneedle.a` |
+| Browser / Node (WebAssembly) | `wasm` | - | `needle.js` + `needle.wasm` |
+
+To run it, use the command-line binary. On macOS, Linux, or Android:
+
+```sh
+# answer one query and exit
+./needle --tools tools.json --prompt "dim the living room to 30"
+
+# or an HTTP server on localhost:8080 (POST /complete {"input": "..."})
+./needle --tools tools.json --serve
+
+# with a large tool catalogue, persist tool embeddings across runs
+./needle --tools tools.json --tool-index tools.idx --serve
+```
+
+`tools.json` is a JSON array of the functions the assistant may call:
+
+```json
+[
+  {
+    "name": "set_lights",
+    "description": "Turn a room's lights on or off and set brightness",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "room": { "type": "string" },
+        "on": { "type": "boolean" },
+        "brightness": { "type": "integer", "description": "0 to 100" }
+      },
+      "required": ["room", "on"]
+    }
+  },
+  {
+    "name": "play_music",
+    "description": "Play music matching a mood, genre, or artist",
+    "parameters": {
+      "type": "object",
+      "properties": { "query": { "type": "string" } },
+      "required": ["query"]
+    }
+  },
+  {
+    "name": "send_message",
+    "description": "Text a contact",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "to": { "type": "string" },
+        "body": { "type": "string" }
+      },
+      "required": ["to", "body"]
+    }
+  }
+]
+```
+
+## Tool retrieval
+
+Five or fewer declared tools render directly. Above that, retrieval engages: at init every tool schema is embedded once by a built-in contrastive head, each turn embeds the query, and only the five highest-scoring tools enter the context, with the grammar rebuilt over just that subset. An unselected tool is unreachable, not merely unlikely. `--tool-index <path>` (CLI) or `tool_index_path` (Python) persists the embeddings on disk, keyed by a fingerprint over the schemas and the model; a matching fingerprint loads instantly, a changed schema re-embeds only what changed.
+
+## Confidence
+
+The `confidence` field is the minimum of two signals: a calibrated post-hoc head that scores the full prompt plus the call the model just produced, and the decoding probability of the call tokens. A call is accepted only when both agree, so the failure mode is escalation, not wrong execution. The contract: pick a threshold for your product, act at or above it, re-ask or route to a bigger model below it. Off-topic requests return the empty call `[]`.
+
+## Fine-tuning
+
+Needle is open and trainable end to end. Fine-tune it on your own tools and domains, then export to a `.cact` and ship it like the base model. See the [needle repo](https://github.com/cactus-compute/needle) for training and export.
+
+## Extraction
+
+Extraction is the same exchange as tool calling: declare the record schema as the only tool and pass the content as the prompt; the passage sits where the query sits, and the returned call's `arguments` are the extracted fields. With one declared tool the grammar admits exactly one call of that name, the `tool_choice` equivalent, so schema conformance is guaranteed rather than requested. There is no separate JSON mode.
+
+`schema.json` describes the record to extract:
+
+```json
+[
+  {
+    "name": "receipt",
+    "description": "A purchase receipt shared as text",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "merchant": { "type": "string" },
+        "total": { "type": "number" },
+        "currency": { "type": "string" },
+        "line_items": { "type": "array", "items": { "type": "object" } }
+      },
+      "required": ["merchant", "total"]
+    }
+  }
+]
+```
+
+```sh
+./needle --tools schema.json --prompt "GreenMart receipt: oat milk 3.50, total 7.75 paid by visa"
+```
+
+```json
+{ "type": "call", "function_calls": [ { "name": "receipt", "arguments": { "merchant": "GreenMart", "total": 7.75 } } ] }
+```
+
+## Citation
+
+Needle 2 is built by the Cactus Compute team. If you use it in your work, please cite:
+
+```bibtex
+@misc{needle2_2026,
+  title        = {Needle 2: A 45M-Parameter Foundation Tool-Calling Model for Tiny Devices},
+  author       = {Ndubuaku, Henry and Mosoyan, Karen and Mroz, Jakub and Cylich, Noah and
+                  Kumar, Satyajit and Sandhu, Parkirat and Shemet, Roman and Lee, Justin H.},
+  year         = {2026},
+  organization = {Cactus Compute, Inc.},
+  howpublished = {\url{https://github.com/cactus-compute/needle}}
+}
+```
+
+Reach out on founders@cactuscompute.com for partnerships, collaborations, synergies and deploying Needle2 in your product.

android-arm64/libneedle.a

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

android-arm64/needle

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

android-arm64/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

android-armv7/libneedle.a

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

android-armv7/needle

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

android-armv7/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

android-riscv64/libneedle.a

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

android-riscv64/needle

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

android-riscv64/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

checkpoints/needle2.pkl

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

config.json

@@ -0,0 +1,38 @@
+{
+  "model_type": "needle",
+  "architectures": ["NeedleForToolCalling"],
+  "name_or_path": "Cactus-Compute/needle2",
+  "vocab_size": 8192,
+  "hidden_size": 512,
+  "num_hidden_layers": 27,
+  "num_attention_heads": 8,
+  "num_key_value_heads": 4,
+  "head_dim": 64,
+  "max_position_embeddings": 2048,
+  "rope_theta": 100000.0,
+  "tie_word_embeddings": true,
+  "torch_dtype": "float16",
+  "total_parameters": 44900000,
+  "sliding_window": 256,
+  "attention": "gqa",
+  "mlp": "hadamard",
+  "extras": {
+    "engram": {"sites": [2, 15], "orders": [2, 3], "slots": 8192, "sub_dim": 128, "conv_taps": 4, "conv_dilation": 3},
+    "mhc_lanes": 4,
+    "heads": ["contrastive_retrieval", "confidence"]
+  },
+  "quantization": {
+    "method": "cactus-quants",
+    "scheme": "embedding=4,mhc=4,default=2",
+    "effective_bits": 2.2,
+    "group_size": 128,
+    "kv_cache_bits": 8,
+    "activation_bits": 8
+  },
+  "deployment": {
+    "format": "cact",
+    "binary_size_mb": 14,
+    "session_ram_mb": 28,
+    "runtime": "self-contained C++ / WebAssembly, no dependencies"
+  }
+}

ios-arm64/libneedle.a

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

ios-arm64/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

ios-sim-arm64/libneedle.a

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

ios-sim-arm64/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

linux-arm64/libneedle.a

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

linux-arm64/needle

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

linux-arm64/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

linux-armv7/libneedle.a

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

linux-armv7/needle

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

linux-armv7/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

linux-mipsel/libneedle.a

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

linux-mipsel/needle

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

linux-mipsel/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

linux-riscv64/libneedle.a

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

linux-riscv64/needle

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

linux-riscv64/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

linux-x86_64/libneedle.a

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

linux-x86_64/needle

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

linux-x86_64/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

macos-arm64/libneedle.a

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

macos-arm64/needle

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

macos-arm64/needle.h

@@ -0,0 +1,35 @@
+#ifndef NEEDLE_H
+#define NEEDLE_H
+
+#ifndef NEEDLE_API
+#define NEEDLE_API __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NEEDLE_API int needle_init(
+    const char* system_prompt,
+    const char* tools_json,
+    const char* tool_index_path
+);
+
+NEEDLE_API int needle_complete(
+    const char* input,
+    int max_new_tokens,
+    char* out,
+    int out_capacity
+);
+
+NEEDLE_API void needle_reset(void);
+
+NEEDLE_API int needle_load(
+    const unsigned char* cact,
+    unsigned long long n
+);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

needle2.cact

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

python/cactus_needle-2.0.0-py3-none-macosx_11_0_arm64.whl

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

python/cactus_needle-2.0.0-py3-none-macosx_11_0_x86_64.whl

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

python/cactus_needle-2.0.0-py3-none-manylinux2014_aarch64.whl

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

python/cactus_needle-2.0.0-py3-none-manylinux2014_x86_64.whl

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

python/cactus_needle-2.0.0-py3-none-musllinux_1_2_aarch64.whl

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

python/cactus_needle-2.0.0-py3-none-musllinux_1_2_x86_64.whl

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

python/cactus_needle-2.0.0-py3-none-win_amd64.whl

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