Custom AI Endpoint

By default, MimicScribe’s text-AI features — summaries, speaker attribution, action items, the live assistant, dictation, and transform — run on Google Gemini through an open-source proxy. Audio always stays on your Mac; only transcript text is sent.

You can route those features to your own OpenAI-compatible endpoint instead — a model running locally on your Mac, or any hosted provider. It’s a power-user option for flexibility, and with a local model it keeps transcript text on your machine.

What you can connect

Any endpoint that speaks the OpenAI chat-completions API. Presets fill the Base URL for common ones:

• Local — text stays on your Mac. Ollama, LM Studio, or llama.cpp. Nothing leaves the device. Step-by-step: On-Device AI.
• Company-approved (enterprise). Microsoft Foundry (Azure OpenAI) or Amazon Bedrock — route transcript text to a provider your org already trusts, with no MimicScribe proxy in the path. See Enterprise providers below.
• Hosted inference. Google Gemini (your own key), OpenAI, Fireworks, Groq, Mistral, or OpenRouter. Transcript text goes to that provider directly, not through our proxy.
• Other. Any OpenAI-compatible server (vLLM, LiteLLM, Together, an internal gateway). Pick Other, paste the base URL, model, and key. Gateways that authenticate on their own header (Azure API Management, Portkey, Kong) work too — see Company gateways below.

With your own model, the output quality is the quality of the model you pick, so Verify (and the long-meeting probe) before relying on one.

Which model to pick

You don’t need a frontier model. The prompts are tuned for a small, fast flash-class model — the built-in default runs on that tier — so a comparable hosted or local model is usually enough. What matters more than raw size is two things, both of which Verify checks for you:

• Reliable structured (JSON) output. The summary, speaker-attribution, and action-item features ask the model for structured responses. A model that can’t hold a nested schema produces malformed or thin results.
• A 32k+ context window so a full-length meeting fits. Smaller windows silently truncate long transcripts — Verify’s long-meeting probe catches this, and MimicScribe fails loud rather than summarize half a meeting.

Practical guidance: dictation and transform are short and forgiving, so almost any current model handles them. Full-meeting summarization is the demanding case. The prompts are tuned specifically against Gemini Flash-Lite, so another provider’s smallest tier can be flakier on the nested schemas even at a similar size — if summaries come back malformed or thin, step up to a stronger instruction-following model (for example a Qwen3- or DeepSeek-class model, or a larger production model on Groq/Fireworks) rather than a mid-size Llama. When in doubt, let Verify and a real meeting decide.

Set it up

Open Settings → AI Provider.

1. Under Custom endpoint, fill in:
   • Preset — optional starting point. Pick one (Ollama, OpenRouter, …) to fill the Base URL — and a default model where one applies — then adjust.
   • Base URL — your server’s OpenAI-compatible address, e.g. http://localhost:11434/v1 for Ollama.
   • Model — the model name your server exposes, e.g. qwen3.6:27b. Use the dropdown next to the field to pick from the models your server advertises — it’s filled in automatically when a server is running — or type a name directly.
   • API Key — optional. Leave it blank for a local server with no auth; set it for a hosted provider. It’s stored in the macOS Keychain, not in plain settings.
   • Auth header — leave blank for the standard scheme (Authorization: Bearer, or api-key on Azure/Foundry hosts, chosen automatically). Set it only when your endpoint authenticates on a different header — a company gateway like Azure API Management (Ocp-Apim-Subscription-Key) or Portkey (x-portkey-api-key). The key is sent in that header instead.
   • Reasoning — sent as reasoning_effort. None (the default) makes thinking models answer directly instead of reasoning at length first. Some hosted providers only accept Low/Medium/High — if Verify or a feature reports the field was rejected, switch to one of those or Model default (omits the field).
2. Click Verify. It runs three checks in order, then tells you what it found:
   • Reachable — the server answers at that Base URL.
   • Model responds — a tiny request comes back from the model you named. A reachable server with the wrong model name is the most common misconfiguration, and a reachability check alone won’t catch it.
   • Capabilities — it probes what your endpoint actually supports and shows a line like Structured output: native · Reasoning control: supported · Long meetings: OK. The important one is the last: it sends a meeting-length prompt and checks the model reads the start of it. Many local servers (Ollama in particular) silently truncate a prompt that’s longer than the model’s context window — a one-hour meeting summarizes into fine-looking garbage with no error anywhere. If the probe finds the window is too small, Verify warns you to raise the model’s context length (e.g. Ollama’s num_ctx) or pick a 32k+ model. MimicScribe also remembers the measured window and, at runtime, fails loud rather than let a long meeting be truncated.
3. Under Feature routing, set any feature — Dictation, Transform, Post-meeting summary, Live assistant — to Custom endpoint. Each feature lists only the providers it supports, and you can mix: summaries on your local model, dictation on Gemini. A successful Verify already points every active feature at the endpoint, so this step is only for fine-tuning which features go where.

