Self-hosted · MIT · Audit-ready

The AI assistant your team owns

Run the same Local Pocket on your own GPU servers. Frontier-class models against your internal data — and a packet capture you can point at the server to prove nothing leaves your network. Your iron. Your models. Your perimeter.

Get in touch See how it compares
YOUR NETWORK PERIMETER NO OUTBOUND GPU SERVER 70B model loaded Your RAG corpus FastAPI + Sync macOS SwiftUI desktop app iOS Companion + Siri intents Android Kotlin client Windows Tauri client One inference endpoint Your hardware Same UI on every device
0

Outbound bytes by default

7B – 400B

Model size supported

Your iron

Not ours, not anyone else's

4

First-party clients shipping

What it unlocks

The questions your team couldn't ask before

Because the data never had to leave. Three concrete patterns we keep hearing.

Engineering, with the receipts

One query against your runbooks, PRs, Slack engineering channel, and observability dashboard — without a byte crossing the VPC boundary.

ask.localpocket.you.internal

Why did p99 spike last Tuesday around 3pm?

  • p99 jumped 220 ms → 1.8 s at 14:47, recovered at 15:12.
  • Coincides with PR #4821 (auth middleware change) merged at 14:46.
  • Datadog shows DB pool exhaustion ~30 s after deploy.
  • Revert at 15:11 returned p99 to baseline.
Sources Notion runbooks (3) GitHub (1) Slack #eng (5) Datadog (2)
ask.localpocket.you.internal

Pull every clause that changed in our Q3 vendor contracts.

  • 4 contracts modified in Q3 with non-trivial clause changes:
  • Acme MSA — SLA tightened 99.5% → 99.9% (p.12)
  • BetaCorp DPA — added EU data-residency requirement (p.5)
  • Gamma LLC — liability cap raised $500k → $2M (p.8)
  • Delta Services — termination notice 30 → 90 days (p.3)
Sources Share drive (4)

Knowledge that won't leak

Legal, finance, and ops query the share drive in plain English. The audit trail stays inside your perimeter. The vendors never know you asked.

Customer context, joined up

Customer success joins your CRM, support inbox, issue tracker, and wiki in one prompt. Same UI your team already uses on their laptop, now pointed at your endpoint.

ask.localpocket.you.internal

Everything we know about Acme's renewal — across all four tools.

  • ARR: $480k, up from $320k last cycle.
  • 3 open tickets (P2) — all latency complaints in EU region.
  • Linear: 2 product requests they championed, both shipped Q3.
  • Wiki note: their champion is now VP Eng (was Director).
  • Last QBR: pushing for SSO + audit-log export.
Sources CRM (1) Support inbox (3) Issue tracker (2) Wiki (4)
Comparison

What you actually get vs. what you'd otherwise build

Cloud LLM API, a DIY internal stack, and Local Pocket Enterprise — side by side on the dimensions that matter for an enterprise rollout.

Cloud LLM API DIY internal stack Local Pocket Enterprise
Data leaves your network Yes · every prompt Only if you wire it that way Never. Zero outbound by default
Model lock-in Whatever the vendor offers None — but you wire it Any GGUF · swap in 10 minutes
Source you can audit No (proprietary) Your own, plus dependencies MIT · readable in an afternoon
Time to first inference Minutes (sign up) Weeks to months ~30 minutes from clone
RAG + knowledge graph Build it yourself Build it yourself Included · production-tested
Native clients Browser or 3rd-party SDK Build it yourself macOS · iOS · Android · Windows
Compliance posture Vendor's, not yours Inherits your stack Inherits your stack
Pricing shape Per-token, scales with usage Eng salaries + infra Flat support fee + your GPUs
Models

Run anything llama.cpp can load

Any GGUF, any quantisation. Hardware guidance below is conservative — quantised weights stretch further.

7B – 13B

Drop-in proof of concept

Hardware

Single consumer GPU (16 GB)

Use case

Pilot, internal demo, small team

70B
Sweet spot

Team-wide assistant

Hardware

1 × H100 80 GB (Q4) · 2 × A100 (FP16)

Use case

Department-scale, real workload

100B – 200B

Sharper reasoning

Hardware

2 – 4 × H100 (tensor-parallel)

Use case

Org-wide assistant, code work

400B+

Frontier-class, on-prem

Hardware

8 × H100 / multi-node

Use case

R&D, mission-critical inference

Per-user throughput

tokens / sec

What the user sees while the model types — single user, steady state.

7B – 13B
1 × consumer GPU
~80 tok/s
70B Sweet spot
1 × H100, Q4
~35 tok/s
100B – 200B
4 × H100, TP
~22 tok/s
400B+
8 × H100
~10 tok/s

