Instructions to use OpenCOReTechnologies/CORe-Pico-4 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use OpenCOReTechnologies/CORe-Pico-4 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="OpenCOReTechnologies/CORe-Pico-4")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("OpenCOReTechnologies/CORe-Pico-4")
model = AutoModelForCausalLM.from_pretrained("OpenCOReTechnologies/CORe-Pico-4", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use OpenCOReTechnologies/CORe-Pico-4 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "OpenCOReTechnologies/CORe-Pico-4"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "OpenCOReTechnologies/CORe-Pico-4",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/OpenCOReTechnologies/CORe-Pico-4

SGLang

How to use OpenCOReTechnologies/CORe-Pico-4 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "OpenCOReTechnologies/CORe-Pico-4" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "OpenCOReTechnologies/CORe-Pico-4",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "OpenCOReTechnologies/CORe-Pico-4" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "OpenCOReTechnologies/CORe-Pico-4",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use OpenCOReTechnologies/CORe-Pico-4 with Docker Model Runner:
```
docker model run hf.co/OpenCOReTechnologies/CORe-Pico-4
```

Congrats on Pico 4! Ready to sync on Pico 5 KV-cache and reasoning persistence

by AndrewThompson1233 - opened 1 day ago

Discussion

AndrewThompson1233

1 day ago

Hi Kraxis and CORe team,

Huge congrats on dropping Pico 4 right on schedule! Clean packaging with the native chat template and dedicated GGUF exports.

Saw the honest notes in the model card regarding memory scaling past 8k context and reasoning degradation over extended multi-turn conversations:
KV cache scaling past 8k: As noted on V3, reading a multi-gigabyte GQA cache across 28 layers on laptop memory bandwidth inevitably throttles generation speed.
Multi-turn reasoning degradation: Pure attention backbones often suffer from attention dilution over long contexts, where early system instructions and intermediate reasoning steps get washed out by intervening tokens.

As you begin architectural planning for Pico 5:
Hybrid recurrence (75% GDN-2 / 25% GQA) directly tackles both items: it keeps 75% of your layer memory at fixed O(1) state size, slashing the KV footprint to allow smooth 16k-40k generation on consumer laptops.
Additionally, GDN-2's associative state matrix acts as a persistent memory anchor, preventing the reasoning drift you observed across long multi-turn sessions.
Decoupling the 151k vocab via low-rank projection will free up ~210M parameters to invest in wider or deeper reasoning layers for Pico 5.

Whenever you are ready to explore the GDN-2 layer specs, kernel configurations, or benchmark numbers from Maba (https://huggingface.co/AndrewThompson1233/maba-v1-architecture), let's sync up!

Best of luck with the Pico 4 rollout!

Best,
Andrew

COReTechnologies

Computational Open Reasoning Technologies org about 21 hours ago

Hi Andrew,

Thanks so much for the kind words on the Pico 4 rollout and for diving into the model card details!

We really appreciate you sharing the insights on hybrid recurrence (GDN-2 / GQA) and low-rank vocab projection for Pico 5. As of now, we've already planned our path forward under our current architecture, and we'd prefer to stay within our own zone as we continue to learn and iterate on our current setup.

That said, we will definitely take a look at what you've put together. If it's something we believe we can make the switch to without disrupting our ongoing work, we'd be more than happy to sync up and talk about it further then.

In the meantime, if you are hitting this, you can quantize the KV cache alone with Pico 4 by using llama.cpp (or llama-server) using the following:

--cache-type-k q8_0 (or -ctk q8_0)
and
--cache-type-v q8_0 (or -ctv q8_0)
(if you do this make sure you do both together, and have Flash Attention on -fa/--flash-attn on)

You can also use other quants with this method, the above just uses q8_0.

Thanks again for following our work and for the great suggestions!

Best,
The CORe Team

AndrewThompson1233

about 21 hours ago

Hi CORe team,

Completely understand and respect that! Iterating steadily on an established stack and mastering its dynamics before pivoting architectures is always the right engineering call.

And thanks for highlighting the -ctk q8_0 / -ctv q8_0 path in llama.cpp - paired with Flash Attention, KV quantization is definitely the cleanest pragmatic fix for edge deployments right now.

Wishing you smooth training runs on the next milestones. The door is always open whenever you want to compare notes down the line!

Best,
Andrew

Upload images, audio, and videos by dragging in the text input, pasting, or clicking here.

Tap or paste here to upload images

· Sign up or log in to comment