Set it up with an agent

This is the easiest way if you already use a coding agent like Claude Code. Everything the Custom endpoint card does, one command does too — so you can describe what you want in plain language and let the agent run it.

Paste something like this to your agent:

Set MimicScribe up to use my local qwen3 model through Ollama. The command is /Applications/MimicScribe.app/Contents/MacOS/mimicscribe --configure-ai-endpoint with --base-url, --model, --api-key, and --reasoning flags. Run it, read back the STATUS line, and tell me if anything needs fixing.

For a hosted provider: “Point MimicScribe at OpenRouter with API key sk-… and the qwen3-plus model.” The agent maps either request to the command below and runs it.

The command

The app’s executable accepts a --configure-ai-endpoint flag, runs headless, and exits:

/Applications/MimicScribe.app/Contents/MacOS/mimicscribe   --configure-ai-endpoint   --base-url http://localhost:11434/v1   --model qwen3

• --base-url, --model, --api-key, --reasoning, --auth-header — the same fields as the card. Pass only the ones you want to change; the rest are left as they are. An empty --api-key "" clears the stored key. --reasoning takes none, low, medium, high, or default. --auth-header names the HTTP header the key is sent in (for gateways — e.g. Ocp-Apim-Subscription-Key); an empty --auth-header "" restores the automatic scheme.
• It verifies by default — the same checks the card’s Verify button runs: reachable, then the model responds, then a capability probe (structured output, reasoning field, and the long-context/silent-truncation check). If verification fails, the command exits non-zero and does not switch any feature over. Pass --no-verify to skip the check (e.g. for a server you’ll start later).
• On success it points every active feature at the endpoint, exactly like the card does. A feature you’ve turned off stays off. Pass --no-adopt to set the fields without switching any feature over.

Reading the output

It prints one key: value line per setting and a final STATUS: line, so an agent can act on the result without screen-scraping:

base-url: http://localhost:11434/v1
model: qwen3
reasoning: none
api-key: none
verify: ok
capabilities: Structured output: native · Reasoning control: supported · Long meetings: OK
adopt: active features → custom endpoint
STATUS: ok

• STATUS: ok — configured, verified, and adopted. Nothing else to do (but restart the app if it’s running — see below).
• STATUS: verify-failed — settings were saved but the endpoint didn’t respond; the exit code is non-zero. The verify: line above says why (can’t reach the server, or the model didn’t answer).
• STATUS: incomplete — no model name is set, so the endpoint can’t be used. Pass --model.
• A WARNING: line (and a capabilities: … Long meetings: at risk line) means the model’s context window is too small for full meetings — raise it (num_ctx) or pick a larger model. This is the one an agent should surface to you, because everything still “works,” just wrong.

The API key is stored in the macOS Keychain, the same place the card puts it. If the app is already running, quit and reopen it to pick up the change (the command prints a NOTE: reminding you).

What routes to your endpoint

Every feature in Feature routing is its own row you can point at your endpoint: dictation, transform, post-meeting summaries (including speaker attribution, action items, and corrections), the live assistant, and a Supporting features row — reference-document search, vocabulary spelling hints, and meeting search. A successful Verify points all of your active rows at the endpoint at once; you can then move any of them back to Gemini or Off individually.

The Supporting features row is the only one without an Apple (On-Device) option — those tasks need structured-output and long-context support that a small on-device model can’t reliably provide, so it offers Gemini, your custom endpoint, or Off.

Enterprise providers

These use the same Custom endpoint card. Verify still works when the provider doesn’t expose an OpenAI-style /models listing — a tiny completion against the model you named is the real check.

Microsoft Foundry (Azure OpenAI)

Field	What to enter
Base URL	https://YOUR-RESOURCE.openai.azure.com/openai/v1 (replace YOUR-RESOURCE)
Model	Your deployment name, not the base model id (e.g. gpt-4o-meeting, not gpt-4o)
API Key	The resource key from the Azure / Foundry portal

MimicScribe sends the key in the api-key header (what Foundry expects for resource keys), including on the Azure Government (.azure.us) and China (.azure.cn) clouds. Microsoft Entra ID / keyless auth is not supported yet — if your org disables resource keys, route through a company gateway instead (many orgs front Foundry with Azure API Management; see Company gateways).

Amazon Bedrock

Field	What to enter
Base URL	https://bedrock-mantle.REGION.api.aws/v1 (e.g. us-east-1) — AWS’s recommended OpenAI-compat Chat Completions endpoint
Model	A Bedrock model id, e.g. openai.gpt-oss-120b
API Key	A Bedrock API key (Bearer token), not an IAM access-key pair

