Frequently asked questions

LLM apps pay to recompute answers they already produced. The same question arrives phrased a hundred ways, and every phrasing becomes a fresh model bill. Crowkis recognizes when a new question means the same thing as an old one and serves the stored answer, when it's safe to.

In most production LLM workloads, a large share of queries are paraphrases or repeats of earlier ones, support bots, internal copilots, and doc assistants are the worst offenders. Every one of those is full-price compute for an answer you already own.

Redis matches exact bytes. 'How do refunds work?' and 'What's your refund window?' are different strings, so Redis treats them as different questions and you pay twice. Crowkis matches meaning and structure, not bytes.

Vector similarity alone over-serves. 'Cancel my subscription' and 'pause my subscription' embed close together, but serving one as the other is a customer-facing mistake. Crowkis adds structural template checks, intent classification, and confidence gates on top of vector search.

One bad entry, a hallucination, a prompt injection, a cross-tenant leak, gets served to every nearby query in a semantic cache. Poison radiates. Crowkis scores every write through a five-stage trust pipeline before it's ever served.

Both. A cache hit returns in well under a millisecond from a local Rust engine, versus seconds for a model round-trip. Users see snappier answers; you see a smaller invoice.

A Redis-compatible cache, written in Rust, that understands what your LLM is being asked and only reuses an answer when it can justify that reuse.

Anyone paying an LLM bill on repetitive traffic: support and FAQ bots, internal copilots, RAG apps, agent fleets, and AI coding tools. Community edition is free, so 'for' includes solo developers.

Five things: the intent class matches, the structural template agrees, a semantic neighbour exists in the HNSW index, the composite confidence score clears that intent's threshold, and the entry passes trust and freshness checks. Any one of them can veto.

Every query is classified into one of 12 intents, factual, creative, personal, transactional, and so on. Factual questions tolerate aggressive reuse; creative and personal ones get strict thresholds. A poem request never serves a cached poem meant for someone else.

Numbers, dates, and entities are lifted out of the query into slots, so 'invoice #4412 status' and 'invoice #9981 status' share one template. It catches paraphrases vectors miss and blocks false matches vectors invent.

Five signals, semantic similarity, freshness, source trust, hit history, and intent threshold, combine into a geometric mean. Factual content needs 0.88 to serve. Below threshold, the query goes to the model, full stop.

Five weighted stages: coherence between question and answer (0.30), content heuristics (0.10), the writer's trust ledger history (0.30), tenant isolation consistency (0.15), and agreement with semantic neighbours (0.15). The composite must clear 0.75 or the write is refused and logged.

Crowkis extracts the step structure from chain-of-thought answers, abstracts the specifics into slots, and recomposes the skeleton for new inputs that share the pattern. It saves on the expensive part, the reasoning, not just the final words.

Reuse thresholds tune themselves per intent class from live hit/miss feedback, within bounded ranges. Where mistakes hurt, the bar drifts up; where reuse is safe, it relaxes. You can pin any threshold by hand.

Exactly what happened before Crowkis existed: your request goes to the provider. Crowkis then offers the response to the write pipeline, and if it passes trust checks, the next paraphrase is a hit. Worst case, Crowkis behaves like a pass-through.

RESP3 (the Redis wire protocol, redis-py, ioredis, and Lettuce connect unmodified), gRPC over h2c for protobuf shops, a REST management API, and MCP for AI apps and agents. Same cache behind all four.

A purpose-built Rust LSM tree: write-ahead log with CRC-checked records, 64 MB memtable, LZ4-compressed SSTables with bloom filters, three-level compaction, and an HNSW vector index that persists alongside. No RocksDB, no garbage collector in the read path.

Yes, CGETSTREAM and the SDKs' stream_get_or_compute serve cached answers chunk by chunk, so a hit feels like live model output to your UI.

Yes. Multimodal entries combine image and text signals, served through CIMGGET and the SDK helpers.

A live verdict feed, every hit, miss, and block with its confidence score, plus hit-type breakdowns, cost saved per tenant and per model, top queries, top misses, safety blocks by stage, memory pressure, and license state.

Yes. Prometheus exposition on /metrics and OpenTelemetry support mean it lights up in Grafana or Datadog without an adapter.

When you upgrade models, Crowkis treats it as a workflow: canary the new model on a slice of traffic, compare quality, then migrate cache entries with leasing. Your warm cache survives the upgrade instead of cold-starting.

Crowkis can register multiple LLM backends and route around unhealthy ones. If your primary provider has an incident, traffic degrades to a fallback instead of failing.

Python (sync + async) and Node/TypeScript, both with get_or_compute, explicit semantic commands, and streaming. Plus the built-in crowkis cli REPL and the MCP server for AI-native tools.

The one-liner pattern: give Crowkis the query and a function that calls your model. If a safe cached answer exists, your function never runs. If not, it runs once and the result is banked. Cache logic disappears from your codebase.

Yes, that's the MCP integration. Claude Code and other MCP-capable apps register 'crowkis mcp' as a server and check the cache before spending tokens. Repeated lookups become free.

Yes, the Python SDK ships adapters and worked examples for both. The integration point is the same get_or_compute wrap around your chain's LLM call.

No. It sits in front of your provider and decides reuse-versus-recompute. It never generates content itself.

No. It uses a vector index internally for cache matching, but it isn't built to be your document retrieval store. Keep your RAG store; put Crowkis in front of the model calls.

