Instructions to use OpenCOReTechnologies/CORe-Pico-V3 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use OpenCOReTechnologies/CORe-Pico-V3 with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-generation", model="OpenCOReTechnologies/CORe-Pico-V3") messages = [ {"role": "user", "content": "Who are you?"}, ] pipe(messages)# Load model directly from transformers import AutoTokenizer, AutoModelForCausalLM tokenizer = AutoTokenizer.from_pretrained("OpenCOReTechnologies/CORe-Pico-V3") model = AutoModelForCausalLM.from_pretrained("OpenCOReTechnologies/CORe-Pico-V3", 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
- llama.cpp
How to use OpenCOReTechnologies/CORe-Pico-V3 with llama.cpp:
Install (macOS, Linux)
curl -LsSf https://llama.app/install.sh | sh # Start a local OpenAI-compatible server with a web UI: llama serve -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M # Run inference directly in the terminal: llama cli -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
Install from WinGet (Windows)
winget install llama.cpp # Start a local OpenAI-compatible server with a web UI: llama serve -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M # Run inference directly in the terminal: llama cli -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
Use pre-built binary
# Download pre-built binary from: # https://github.com/ggerganov/llama.cpp/releases # Start a local OpenAI-compatible server with a web UI: ./llama-server -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M # Run inference directly in the terminal: ./llama-cli -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
Build from source code
git clone https://github.com/ggerganov/llama.cpp.git cd llama.cpp cmake -B build cmake --build build -j --target llama-server llama-cli # Start a local OpenAI-compatible server with a web UI: ./build/bin/llama-server -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M # Run inference directly in the terminal: ./build/bin/llama-cli -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
Use Docker
docker model run hf.co/OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
- LM Studio
- Jan
- vLLM
How to use OpenCOReTechnologies/CORe-Pico-V3 with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "OpenCOReTechnologies/CORe-Pico-V3" # 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-V3", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker
docker model run hf.co/OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
- SGLang
How to use OpenCOReTechnologies/CORe-Pico-V3 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-V3" \ --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-V3", "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-V3" \ --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-V3", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }' - Ollama
How to use OpenCOReTechnologies/CORe-Pico-V3 with Ollama:
ollama run hf.co/OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
- Unsloth Desktop
- Pi
How to use OpenCOReTechnologies/CORe-Pico-V3 with Pi:
Start the llama.cpp server
# Install llama.cpp: brew install llama.cpp # Start a local OpenAI-compatible server: llama serve -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
Configure the model in Pi
# Install Pi: npm install -g @earendil-works/pi-coding-agent # Add to ~/.pi/agent/models.json: { "providers": { "llama-cpp": { "baseUrl": "http://localhost:8080/v1", "api": "openai-completions", "apiKey": "none", "models": [ { "id": "OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M" } ] } } }Run Pi
# Start Pi in your project directory: pi
- Docker Model Runner
How to use OpenCOReTechnologies/CORe-Pico-V3 with Docker Model Runner:
docker model run hf.co/OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
- Lemonade
How to use OpenCOReTechnologies/CORe-Pico-V3 with Lemonade:
Pull the model
# Download Lemonade from https://lemonade-server.ai/ lemonade pull OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
Run and chat with the model
lemonade run user.CORe-Pico-V3-Q4_K_M
List all available models
lemonade list
- Hermes Agent
How to use OpenCOReTechnologies/CORe-Pico-V3 with Hermes Agent:
Start the llama.cpp server
# Install llama.cpp: brew install llama.cpp # Start a local OpenAI-compatible server: llama serve -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
Configure Hermes
# Install Hermes: curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash hermes setup # Point Hermes at the local server: hermes config set model.provider custom hermes config set model.base_url http://127.0.0.1:8080/v1 hermes config set model.default OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
Run Hermes
hermes
- Atomic Chat
- OpenClaw
How to use OpenCOReTechnologies/CORe-Pico-V3 with OpenClaw:
Start the llama.cpp server
# Install llama.cpp: brew install llama.cpp # Start a local OpenAI-compatible server: llama serve -hf OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M
Configure OpenClaw
# Install OpenClaw: npm install -g openclaw@latest # Register the local server and set it as the default model: openclaw onboard --non-interactive --mode local \ --auth-choice custom-api-key \ --custom-base-url http://127.0.0.1:8080/v1 \ --custom-model-id "OpenCOReTechnologies/CORe-Pico-V3:Q4_K_M" \ --custom-provider-id llama-cpp \ --custom-compatibility openai \ --custom-text-input \ --accept-risk \ --skip-health
Run OpenClaw
openclaw agent --local --agent main --message "Hello from Hugging Face"
KV cache memory footprint at 40k context and vocabulary allocation on 1.7B
Hi team,
Targeting extended reasoning (/think) and tool calling in a 1.7B edge footprint is a great direction, especially with native 40k context support.
Looking at the memory and compute dynamics on local laptop deployments:
The KV cache memory wall at 40k context:
Your q4_k_m GGUF weighs ~1.1 GB. Assuming standard GQA (2 KV heads, head dimension 128), storing the KV cache across 28 layers at 40,960 tokens in fp16 requires:
28 * 2 * 2 * 128 * 40,960 * 2 bytes ≈ 1.17 GB.
At full context or during long /think reasoning traces, the dynamic KV cache exceeds the size of the quantized model weights. On laptop CPUs/iGPUs, decoding throughput stalls heavily once memory bandwidth is dominated by reading this cache every step.Vocabulary parameter tax:
With a 151,936 tokenizer at 1,536 hidden width, a single embedding table consumes ~233.4M parameters (13.5% of the 1.72B budget if tied, or ~27% if untied).
In an open architecture project called Maba (101M reference model: https://huggingface.co/AndrewThompson1233/maba-v1-architecture), we handle this compute regime using two complementary mechanisms:
Low-rank factorized embeddings: Projecting 151,936 -> 128 -> 1,536 drops the lookup table from 233.4M to 19.6M parameters, freeing over 210M parameters to allocate into deeper layer transformations.
Hybrid recurrence (75% GDN-2 / 25% GQA): Linear recurrent layers maintain fixed O(1) state memory. At 40k context, this slashes total KV cache size by ~75% (from 1.17 GB down to ~300 MB), preventing token generation from slowing down during lengthy reasoning traces.
How does generation speed hold up on edge devices when /think traces push context beyond 8k tokens?
Best,
Andrew
Hello Andrew,
While we noted reasoning capability in the model card, full end-to-end reasoning is currently separated until our release of Pico 4 later this week, which natively integrates reasoning capabilities.
Regarding performance at extended context: in our CPU-only benchmarks at FP16, we did observe a reduction in generation speed as context length scales up. Unsurprisingly, the impact is most noticeable during the prefill phase, though decoding throughput is also affected as the KV cache grows.
We appreciate the breakdown of Maba's approach to factorized embeddings and hybrid recurrence. Slashing the KV footprint by ~75% while keeping O(1) state memory is a super compelling approach for edge deployment. We're already deep into the training run for Pico 4, so our architecture is locked in for this release, but we're keeping these exact memory-wall dynamics in mind as we start planning Pico 5 and beyond.
Best,
Kraxis
Hi Kraxis,
Thanks for confirming the CPU benchmark telemetry. Prefill stalls and memory bandwidth pressure on growing KV caches are practically unavoidable on standard GQA once context scales out.
Excited to see the Pico 4 release later this week.
When you start drafting the architectural specs for Pico 5, feel free to ping me or open a thread on the Maba repo (https://huggingface.co/AndrewThompson1233/maba-v1-architecture). Happy to share profiling data and kernel setups for the GDN-2 recurrent blocks on edge hardware.
Best of luck with the Pico 4 launch!
Best,
Andrew