OpenRouter em Python: use qualquer LLM com uma única chave de API

Desenvolver aplicações de IA muitas vezes exige gerenciar várias chaves de API, aprender diferentes padrões de serviço e lidar com diversos métodos de autenticação. E se você pudesse acessar dezenas de LLMs de ponta com apenas uma chave de API? Essa é a proposta do OpenRouter. Neste artigo, vou mostrar a maneira mais simples de usá-lo em Python. Nos próximos artigos, também mostraremos como integrar o OpenRouter ao LangChain e como usá-lo com o LangChain para chamadas de ferramentas. O código-fonte deste artigo está disponível aqui.

O que é o OpenRouter?

O OpenRouter funciona como um gateway unificado para os principais modelos de linguagem do mundo, incluindo modelos comerciais e de código aberto. Ele permite acessar modelos da OpenAI, Anthropic, Google, Meta, Mistral e outros provedores por meio de uma API única e padronizada.

Em vez de criar contas separadas para cada provedor e gerenciar vários SDKs, o OpenRouter oferece uma interface que permite acessar qualquer modelo de linguagem de grande porte de qualquer provedor com apenas uma linha de código. Isso pode simplificar bastante seu fluxo de desenvolvimento se você estiver criando aplicações que usam vários LLMs ou apenas quiser experimentar diferentes modelos para descobrir qual atende melhor ao seu caso de uso.

Por que usar o OpenRouter?

Já mencionamos algumas vantagens: uma única API para acessar dezenas de modelos, como GPT-4, Claude, Gemini, Llama e muitos outros. Além disso, o OpenRouter oferece:

• Roteamento para o melhor modelo: há várias opções para direcionar prompts a diferentes modelos de acordo com o conteúdo dos prompts. Por exemplo, ao definir "model" como "openrouter/auto", você usa o AutoRouter para decidir qual modelo é mais adequado para processar seu prompt.

• Confiabilidade e redundância: o OpenRouter oferece recursos de failover, permitindo que sua aplicação recorra a outros provedores quando um deles ficar indisponível.

• API compatível com a OpenAI: se você já usa o SDK da OpenAI, pode migrar para o OpenRouter com o mínimo de alterações no código.

Implementação básica do OpenRouter

Esta é a maneira mais simples de usar o OpenRouter em Python. O código em openrouter_simple.py apresenta um exemplo mínimo para você começar rapidamente. Confira o script completo:

"""
Minimal example for using OpenRouter with the OpenAI client directly.
This is the simplest way to get started with OpenRouter.
"""
import os
import pathlib
from dotenv import load_dotenv
from openai import OpenAI

# Get the current directory and load .env file
current_dir = pathlib.Path(__file__).parent.absolute()
env_path = current_dir / '.env'
load_dotenv(dotenv_path=env_path)

# Get API key from environment
api_key = os.environ.get("OPENROUTER_API_KEY")

# Check if API key is available
if not api_key:
    raise ValueError("OpenRouter API key not found. Please set OPENROUTER_API_KEY in your .env file.")

# Create a client for OpenRouter
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=api_key,
    default_headers={"HTTP-Referer": "http://localhost:5000"}  # Required by OpenRouter
)

# Send a message to the model
response = client.chat.completions.create(
    model="openai/gpt-3.5-turbo",  # You can change this to any supported model
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello, who are you?"}
    ]
)

# Display the response
print(response.choices[0].message.content)

Este script reúne tudo o que você precisa para começar a usar o OpenRouter. Você pode dividi-lo em quatro etapas:

1. Configuração do ambiente

O script começa carregando sua chave de API de um arquivo .env, o que mantém suas credenciais seguras:

# Get the current directory and load .env file
current_dir = pathlib.Path(__file__).parent.absolute()
env_path = current_dir / '.env'
load_dotenv(dotenv_path=env_path)

# Get API key from environment
api_key = os.environ.get("OPENROUTER_API_KEY")

# Check if API key is available
if not api_key:
    raise ValueError("OpenRouter API key not found. Please set OPENROUTER_API_KEY in your .env file.")

Você precisará criar um arquivo .env com sua chave de API do OpenRouter:

OPENROUTER_API_KEY=your_openrouter_api_key

Você pode obter uma chave de API inscrevendo-se em openrouter.ai.

