> ## Documentation Index
> Fetch the complete documentation index at: https://praison.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Model Provider Plugins

> Map any model name to a provider id — built-in or plugin-registered via entry points

> [!NOTE]
>
> **Looking to add a full provider, not just a name matcher?** This page registers a bare-name → provider-id matcher. For a complete `LLMProviderAdapterProtocol` adapter that handles the actual API call and plugs into the CLI picker, see [Custom Provider Adapters](https://praison.ai/docs/features/custom-provider-adapters.md).

Model provider plugins map a bare model name (`llama-3.1-70b`, `claude-sonnet-4-6`, `custom-model`) to its canonical provider id (`groq`, `anthropic`, ...) so runtime and config resolution work for every vendor — not just three hard-coded ones.

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents.llm import resolve_provider

resolve_provider("claude-sonnet-4-6")   # "anthropic"
resolve_provider("openai/gpt-4o")        # "openai"  (explicit prefix wins)
resolve_provider("llama-3.1-70b-groq")   # "groq"
```

Your agent picks a model by name; PraisonAI resolves the provider so `providers.<name>.runtime_default` applies automatically.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    subgraph "Provider Resolution"
        M[📝 Model name] --> P{🔍 provider/model prefix?}
        P -->|yes| Pre[✅ prefix wins]
        P -->|no| EP[🔌 Entry-point matchers]
        EP --> BI[🧠 Built-in matchers]
        BI --> Out[✅ provider id]
    end

    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef decide fill:#F59E0B,stroke:#7C90A0,color:#fff
    classDef plugin fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef result fill:#10B981,stroke:#7C90A0,color:#fff

    class M input
    class P decide
    class EP,BI plugin
    class Pre,Out result
```

## Quick Start

**1. Resolve a built-in provider**

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents.llm import resolve_provider

print(resolve_provider("gemini-1.5-pro"))   # "google"
print(resolve_provider("deepseek-chat"))     # "deepseek"
print(resolve_provider("grok-2"))            # "xai"
```

**2. Use it from YAML runtime config**

```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
framework: praisonai

providers:
  groq:
    runtime_default: praisonai   # applies to any groq model

agents:
  fast:
    role: Responder
    goal: Answer quickly
    instructions: "Answer in one sentence"
    llm: llama-3.1-70b-groq       # resolves to provider "groq"
```

***

## How It Works

`resolve_provider(model_name)` returns the provider id in a fixed precedence.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
sequenceDiagram
    participant Caller
    participant R as resolve_provider
    participant EP as entry-point matchers
    participant BI as built-in matchers

    Caller->>R: resolve_provider("llama-3.1-70b-groq")
    R->>R: has "/" ? → no
    R->>EP: try registered matchers (lowercased name)
    EP-->>R: no match
    R->>BI: try built-ins in order
    BI-->>R: "groq" matches
    R-->>Caller: "groq"
```

| Step | Rule |
| - | - |
| 1. Explicit prefix | `provider/model` → text before the first `/`, lowercased (`openai/gpt-4o` → `openai`). |
| 2. Entry-point matchers | Callables registered under `praisonaiagents.model_providers`; the entry-point **name** is the returned provider id. Registered matchers run **before** built-ins, so a plugin can override built-in detection. |
| 3. Built-in matchers | The shipped table below, tried in order. |

Returns `None` when nothing matches.

### Built-in providers

| Provider id | Match rule |
| - | - |
| `anthropic` | `"claude"` anywhere in the name (cloud-vendored forms like `us.anthropic.claude-3-5-sonnet` still resolve) |
| `openai` | starts with `gpt-`, `o1-`, `o3-`, `o4-`, `chatgpt-` |
| `google` | starts with `gemini-`, `gemma-` |
| `groq` | starts with `llama-`, `mixtral-`, `gemma2-` **and** contains `groq` |
| `cohere` | starts with `command-`, `c4ai-` |
| `mistral` | starts with `mistral-`, `codestral-`, `open-mistral-`, `open-mixtral-` |
| `ollama` | starts with `ollama/` |
| `deepseek` | starts with `deepseek-` |
| `xai` | starts with `grok-` |
| `perplexity` | starts with `pplx-`, `sonar-` |

***

## Publish a Plugin

Register a vendor out-of-tree — pip-installable, no PraisonAI code changes.

**1. Declare the entry point**

```toml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# your-plugin/pyproject.toml
[project.entry-points."praisonaiagents.model_providers"]
bedrock = "my_plugin.matchers:is_bedrock_model"
```

The entry-point **name** (`bedrock`) is the provider id `resolve_provider(...)` returns on a match — it must equal the key you use under `providers:` in YAML.

**2. Write the matcher**

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# my_plugin/matchers.py
def is_bedrock_model(model_name_lowercased: str) -> bool:
    return (
        model_name_lowercased.startswith("bedrock/")
        or ".anthropic.claude-" in model_name_lowercased
    )
```

The matcher receives the **already-lowercased** model name and returns `bool`.

**3. Use it**

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# after `pip install your-plugin`
from praisonaiagents.llm import resolve_provider

resolve_provider("bedrock/claude-3")   # "bedrock"
```

> [!NOTE]
>
> **Registered matchers take precedence over built-ins.** Register a matcher named `anthropic` to override the built-in `claude` detection, for example.

> [!WARNING]
>
> **Failure isolation.** A broken plugin — import error, load error, or a matcher that raises — is skipped silently, so provider inference never falls over on a third-party bug. If your plugin seems ignored, test the matcher import directly.

***

## What Consumes This

`praisonai_adapter._resolve_agent_runtime` calls `resolve_provider(agent_model)` to pick `providers.<name>.runtime_default`. When no provider matches, a `logger.debug` line explains the miss and the provider-scoped default is not consulted:

```
runtime resolution: no provider registered for model '<model>'; provider-scoped 'runtime_default' not consulted
```

See [Runtime Selection](https://praison.ai/docs/features/runtime-selection.md) for the full resolution order.

***

## Public API

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# lazy re-export (preferred)
from praisonaiagents.llm import resolve_provider

# canonical module
from praisonaiagents.llm.model_providers import resolve_provider
```

| Symbol | Signature | Description |
| - | - | - |
| `resolve_provider` | `(model_name: str) -> Optional[str]` | Returns the canonical provider id, or `None` if no matcher hits. |

***

## Best Practices

> [accordion] Match the entry-point name to your provider key
>
> `resolve_provider(...)` returns the entry-point **name**. Name it exactly what you use under `providers:` in YAML, or `runtime_default` won't apply.

> [accordion] Accept the lowercased name
>
> Matchers receive the model name already lowercased. Don't re-lowercase or compare against mixed-case constants — write your checks in lowercase.

> [accordion] Keep matchers cheap and total
>
> Matchers run on every unprefixed model name. Use simple `startswith` / `in` checks and never raise — a raising matcher is skipped, and slow ones tax every resolution.

> [accordion] Prefer explicit prefixes for one-offs
>
> For a single model, `provider/model` in YAML (`bedrock/claude-3`) resolves without any plugin — reserve entry points for whole vendor families.

***

## Related

> [card] [Runtime Selection](https://praison.ai/docs/features/runtime-selection.md)
>
> Choose which runtime executes each model, per provider or per agent

> [card] [Integration Registry](https://praison.ai/docs/features/integration-registry.md)
>
> Same static-map + entry-point + built-ins-win pattern for integrations


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.