Running Local RAG with Embeddings in Ollama: Chunking, Dimensions, and the Failure Modes Nobody Warns You About

You do not need a vector database or extra VRAM to give your local LLM semantic search over its own documents. You need the right chunk sizes, the right embedding tag, and an index that fails loudly instead of silently cross-model-searching.

Ollama’s Keep-Alive and Predictable Model Loading: Deciding When Your Local Model Stays in VRAM

Ollama can unload your model five minutes after it stops doing anything, and your next request pays the reload. How long to keep it resident depends on more than intuition: eviction priority is literally your keep-alive number.

Ollama vs llama-server: Which Runtime Should You Actually Run Your Local Models Through?

Same engine, two different operating models. Ollama defaults to registry pulls and a VRAM-tiered context guess; llama-server asks you to set the window yourself and exposes layer split, KV-cache dtype, metrics, and API keys. A decision guide for both.

The Hidden Cost of Context Length: Why Your Local Model Runs Out of Memory Before It Reads a Single Token

Raising context windows does not fit the same memory it used to. The KV cache is allocated in full before your first token, its size is computable from the model's config file, and hybrid-attention models change the number quietly.

Ollama's OpenAI-Compatible Endpoint: What Your Agent Framework Actually Gets

Agent frameworks mostly assume OpenAI chat completions. What that contract looks like on a local machine: which /v1 routes Ollama v1 serves, which request fields are honored vs quietly dropped, context control by model aliasing, and where direct llama.cpp starts to pay.

What Is llama.cpp? The Inference Engine Under Your Local Models, and When to Drive It Directly

GGUF came from llama.cpp, yet most of us meet it through a wrapper. What the engine actually exposes — server endpoints, slots, KV-cache math you can compute yourself, and the security defaults worth reading before exposing an endpoint.

How Much Hardware Do You Need for Local AI Agents? A Practical VRAM, RAM, and CPU Guide

A practical sizing guide for running sustained local AI agent workloads: what 8 to 48 GB+ of VRAM really buys you, plus the system RAM and CPU decisions that come with each tier.

Cloud AI vs Local AI Agents: Choosing the Right Role

Cloud AI and local AI agents are not direct replacements for each other. Here is how I divide tasks between them and why a hybrid approach works better.

Why AI Agents Need Human Control: Lessons from Automation Failures

Building AI agents revealed an important lesson: automation alone is not enough. Learn why reliable AI systems need human control and clear boundaries.

Running Local AI Agents on a 24GB VRAM Machine: What I Learned

A practical look at running local AI agents on a 24GB VRAM machine. Learn about hardware limits, model selection, and what actually matters in daily use.

How I Connected OpenClaw with Slack to Build a Remote AI Assistant

A practical look at connecting OpenClaw with Slack to create a remote AI assistant. Learn why I chose Slack, how the workflow works, and what I learned.

Building My Own AI Agent Environment: Lessons Learned from OpenClaw and Hermes

A real-world journey building a personal AI agent environment with OpenClaw, Hermes, and local AI models. Learn what worked, what failed, and what I discovered.

Local AI

Ornith-1.5 for Local AI: What a New MoE Family Means When Your GPU Fits One Model but Not Two

The new Ornith-1.5 open-weight family (35B-A3B MoE, 9B, MIT) fits inside one consumer GPU. What you should actually run on a 24 GB card, why its hybrid attention makes long context unusually cheap from the math, and when it replaces what you already host.

24GB Lab

RunPod vs Vast.ai for Local AI: What to Do When Your 24 GB GPU Is Not Enough

A practical comparison of RunPod and Vast.ai for local AI users who occasionally need more VRAM than a 24 GB GPU can provide — with the stay-local vs rent vs buy decision worked out in order.

AI Agents

Running Claude Code on a Local Model: How Ollama's New Compatibility Endpoint Works

Claude Code can run against a model on your own machine, no paid key involved. Current Ollama does it with ollama launch claude — what the endpoint actually covers, which models to try first, and why the context window is the setting that matters.

Local AI

Muse Glimmer on Your GPU: What the Official Tags and File Sizes Actually Require

Meta Superintelligence Labs' new open model for local deployment lands with a real footprint. We map Muse Glimmer 30B's official quantization ladder against your card tier and Ollama tags, using exact file sizes.

Frontier AI

Qwen3.8-Max Weights Are Public on Hugging Face — But They Won’t Fit a Typical Local PC

Qwen3.8-Max-class weights are now downloadable from Qwen on Hugging Face. Here's how large the A95B checkpoint really is, what the smallest GGUF costs, and why it is far beyond a typical local PC.

Local AI

Qwen3.8-27B Vision: What Images and Video Actually Cost When You Run It Locally

Images work out of the box in Ollama. Verified against the model's shipped configs: what each image costs in tokens, what the projector adds on GGUFs, and exactly where my verification stops at video.

24GB Lab

Qwen3.8-27B Quantization: Which File Actually Fits Your GPU

Exact Hugging Face file sizes for every Qwen3.8-27B GGUF, a blunt per-card recommendation (UD-Q4_K_M at ~24GB), when NVFP4 changes the maths on Blackwell, and two-minute checklist built from hard numbers.

24GB Lab

Qwen3.8-27B on a 24 GB Card With Ollama: The Defaults You Inherit and the Settings That Actually Matter

Why different context surfaces can show 262K and 131K at the same time, which Ollama defaults qwen38-27b hands you after a pull, what thinking-on-by-default costs in real use, plus a day-one checklist from one measured RTX 5090 Laptop GPU session.

24GB Lab

Qwen 3.8 27B on a 24 GB Laptop GPU: Field Report From Actual Use

What Qwen 3.8 27B at 4-bit actually costs in VRAM and time on an RTX 5090 Laptop GPU, based only on retained client-side measurements.

Local AI

Should You Switch to Qwen3.8-27B? An Upgrade Decision Guide for Existing Local LLM Users

A decision guide for people already running a local LLM: what the vendor-published model card says about Qwen3.8-27B versus Qwen3.6-27B, where the reported differences actually matter agentically and multimodally, and how to fit it on your hardware.