2. Configuração do cliente OpenAI

A mágica acontece nestas poucas linhas:

# Create a client for OpenRouter
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=api_key,
    default_headers={"HTTP-Referer": "http://localhost:5000"}  # Required by OpenRouter
)

Observe que estamos usando o cliente padrão da OpenAI, mas direcionando-o para o endpoint da API do OpenRouter. Isso funciona porque o OpenRouter é totalmente compatível com o formato da API da OpenAI.

O cabeçalho HTTP-Referer é exigido pelo OpenRouter para identificar a origem da solicitação. Em um ambiente de produção, você definiria esse valor como a URL da sua aplicação.

3. Seleção do modelo e solicitação

Ao fazer uma solicitação, você especifica qual modelo quer usar:

# Send a message to the model
response = client.chat.completions.create(
    model="openai/gpt-3.5-turbo",  # You can change this to any supported model
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello, who are you?"}
    ]
)

O identificador do modelo segue o formato provider/model-name. Alguns exemplos:

• openai/gpt-4o-2024-11-20 - GPT-4o (Omni) da OpenAI com uma data de corte de conhecimento específica

• anthropic/claude-sonnet-4 - Claude 4 Sonnet da Anthropic

• google/gemini-2.5-pro-preview - Gemini Pro 2.5 do Google (prévia)

• meta-llama/llama-4-maverick - Llama 4 17B Instruct da Meta

Às vezes, o OpenRouter dá acesso a modelos que talvez você não conseguisse usar normalmente. Um exemplo foi o acesso antecipado a modelos premium como o GPT-4 32K. A lista completa de modelos disponíveis está em openrouter.ai/models.

4. Processamento da resposta

Por fim, extraímos e exibimos a resposta:

1# Display the response
2print(response.choices[0].message.content)

A estrutura da resposta segue o mesmo formato da API da OpenAI, facilitando a integração com o código existente.

Recursos e opções do OpenRouter

Embora o exemplo básico acima ajude você a começar rapidamente, o OpenRouter oferece muitos outros recursos:

Controle do roteamento de modelos

O OpenRouter oferece opções abrangentes para controlar para qual provedor subjacente sua solicitação será direcionada. Você pode especificá-las usando o formato JSON do OpenRouter (consulte extra_body):

# Provider preference ordering
response = client.chat.completions.create(
    model="meta-llama/llama-3.1-8b-instruct",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"provider": {"order": ["together", "fireworks", "perplexity"]}}
)

# Quantization preferences (only for open-source models)
response = client.chat.completions.create(
    model="meta-llama/llama-3.1-8b-instruct",  # Must use open-source model
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"provider": {"quantizations": ["fp8"]}}
)

# Fallback control
response = client.chat.completions.create(
    model="meta-llama/llama-3.1-8b-instruct",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"provider": {"allow_fallbacks": True}}
)

# Data collection control
response = client.chat.completions.create(
    model="openai/gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"provider": {"data_collection": "deny"}}
)

Este exemplo especifica que você quer usar apenas provedores que oferecem suporte à quantização fp8 para esse modelo.

Streaming de respostas

O OpenRouter oferece suporte ao streaming de respostas, um recurso útil para aplicações de chat:

stream = client.chat.completions.create(
    model="anthropic/claude-3-sonnet",
    messages=[
        {"role": "user", "content": "Tell me about renewable energy benefits"}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Modelos de linguagem com visão

O OpenRouter oferece suporte a modelos multimodais capazes de processar imagens:

import base64

# Method 1: Using local image files
def encode_image_to_base64(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

base64_image = encode_image_to_base64("your_image.png")

response = client.chat.completions.create(
    model="openai/gpt-4o",  # GPT-4o works reliably for vision
    messages=[
        {
            "role": "user", 
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_image}"}}
            ]
        }
    ]
)

# Method 2: Using image URLs
response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[
        {
            "role": "user", 
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
            ]
        }
    ]
)

Preços e gestão de custos

O OpenRouter usa um sistema baseado em créditos, no qual diferentes modelos consomem quantidades variadas de créditos por solicitação. Há créditos gratuitos para testes, mas você precisará comprar créditos adicionais para uso em produção.

