OpenAI compatibilidad con Anthropic

Invocar modelos de Anthropic

Trabajar con modelos de Anthropic desde el SDK de OpenAI es útil cuando ya tienes una base de código que usa la API de OpenAI y quieres probar Claude sin cambiar toda la arquitectura de tu aplicación. Esta compatibilidad se basa en apuntar el cliente de OpenAI al endpoint de Anthropic, reutilizando la misma interfaz de chat completions.

En la práctica significa que tu código Python sigue usando el cliente OpenAI, pero la api_key y el base_url pertenecen a Anthropic, y el valor de model hace referencia a un modelo de Claude publicado en su documentación oficial.

Requisitos previos

Antes de escribir una sola línea de código necesitas tener claros los siguientes requisitos:

• 1. Cuenta en Anthropic y API key activa: debes registrarte en Anthropic, crear una organización y generar una clave desde su panel para poder invocar modelos de Claude.

• 2. Variable de entorno con la clave: por seguridad, la API key de Anthropic se debe guardar en una variable de entorno, por ejemplo ANTHROPIC_API_KEY, sin escribirla en claro en el código.

Configurar el cliente OpenAI apuntando a Anthropic

El primer paso técnico es crear un cliente de OpenAI que en realidad apunte al endpoint de Anthropic. La diferencia clave está en el base_url, que ya no es el de OpenAI sino https://api.anthropic.com/v1.

Problema: tienes código que ya crea un cliente de OpenAI, pero necesitas que las peticiones vayan a Anthropic.

Solución: reutilizar la clase OpenAI cambiando la configuración de conexión.

import os
from openai import OpenAI

# Usamos la clave de Anthropic guardada en la variable de entorno ANTHROPIC_API_KEY
client = OpenAI(
    api_key=os.getenv("ANTHROPIC_API_KEY"),
    base_url="https://api.anthropic.com/v1",
)

En este fragmento el objeto client sigue siendo una instancia de OpenAI, pero todas las llamadas irán al endpoint de Anthropic y se autenticarán con la clave que hayas configurado en ANTHROPIC_API_KEY.

Primera llamada a un modelo de Claude

Una vez configurado el cliente, puedes invocar un modelo de Claude utilizando la misma interfaz de chat.completions.create que ya usas con los modelos de OpenAI. Solo debes asegurarte de utilizar un identificador de modelo válido según la documentación de Anthropic.

Problema: quieres comprobar rápidamente que la integración funciona y que Claude responde a una conversación sencilla.

Solución: enviar un par de mensajes (system y user) y mostrar la respuesta por consola.

response = client.chat.completions.create(
    model="claude-haiku-4-5",  # Modelo de Anthropic; ajusta al nombre que tengas disponible
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Who are you?"}
    ],
)

print(response.choices[0].message.content)

En este ejemplo utilizas un rol system para dar contexto al asistente y un mensaje user con la pregunta concreta, y recuperas el texto de la respuesta accediendo a response.choices[0].message.content, igual que harías con un modelo de OpenAI estándar.

Buenas prácticas al usar Anthropic con el SDK de OpenAI

Cuando conectas dos proveedores distintos a través de la misma interfaz, es importante tener en cuenta algunos matices para evitar errores difíciles de depurar.

• 1. Ajustar el nombre del modelo: los identificadores de los modelos de Anthropic (por ejemplo claude-3-5-sonnet o claude-3-5-haiku) no coinciden con los de OpenAI, así que siempre debes consultar la lista de modelos disponible en la documentación de Anthropic antes de usarlos en el parámetro model.

• 2. Revisar parámetros soportados: aunque la firma de chat.completions.create sea compatible, algunos parámetros avanzados pueden no estar plenamente soportados por los modelos de Claude, por lo que conviene empezar con los campos básicos (messages, max_tokens, temperature, top_p) y añadir el resto de forma gradual.

• 3. Separar la configuración por proveedor: en aplicaciones reales es recomendable aislar la configuración de OpenAI y Anthropic en funciones o módulos distintos (por ejemplo get_openai_client() y get_anthropic_client()), de modo que puedas cambiar claves, endpoints o modelos sin tocar el resto del código de negocio.

• 4. Monitorizar costes y tiempos de respuesta: al combinar modelos de diferentes proveedores conviene registrar tanto el uso de tokens como la latencia de cada llamada, para poder decidir con datos qué modelo utilizar en cada caso de uso concreto.

Ejemplo completo orientado a función de utilidad

Para integrar mejor Anthropic en una base de código ya existente, suele ser útil encapsular la llamada en una función de alto nivel que oculte los detalles del cliente y del endpoint.

Problema: no quieres repetir en cada módulo la configuración del cliente ni la lógica de extracción de la respuesta.

Solución: crear una función de ayuda que reciba el mensaje de usuario y devuelva directamente el texto generado por Claude.

import os
from openai import OpenAI


def create_anthropic_client() -> OpenAI:
    """Crea y devuelve un cliente configurado para llamar a modelos de Anthropic."""
    return OpenAI(
        api_key=os.getenv("ANTHROPIC_API_KEY"),
        base_url="https://api.anthropic.com/v1",
    )


def ask_claude(prompt: str) -> str:
    """Envía un mensaje de usuario al modelo Claude y devuelve solo el texto de respuesta."""
    client = create_anthropic_client()

    response = client.chat.completions.create(
        model="claude-haiku-4-5",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": prompt},
        ],
        max_tokens=512,
        temperature=0.3,
    )

    return response.choices[0].message.content


if __name__ == "__main__":
    answer = ask_claude("Resume en una frase qué es un modelo de lenguaje.")
    print(answer)

Con este diseño encapsulas los detalles de Anthropic y del SDK de OpenAI en un solo módulo, lo que facilita cambiar de modelo, de endpoint o incluso de proveedor sin reescribir el resto de la lógica de tu aplicación.