Self-Hosted Customer Support AI with ResolveKit and Your Own LLM

You have data you don't want in someone else's hands. Your legal team has questions about where PII lives. Your ops team has APIs behind a VPN. And your enterprise customers have procurement checklists that require "data processed in our own infrastructure."

You can't solve those constraints with a SaaS support tool. You need something you control end-to-end.

ResolveKit is designed for exactly this: a native SDK that runs in your mobile app, connected to a backend you own, backed by LLM providers you choose. Here's how the architecture works and what it gives you.

The Architecture: Where Data Flows

ResolveKit's in-app support system has four components:

1. The SDK — embedded in your iOS or Android app. Handles the chat UI, session management, and tool execution. ~500KB. No web view.

2. The backend — your ResolveKit instance. Routes messages to your LLM, enforces approval policies, logs traces. MIT/AGPL, self-hosted.

3. The LLM — your API keys. OpenAI, Anthropic, Ollama, or any OpenAI-compatible endpoint. You're in control of the model.

4. The operator dashboard — a web UI for reviewing traces, managing approvals, and configuring policies. Connects to your self-hosted backend.

The SDK sends messages to your backend. Your backend sends them to your LLM. Your LLM responds. The backend logs the exchange and returns the response to the SDK. Nothing is routed through ResolveKit's infrastructure by default — you're pointing at your own endpoints.

BYO LLM: What That Actually Means

"Bring your own LLM" isn't just a licensing flexibility pitch. It has concrete implications for how you build support workflows.

You control the model. If you want to run a fine-tuned model trained on your support logs, you can. If you want to use a small local model for simple queries and only route complex ones to GPT-4o, you can. The backend doesn't care which provider you use — it speaks OpenAI-compatible API format.

You control the data. The backend receives every user message and every function call argument. With a self-hosted deployment, that data never leaves your network. You can apply your own encryption, VPC routing, and data residency rules.

You control the cost. LLM pricing varies wildly by provider and model. Running Llama 3.3 locally costs electricity. Running GPT-4o through the OpenAI API costs per token. ResolveKit's managed tier adds $0.50 per resolved conversation on top of your LLM costs — but if you self-host, you pay only your infrastructure and LLM costs.

Setting Up a Self-Hosted ResolveKit Backend

The backend is a Node.js service you deploy to your own infrastructure. Docker image is available on GitHub.

docker pull resolvekit/backend:latest
docker run -p 3000:3000 \
  -e RESOLVEKIT_LICENSE=your-license-key \
  -e OPENAI_API_KEY=sk-... \
  -e DATABASE_URL=postgres://localhost/resolvekit \
  -e OPERATOR_API_KEY=your-operator-key \
  resolvekit/backend:latest

Configuration is done via environment variables. Key ones:

| Variable | What it does |

|---|---|

| `OPENAI_API_KEY` | Your LLM API key (or `ANTHROPIC_API_KEY`, or `OLLAMA_BASE_URL` for local) |

| `DATABASE_URL` | PostgreSQL connection string — session data, traces, and logs live here |

| `OPERATOR_API_KEY` | Protects the operator dashboard endpoint |

| `REQUIRE_APPROVAL_DEFAULT` | Set to `true` to require operator approval for all tool calls by default |

Once the container is running, point your SDK at it:

let runtime = ResolveKitRuntime(configuration: ResolveKitConfiguration(
    apiKeyProvider: { "rk_your_api_key" },
    backendURL: URL(string: "https://your-internal-domain/api")!,
    functions: [GetOrderStatus.self, ProcessRefund.self, EscalateToHuman.self]
))

What Operator Control Looks Like in Practice

One of the more common questions from legal and security teams during procurement is: "Can we see what the AI decided to do?" With ResolveKit, every tool call — including the LLM's reasoning for why it made a particular call — is logged to your database.

The operator dashboard shows you:

• **Conversation trace** — every message in the session, in order
• **Tool call log** — which function was called, with what arguments, and what the LLM said about why
• **Approval decisions** — approved, rejected, or modified, with operator ID and timestamp
• **Latency metrics** — time from user message to first token, time from tool call to resolution

You can query this data directly via the backend API and pipe it into your SIEM, your data warehouse, or your compliance reporting pipeline. The schema is documented in the backend repo.

Who This Is For

Self-hosted ResolveKit is the right call when:

• **Enterprise procurement requires it** — data processed in your own infrastructure, not a third-party SaaS
• **You have strict PII requirements** — PCI, HIPAA, GDPR, or internal data governance rules that restrict what leaves your network
• **You want to run local models** — small Llama instances for simple FAQ routing, save GPT-4o calls for complex triage
• **You have API access restrictions** — your backend services aren't reachable from public cloud providers without VPN

If you're a smaller team that wants to move fast and doesn't have compliance constraints, the managed tier at $0.50/conversation is simpler. Self-hosted is for teams that need operational control before they can sign a contract.

What's Included in the Self-Hosted Tier

Everything in the managed tier, minus the ResolveKit-hosted routing:

• SDK (iOS + Android)
• Backend (Node.js, Docker)
• Operator dashboard
• Full trace logging
• Approval policy engine
• SDK updates and security patches via GitHub

You bring: your own infrastructure, your own database, your own LLM API keys.

The backend is MIT/AGPL licensed. Use it for free on your own infrastructure. If you need commercial licensing for closed-source products, contact the team.

Getting Started

The iOS SDK and Android SDK are on GitHub. The backend repo includes a Docker Compose file with a PostgreSQL dependency for local development. Quick-start guide is in the README.

If you're evaluating whether self-hosted ResolveKit fits your infrastructure constraints, the team can walk through the architecture with your security or ops team. Talk to someone →

For immediate development: Start Free — no credit card required, self-hosted is free forever under MIT/AGPL.