Você pode monitorar seu uso no painel do OpenRouter e definir limites de crédito para as chaves de API, controlando assim os gastos.

Comece agora

Para usar o código deste artigo:

• Crie uma conta no OpenRouter em openrouter.ai

• Crie uma chave de API em openrouter.ai/settings/keys

Configure um ambiente Python com os pacotes necessários:

pip install openai python-dotenv

Crie um arquivo .env com sua chave de API:

OPENROUTER_API_KEY=your_openrouter_api_key

Execute o script de exemplo:

python openrouter_simple.py

Para concluir

O OpenRouter preenche uma lacuna no ecossistema de IA ao funcionar como um marketplace unificado de modelos de linguagem. A implementação que apresentei se destaca pela simplicidade: com apenas algumas linhas de código, você pode alternar entre dezenas de modelos de ponta sem mudar a estrutura da sua aplicação.

Para quem desenvolve aplicações de IA, isso significa que você pode:

1. Testar diferentes modelos sem se comprometer com um único provedor

2. Usar o melhor modelo para cada tarefa específica

3. Implementar alternativas para aumentar a confiabilidade

4. Otimizar os custos escolhendo o modelo mais econômico para cada caso de uso

O script openrouter_simple.py incluído fornece a base necessária. A partir daí, você pode criar aplicações robustas que aproveitam todo o potencial dos modelos de linguagem modernos sem a complexidade de gerenciar várias APIs.

Desenvolva aplicações de IA com segurança usando a Snyk

Ao desenvolver aplicações com o OpenRouter e outras ferramentas de IA, a segurança se torna uma preocupação fundamental. A Snyk oferece soluções criadas especificamente para o ecossistema de IA emergente.

Snyk AI Security Platform

A AI Security Platform da Snyk ajuda a enfrentar os desafios de segurança específicos do desenvolvimento impulsionado por IA. Com ela, os desenvolvedores podem criar aplicações de IA seguras sem abrir mão da velocidade que a IA proporciona.

A AI Security Platform foi desenvolvida para ajudar as organizações a acelerar a inovação impulsionada por IA, reduzir riscos para os negócios e proteger a IA agentiva e generativa. Isso é especialmente importante porque estudos indicam que quase metade de todo o código gerado por IA contém vulnerabilidades de segurança.

A AI Security Platform da Snyk permite que as equipes desenvolvam rapidamente sem abrir mão da segurança em um cenário habilitado por IA — reduzindo o esforço humano e aumentando a eficiência das políticas de segurança e da governança. Ela se baseia nos abrangentes mecanismos de teste da Snyk, impulsionados pelo DeepCode AI e abastecidos por seu banco de dados de vulnerabilidades, referência no setor.

Programa Secure Developer da Snyk para código aberto

Se você trabalha em projetos de código aberto que usam tecnologias de IA como o OpenRouter, o Secure Developer Program da Snyk oferece recursos valiosos. Lançado em fevereiro de 2025, o programa foi criado para fortalecer a segurança no ecossistema de código aberto. O Snyk Secure Developer Program oferece um suporte inédito a comunidades de código aberto, ajudando a criar programas de segurança de nível empresarial que identificam e corrigem rapidamente vulnerabilidades no código.

O programa oferece aos projetos de código aberto que atendem aos critérios:

• Ferramentas de segurança de nível empresarial: acesso completo e gratuito à plataforma de segurança premium da Snyk

• Suporte especializado: assistência prática da equipe de relações com desenvolvedores da Snyk

• Recursos para a comunidade: acesso à comunidade da Snyk no Discord e ao Partner Connect

• Acesso à API: recursos de integração para automatizar verificações de segurança

A Snyk oferece gratuitamente essas ferramentas de segurança para desenvolvedores, referência no setor, a projetos de código aberto que atendem aos critérios. Para se qualificar, seu projeto não pode ter o apoio de uma empresa e precisa ter pelo menos 10.000 estrelas no GitHub.

Combinando a flexibilidade do OpenRouter às ferramentas de segurança da Snyk, você pode criar aplicações de IA poderosas e seguras. Essa abordagem é especialmente valiosa à medida que o desenvolvimento de IA acelera e surgem novos desafios de segurança.

Saiba mais sobre essas ofertas e inscreva-se no Secure Developer Program.