Throughput is one axis — capability is the other. Bigger models trade speed for sharper reasoning. Numbers are conservative; quantisation, batching, and tensor-parallelism push them further.

Deployment

From clone to first inference in 30 minutes

One container, your GGUF weights, and the four clients you already ship. No vendor account, no API key, no cloud round-trip.

  1. 01 · Provision

    One GPU server, your choice

    Bare-metal rack, a colo box, a VPC instance. Anything llama.cpp runs on. Start with one A100/H100; scale out when load forces the issue.

  2. 02 · Run

    Server up, model loaded

    docker compose up or a systemd unit. Drop your GGUF in the models directory. Same /init + /chat surface as the desktop app — same code path.

  3. 03 · Point clients at it

    One config change per device

    macOS, iOS, Android, Windows — each client gets your endpoint URL instead of localhost. Same UI, same shortcuts, your inference.

docker-compose.yml 
# the whole deployment
services:
  localpocket:
    image: local-pocket/server:latest
    ports: ["8000:8000"]
    volumes:
      - ./models:/models:ro
      - ./data:/var/lib/localpocket
    environment:
      # swap the GGUF, no app change
      LP_MODEL_PATH: /models/llama-70b-q4.gguf
      LP_BIND: 0.0.0.0:8000
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]
    restart: unless-stopped

That's the whole deployment. Swap the GGUF path to swap the model.

What ships with you

Everything in the box

The full source

MIT-licensed. SwiftUI clients, FastAPI server, RAG pipeline, knowledge graph, sync layer — every line your team can read, fork, and harden.

Reference deployment

Docker compose and systemd units for single-node and small-cluster layouts. Sane defaults. Clear knobs. Real load tests.

Connector pack

Pre-built adapters for the systems your data lives in: object stores, wikis, ticketing, calendar, mail, code hosts. Drop in your credentials, point at internal hostnames.

Direct support

Slack or Signal channel straight to the people who wrote the code. Model selection, RAG tuning, custom integrations.

Security

Inherits your compliance posture

Because nothing leaves your network, Local Pocket Enterprise maps onto your existing controls instead of asking for new exceptions.

SOC 2 Type II

Maps to your existing controls

ISO 27001

No new vendor in scope

HIPAA

PHI never leaves the perimeter

GDPR

Data residency is wherever your server is

Compliance posture maps to your environment — we don't ship attestations, but the architecture removes most of the blockers.

Engagement

What 30 days with us actually looks like

No discovery dance, no nine-step procurement. A short, predictable path from "we should look at this" to "it's running in production."

Day 0
Inquiry

You email us. We reply with sizing questions inside 24 hours.

Day 7
Sandbox

Reference deployment running in your dev environment. First inference inside your perimeter, against test data.

Day 30
Pilot complete

Real workloads against your data. Two of your engineers familiar with the code. Sign-off or walk-away.

Day 30+
Production

Support contract starts. Direct line to the maintainers. Quarterly model upgrades on your call.

You can stop at the end of the pilot. No clawback, no termination fee. The reference deployment is yours either way.

FAQ

Common questions

Is it actually the same code as the desktop app?
Yes. The server-side stack is the FastAPI process that ships inside the desktop bundle. The desktop UI calls it on localhost; your team calls it at your internal hostname. Same RAG, same knowledge graph, same prompts.
How big a model can it run?
Whatever your hardware fits. A single H100 holds a quantised 70B comfortably. Multi-GPU layouts run 400B-class weights. We help you pick weights and quantisation for your workload — start small, swap up as load grows.
What about compliance — SOC 2, ISO, HIPAA, GDPR?
Because nothing leaves your network, the privacy posture maps cleanly onto your existing infrastructure controls. The codebase is small enough that your security team can do a real review — not a vendor questionnaire.
How is this licensed?
MIT. The source is on GitHub. Self-hosting is free; what we charge for is the reference deployment, ongoing support, custom integrations, and incident response. Tell us what you need.
Can we use it without a managed support contract?
Yes — fork the public repo and self-host. The Enterprise tier exists for teams who want a direct line to the maintainers, tested reference deployments, and help wiring it into their stack without paying for the learning curve.
How many seats? Per-user pricing?
No per-seat fees. The model runs on your iron; the cost is your GPU and a flat support fee. Connect as many of your employees as your GPU can serve.

Tell us what you want to run

Your stack, your data, the models you have in mind. We come back with a deployment plan, a hardware sizing, and a number.

contact@kclub.me

Usually a 30-minute call. No questionnaire.