Providers and models

LangChain gives you a single, unified API to work with models from any provider. Install a provider package, pick a model name, and start building—the same code works whether you use OpenAI, Anthropic, Google, or any other supported provider.

graph LR
    subgraph "Your code"
        A["LangChain API<br/>(invoke, stream, bind_tools)"]
    end

    subgraph "Providers"
        B["OpenAI"]
        C["Anthropic"]
        D["Google"]
        E["AWS Bedrock"]
        F["...and more"]
    end

    A --> B
    A --> C
    A --> D
    A --> E
    A --> F

    classDef code fill:#E5F4FF,stroke:#006DDD,stroke-width:2px,color:#030710
    classDef provider fill:#EBD0F0,stroke:#885270,stroke-width:2px,color:#441E33

    class A code
    class B,C,D,E,F provider

One API for any model

Every LangChain chat model, regardless of provider, implements the same interface. This means you can:

• Swap providers without rewriting application logic
• Compare models side-by-side with identical code
• Use advanced features like tool calling, structured output, and streaming across all providers

from langchain.chat_models import init_chat_model

openai_model = init_chat_model("openai:gpt-5.5")
anthropic_model = init_chat_model("anthropic:claude-opus-4-8")
google_model = init_chat_model("google-genai:gemini-3.1-pro-preview")

for model in [openai_model, anthropic_model, google_model]:
    response = model.invoke("Explain quantum computing in one sentence.")
    print(response.text)

What is a provider?

A provider is a company or platform that hosts AI models and exposes them through an API. Examples include OpenAI, Anthropic, Google, and AWS Bedrock.

In LangChain, each provider has a dedicated integration package (for example langchain-openai, langchain-anthropic) that implements the standard LangChain interface for that provider's models. This means:

• Dedicated packages for each provider with proper versioning and dependency management
• Provider-specific features are available when you need them (for example OpenAI's Responses API, Anthropic's extended thinking)
• Automatic API key handling through environment variables

uv add langchain-openai       # For OpenAI models
uv add langchain-anthropic    # For Anthropic models
uv add langchain-google-genai # For Google models

For a full list of provider packages, see the integrations page.

Find model names

Each provider supports specific model names that you pass when initializing a chat model. There are two ways to specify a model:

from langchain.chat_models import init_chat_model

model = init_chat_model("openai:gpt-5.5")

from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-5.5")

When using init_chat_model with the provider:model format, LangChain automatically resolves the provider and loads the correct integration package. You can also omit the provider prefix if the model name is unambiguous (e.g., "gpt-5.5" resolves to OpenAI).

To find available model names for a provider, refer to the provider's own documentation. Here are some popular providers:

Use new models immediately

Because LangChain provider packages pass model names directly to the provider's API, you can use new models the moment a provider releases them (no LangChain update required). Simply pass the new model name:

model = init_chat_model("google_genai:gemini-mythos")

New model names work immediately as long as your provider package version supports the API version the model requires. In most cases, model releases are backward-compatible and require no package update.

Model capabilities

Different providers and models support different features. For a list of the chat model integrations and their capabilities, see the chat models integrations page.

Routers and proxies

Routers (also called proxies or gateways) give you access to models from multiple providers through a single API and credential. They can simplify billing, let you switch between models without changing integrations, and offer features like automatic fallbacks and load balancing.

Routers are useful when you want to:

• Access many providers with a single API key and billing account
• Switch models dynamically without managing multiple provider credentials
• Use fallback models that automatically retry with a different model if the primary one fails

from langchain.chat_models import init_chat_model

model = init_chat_model("openrouter:anthropic/claude-sonnet-4-6")
response = model.invoke("Hello!")

OpenAI-compatible endpoints

Many providers offer endpoints compatible with OpenAI's Chat Completions API. You can connect to these using ChatOpenAI with a custom base_url:

from langchain_openai import ChatOpenAI

model = ChatOpenAI(
    base_url="https://your-provider.com/v1",
    api_key="your-api-key",
    model="provider-model-name",
)

Next steps