It's engineered not to: personal, time-sensitive, and creative intents get strict thresholds, and the confidence gate refuses uncertain matches. You can also exclude tenants or set TTLs to zero for never-cache flows.

No. The license check is offline Ed25519 signature verification. Crowkis runs fully air-gapped. Nothing leaves your network unless you send it.

No, Crowkis is closed-source by design. You receive a signed binary in a minimal image: one file to security-review, no dependency tree to audit, no supply chain to poison.

Not in-process, run it behind your proxy or service mesh like you would most data-plane infrastructure, and keep the ports off the public internet.

Instead of one shared credential, you mint a key per app, team, or customer, each with its own budget and rate limits. When one app goes rogue, you throttle a key, not the whole cache.

Hard spending and rate ceilings per key. A runaway agent loop hits its budget and stops costing you money, Crowkis enforces the wall locally instead of you discovering it on the invoice.

The proof tool: replay a sample of your real production queries through the cache and get the exact hit rate and dollar savings you would have had. No projections, your own data. We run it for you on the demo call, before you spend anything.

Versioned prompts managed in the control plane, so prompt changes are tracked, comparable, and tied to cache behavior instead of scattered across codebases.

Purpose-built cache paths for agent workloads: multi-turn conversation state and deterministic tool-call results. Agent fleets are the most repetitive traffic that exists, these two features usually justify the license on their own.

A browsable library of the reasoning skeletons Crowkis has extracted, so teams can see which thought patterns recur and reuse them deliberately.

Routing that sends each query to the cheapest model that clears your quality bar for that intent, easy questions to cheap models, hard ones to frontier models, automatically.

Answers cached from one provider serve equivalent queries on another. Switch from one vendor to another without abandoning the cache value you've built.

Preset configurations for HIPAA, SOC2, GDPR-EU, and FedRAMP postures: retention rules, PII handling, audit behavior, and erasure workflows aligned to each regime out of the box.

Every administrative action and trust decision, persisted and exportable, the artifact your auditor actually asks for.

Your identity provider controls who can touch the control plane. Offboarding an employee from Okta offboards them from Crowkis.

Auto-Tuner continuously optimizes thresholds and eviction weights against your live traffic. Privacy Vault isolates sensitive entries with stricter handling. Live Edit lets operators correct or redact a cached answer in place, with the change audited.

Community: community channels. Enterprise: priority support with a fast human response, and we'll get on a call.

docker pull crowkis/crowkis:latest, then docker run with a volume on /data. RESP on 6379, dashboard on 6380, gRPC on 6381. First cache hit visible in the dashboard within five minutes.

No. The binary boots with sensible defaults and zero required environment variables. Configuration is enrichment, not a prerequisite.

Binary swap: docker pull the new tag and restart. The on-disk format is stable, no schema migrations, no export/import dance.

Modest: it's a single Rust binary. The defaults assume 512 MB of memory; give it more and the block cache will use it. Vertical scaling is free within a cluster license.

Yes, by default: non-root user, read-only filesystem, all Linux capabilities dropped, no-new-privileges, pids limit, localhost-only published ports, health checks, and log rotation, in the stock compose file.

The stripped crowkis binary, a non-root user, and a /data directory. No source, no package manager, no shell tooling to live off.

Yes, durability is WAL-based with CRC-checked records, and the vector index persists with the store. Restart recovery is part of the 347-test suite.

Yes, it's a single container with a /health endpoint, so a Deployment with a PVC works today, and a Helm chart ships with the Kubernetes packaging milestone.

Three ways: the built-in dashboard (live verdict feed), Prometheus /metrics for your existing Grafana, and structured JSON logs, one line per significant event, no log spam.

Community is free forever, full engine, no license, no sign-up. Enterprise is flat per cluster per year, priced in one conversation: email contact@crowkis.com and we'll get on a call. No usage metering, no per-seat math.

One running Crowkis deployment, regardless of how big the machine is. You buy another license when you run another cluster, not when you add cores.

No. It's the full engine, all seven differentiators, capped at 3 tenants and 100K entries. Solo developers and small teams can run it in production for free, indefinitely.

A signed JSON file mounted at /etc/crowkis/license.json, verified offline with Ed25519 at boot and every six hours. Invalid signature refuses to start; no file means Community; expiry has a 14-day grace period before degrading to Community.

No, deliberately. Caches exist to make costs predictable; a cache with a meter on it would be self-defeating.

Email contact@crowkis.com. For Enterprise we'll run Crowkis Replay on a sample of your own traffic during the call, so you see your real savings before spending anything.

The deliverable is one signed Rust binary, there is no dependency tree inside the runtime image for an attacker to poison. The 2026 supply-chain compromise of a major Python LLM gateway is exactly the attack class this architecture removes by construction.

Every entry is namespaced by tenant and lookups never cross the boundary. Tenant isolation is also a scored stage in the write-trust pipeline, so cross-tenant anomalies block the write itself.

A PII index supports scrubbing and erasure workflows with reports through the management API. Prompt previews stay out of logs by default, privacy is the default setting, not an option you enable.

RESP and gRPC take a bearer token compared in constant time; the management API takes an admin key, RBAC API keys, or sessions with role-gated endpoints. Bind beyond localhost and management auth becomes mandatory automatically, misconfiguration fails closed.

Every write, human, SDK, or agent, passes the same five-stage pipeline, and the source trust ledger means writers with a bad history face a higher bar. A blocked write is logged with the stage that vetoed it.

Fully. No phone-home, offline license verification, local dashboard. Air-gapped deployments are a first-class case, not a degraded one.