Which AI providers does Cognocient support?

Cognocient proxies 10 provider types — OpenAI, Anthropic, Google Gemini, Mistral, Groq, Together AI, Azure OpenAI, AWS Bedrock, Google Vertex AI, and any OpenAI-compatible server as a custom endpoint — through a single base_url. Change the model name to switch providers with no separate SDK, no re-authentication, and no new keys.

Beyond chat: other endpoints and providers

Cognocient also proxies these OpenAI-compatible endpoints, with the same budgets, guardrails, freeze and cost tracking as chat:

Cohere, Jina and Voyage are added like any provider under Settings → AI Providers and are used only for reranking.

Growth and above can add extra keys per provider for multi-key balancing, and Business can keep keys in AWS Secrets Manager, Vault or Azure Key Vault.

Provider overview

New models

You don't have to wait for Cognocient to "add" a model. Any model name your provider accepts is forwarded as-is. Pricing keeps up on its own:

• Daily catalogue sync. Once a day Cognocient reads the public LiteLLM price map, which tracks new models from every provider above, and adds any model it doesn't know yet with its input, output and cache prices.
• Existing prices are never changed silently. If a provider changes the price of a model Cognocient already has, the change waits for review by the Cognocient team before it applies.
• Brand-new models are flagged, not guessed. Until a model is in the catalogue, its calls are costed at a conservative fallback ($2.50 / $10 per 1M tokens, never $0) and the model is flagged for pricing the same day.

Dated snapshots (for example claude-sonnet-4-5-20250929) and Bedrock cross-region IDs (us.anthropic....) use the price of their base model automatically.

Quick setup

Replace your api_key and base_url — that's the only change needed.

Image generation

/v1/images/generations is proxied the same way as chat and embeddings — same base URL, same proxy key, full budget/velocity/attribution coverage. Unlike chat and embeddings, image models are priced per-image rather than per-token (see Guardrails → Dollar-denominated velocity for why that needed its own velocity check).

response = client.images.generate(
    model="dall-e-3",
    prompt="a watercolor fox in a forest",
    size="1024x1024",
    quality="standard",
    n=1,
)

Native Anthropic SDK

If you use the Anthropic Python or TypeScript SDK directly (not via the OpenAI SDK), the base URL is slightly different — omit /v1:

Switching providers at runtime

All providers share the same client — switch by changing the model name:

from openai import OpenAI
 
client = OpenAI(api_key="sk-cog-YOUR-KEY", base_url="https://api.cognocient.com/v1")
 
def call_ai(prompt: str, model: str = "gpt-4o-mini"):
    return client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        extra_headers={"X-Cost-Feature": "ai-router"}
    )
 
# Route to any provider dynamically
call_ai("Hello", model="gpt-4o-mini")            # OpenAI
call_ai("Hello", model="claude-sonnet-4-6")       # Anthropic
call_ai("Hello", model="gemini-2.0-flash")        # Google

AWS Bedrock

Add your AWS Access Key ID and Secret Access Key (plus the region your model access is enabled in) in Settings → AI Providers. Bedrock is detected automatically from the model ID — no prefix needed:

# Bedrock — detected from the vendor-namespaced model ID
response = client.chat.completions.create(
    model="anthropic.claude-3-5-sonnet-20241022-v2:0",
    messages=[{"role": "user", "content": "Hello"}],
)
 
response = client.chat.completions.create(
    model="amazon.nova-pro-v1:0",
    messages=[{"role": "user", "content": "Hello"}],
)

Requests are signed with AWS Signature Version 4 and sent to Bedrock's Converse API — tool/function calling is supported.

Streaming (stream: true) works too: Cognocient calls Bedrock's ConverseStream API, decodes AWS's binary event-stream, and returns standard OpenAI-format server-sent events, including streamed tool calls and a final usage chunk.

Google Vertex AI

Add your GCP service-account JSON key (plus your project ID and region) in Settings → AI Providers. Unlike Bedrock, Vertex AI's Gemini model IDs look identical to direct Gemini API model IDs, so a vertex/ prefix tells Cognocient which key to bill against:

# Vertex AI — the vertex/ prefix routes here instead of a direct Gemini key
response = client.chat.completions.create(
    model="vertex/gemini-2.0-flash-001",
    messages=[{"role": "user", "content": "Hello"}],
)

Vertex AI's own OpenAI-compatible endpoint handles the request, so no request/response translation is needed — streaming and tool calling both work the same as the direct Gemini and OpenAI routes.

Custom OpenAI-compatible endpoints

Route to any server that speaks the OpenAI chat-completions API: Ollama, vLLM, LM Studio, llama.cpp's server, a LiteLLM gateway, or another vendor's OpenAI-compatible API. Add it in Settings → AI Providers → Custom:

Send custom/<model> as the model. The custom/ prefix selects your endpoint and is removed before the request is forwarded:

response = client.chat.completions.create(
    model="custom/llama3.1",   # sent to your server as "llama3.1"
    messages=[{"role": "user", "content": "Hello"}],
)

Streaming works. Cognocient asks the server for a final usage chunk (stream_options.include_usage) so tokens can be counted; servers that don't send one are tracked without token counts.

Cost tracking

Self-hosted models have no list price, so calls are recorded at $0 unless you enter your own per-1M-token rates. They still appear everywhere else: volume, latency, features, departments, budgets by count. Cognocient does not apply its generic fallback price to them, so a free local model never shows invented spend. Waste and model-mismatch detection don't apply to custom endpoints, since there are no price tiers to compare.

You can configure one custom endpoint per account. Its model names are yours to choose, so run several models behind the one endpoint (Ollama and vLLM both serve many).

Adding your provider API keys

Your provider keys are stored encrypted in Cognocient. The first one is added during sign-up: the setup flow offers every provider in this list, grouped as model providers, cloud platforms (Azure, Bedrock, Vertex AI) and self-hosted, and asks only for the fields that provider needs:

To add more later:

1. Go to Settings → AI Providers
2. Click Add another provider and pick one
3. Fill in the fields above; secrets are encrypted before being stored
4. All requests routed to that provider now use this key automatically

Your application never changes: one proxy key reaches every connected provider, and the model name in each call picks the provider. To rotate a key, click the refresh icon on its card and paste the new one; for Azure, Bedrock, Vertex AI and custom endpoints you can leave the secret blank to keep the stored one while changing the other fields.

Azure OpenAI: tell us the underlying model if your deployment name doesn't match it

Azure resolves which model actually answers a call purely from your deployment name in the URL — the model field your application sends in the request body is not authoritative, and Azure itself effectively ignores it for routing.

If you named your deployment something like my-prod-deployment rather than the model name itself, Cognocient has no way to know which real model that maps to unless you tell it. When adding or editing your Azure key in Settings → AI Providers, fill in the Underlying Model field (e.g. gpt-4o) — Cognocient uses that value for cost calculation instead of trusting whatever string your application happens to send.

Frequently asked questions