polygate 0.1.0

One consistent function to call any LLM provider — Anthropic, OpenAI, Gemini, Moonshot, and more.

polygate

One function. Any LLM provider.

polygate is a tiny, dependency-light wrapper that gives you a single consistent interface for calling Anthropic (Claude), OpenAI, Google Gemini, and Moonshot (Kimi K2) — instead of learning four different SDKs and four different response shapes.

from polygate import chat

response = chat(
    provider="anthropic",       # or "openai", "gemini", "moonshot"
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Say hi in one word."}],
    api_key="sk-...",           # or set ANTHROPIC_API_KEY in the environment
)

print(response.content)   # "Hi!"
print(response.usage)     # Usage(prompt_tokens=..., completion_tokens=..., total_tokens=...)

import { chat } from "polygate";

const response = await chat({
  provider: "openai",
  model: "gpt-4o",
  messages: [{ role: "user", content: "Say hi in one word." }],
  apiKey: "sk-...", // or set OPENAI_API_KEY in the environment
});

console.log(response.content);

This repo isn't trying to out-feature mature gateways like LiteLLM, Portkey, or Helicone — it's a small, boring, easy-to-read wrapper built to be genuinely simple to depend on and easy to maintain. Contributions are welcome, but the scope is intentionally kept narrow: normalize the request/response shape across providers, nothing more (no built-in retries, caching, or routing logic — bring your own if you need them, or build them on top).

Why this exists

Most unified-LLM libraries are either full frameworks (with retries, caching, cost tracking, routing, and a dozen other opinions baked in) or tightly coupled to one ecosystem (e.g. LangChain). polygate is neither — it's the smallest possible layer that lets you swap providers by changing one string, with each provider adapter being readable in under 100 lines.

Packages

Language	Package	Install
Python	polygate	pip install polygate
TypeScript / JavaScript	polygate	npm install polygate

(Not published yet — see CONTRIBUTING.md for running from source.)

Supported providers

Provider	Aliases	Env var fallback
Anthropic (Claude)	anthropic, claude	ANTHROPIC_API_KEY
OpenAI	openai, gpt	OPENAI_API_KEY
Google Gemini	gemini, google	GEMINI_API_KEY
Moonshot (Kimi K2)	moonshot, kimi	MOONSHOT_API_KEY

The unified message format

Regardless of provider, messages is always a list of:

{ "role": "system" | "user" | "assistant", "content": "..." }

Each adapter translates this into whatever shape the underlying provider actually expects (e.g. Anthropic's separate system field, Gemini's contents/model role naming).

The unified response

Every call returns the same shape, regardless of provider:

• content — the assistant's reply text
• role — always "assistant"
• model — the model that was actually used
• provider — which provider served the request
• usage — { prompt_tokens, completion_tokens, total_tokens }
• raw — the untouched, original provider response, for anything not normalized above

Extra parameters

Anything you pass beyond provider, model, messages, api_key, temperature, and max_tokens is forwarded straight through to the provider's request payload — so provider-specific options (tools, top_p, stop sequences, etc.) still work without polygate needing to know about them ahead of time.

Project layout

polygate/
├── python/       # pip package
├── typescript/   # npm package
├── README.md
├── CONTRIBUTING.md
└── LICENSE

Contributing

See CONTRIBUTING.md. Adding a new provider is usually just: one new adapter file + one line in the registry.

License

MIT — see LICENSE.