IAM SigV4 signing is not supported — paste a Bedrock API key from the AWS console. The Mantle endpoint serves a subset of Bedrock’s catalog; if Verify reports your model id isn’t found there (some Anthropic ids), use Other with https://bedrock-runtime.REGION.amazonaws.com/openai/v1 and the same key.

Fireworks / Groq

Provider	Base URL	Model guidance
Fireworks	https://api.fireworks.ai/inference/v1	Full path id from the Fireworks console. For meetings, prefer a large instruction model with strong structured JSON (e.g. Qwen3 / DeepSeek class) — mid-size Llama is fast but often flaky on nested summary/attribution schemas.
Groq	https://api.groq.com/openai/v1	An id from console.groq.com. For meetings prefer a larger production model (e.g. openai/gpt-oss-120b) over mid-size Llama. Short dictation/transform is less demanding.

Paste the provider API key; both use Authorization: Bearer. MimicScribe’s prompts are tuned on Gemini — any custom model is a quality tradeoff; use Verify (and the long-meeting capability probe) before relying on a pick for real meetings.

Company gateways

Many companies put one gateway in front of every approved AI provider — a LiteLLM proxy, Azure API Management, Portkey, or Kong. If your org hands you a gateway URL and a key instead of a provider account, that’s what goes in the card:

Gateway	Base URL	Auth header setting
LiteLLM proxy	Your gateway’s /v1 URL	Leave blank — LiteLLM takes a standard Bearer key
Azure API Management	The API’s gateway URL	Ocp-Apim-Subscription-Key
Portkey	Your Portkey gateway URL	x-portkey-api-key
Kong (key-auth)	Your gateway route URL	apikey (or whatever your Kong config names)

The Auth header field (on the Custom endpoint card, or --auth-header on the command line) names the header your key is sent in; blank means the standard scheme. Gateway configurations vary — if Verify returns 401, ask whoever runs the gateway which header it authenticates on. Some gateways need extra routing headers MimicScribe doesn’t send; those need a server-side default (most gateways can pin a provider per key).

What about GitHub Copilot?

You can’t point MimicScribe at a Copilot subscription, because GitHub doesn’t offer an API for apps like this one. Copilot’s model access is scoped to GitHub’s own surfaces (the IDE extensions, github.com, the Copilot CLI and SDK), and its inference endpoints are off-limits to third-party clients — tools that call them anyway are unsupported and risk the account. GitHub Models, the OpenAI-compatible endpoint GitHub briefly offered, was retired in July 2026; GitHub points its users at Azure AI Foundry instead.

That’s the practical answer too: a company with Copilot seats almost always has an Azure tenant. Ask for a Foundry deployment and use the Microsoft Foundry preset above — same Microsoft billing relationship, and an endpoint your org actually sanctions.

Privacy

• A local endpoint keeps transcript text on your Mac end to end — combined with on-device transcription, nothing leaves the machine.
• A hosted or enterprise endpoint sends transcript text to that provider instead of to Google. You are responsible for the privacy and security of any endpoint you configure.
• Audio is never sent, on any path.

If you want AI summaries with zero cloud, point the features at a local model. If you want no AI at all, use Local Mode — toggle it per meeting, or turn on Start meetings offline (Settings → AI Provider) to make it the default. That keeps transcription on-device and pauses every AI feature.

You can watch the routing work. Open Settings → Network Log and run a meeting: each AI request lists the endpoint it went to — your server’s address instead of our proxy. With a local model that’s localhost, and nothing AI-related leaves the machine. See Network Activity for what the log records.

Plans and limits

A custom endpoint shares your free-tier daily allowance — the same per-feature daily caps as the default proxy path. The Light and Unlimited plans lift those caps. This is a product limit, not a cost one: even when the model runs on your own hardware, free use is metered the same way.

Troubleshooting

Verify reports its failure modes separately:

• Cannot connect / server returned a code — the Base URL is wrong, or the server isn’t running.
• Model not found / timed out — the server is reachable, but the Model name doesn’t match what it exposes, or the model is too slow to load. Check the exact name your server lists (Foundry: deployment name; Fireworks: full accounts/…/models/… path; Bedrock: model id).
• 401 / unauthorized — wrong key type for that host. Foundry wants a resource key (not an Entra token). Bedrock wants a Bedrock API key (not IAM access keys). Behind a company gateway, a 401 usually means the key belongs in a different header — set Auth header to the one your gateway authenticates on (see Company gateways).
• Long meetings at risk (a warning, not a hard failure) — the model’s context window is too small to read a full meeting, so long transcripts would be silently truncated. Raise the model’s context length (Ollama’s num_ctx) or pick a model with a 32k+ window. Short tasks like dictation and transform are unaffected.

If a feature is set to Custom endpoint but no model name is saved, that run is skipped and the feature reports “Custom endpoint not configured — choose a model in AI Provider settings.”

To confirm what is and isn’t leaving your Mac at any moment, see Network Activity.