# Python: el SDK de OpenAI apuntando a modelos de pesos abiertos

> Llama a LLM de pesos abiertos desde Python con openai: una llamada, lotes async con concurrencia, streaming y el coste de cada consulta.

- URL: https://llmwithcrypto.com/es/docs/python/
- Última actualización: 2026-10-23
- Editor: LLMwithCrypto (https://llmwithcrypto.com)

El paquete oficial `openai` funciona tal cual: pasa nuestra base URL y tu clave al crear el cliente. El resto de tu código se queda igual, salvo el nombre del modelo.

**Respuesta rápida — ¿Cómo llamo a LLMwithCrypto desde Python?**

Instala el paquete oficial con `pip install openai` y luego crea el cliente con `base_url="https://llmwithcrypto.com/api/v1"` y tu clave desde `LLMWITHCRYPTO_API_KEY`. **LLMwithCrypto** responde a `client.chat.completions.create()` como la API de OpenAI, para 12 modelos de pesos abiertos como `deepseek-v4-pro` o `gpt-oss-120b`. El streaming, el async y el tool calling funcionan como siempre, según la documentación del 23 de octubre de 2026.

## Lo que necesitas

| Atributo | Valor |
| --- | --- |
| Python | 3.9 o superior |
| Paquete | `openai` (oficial); `requests` para la llamada a créditos |
| URL base | `https://llmwithcrypto.com/api/v1` |
| Clave | En la variable de entorno `LLMWITHCRYPTO_API_KEY`, nunca en el código |
| Ids de modelos | En la [página de modelos](https://llmwithcrypto.com/es/models/) o desde `client.models.list()` |

## ¿Cómo envío una sola consulta?

Crea el cliente una vez y reutilízalo: mantiene la conexión abierta entre llamadas. El SDK no lee por sí solo ninguna variable de entorno para la base URL aquí, así que pásala explícitamente.

*one_call.py*

```python
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)

resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "Answer in two sentences."},
        {"role": "user", "content": "What is a context window?"},
    ],
    max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, "in,", resp.usage.completion_tokens, "out")

```

## ¿Cómo ejecuto muchas consultas a la vez?

Usa `AsyncOpenAI` con `asyncio.gather` y un semáforo para limitar cuántas solicitudes se ejecutan en paralelo. Cuatro es un inicio seguro; auméntalo mientras te mantengas por debajo de tu rate limit. Cada cuenta tiene un límite de peticiones y de tokens por minuto, que se muestra en el panel; pídelo a soporte y se puede ampliar.

*many_calls.py*

```python
import asyncio
import os

from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)
LIMIT = asyncio.Semaphore(4)


async def summarize(text):
    async with LIMIT:
        resp = await client.chat.completions.create(
            model="deepseek-v4.1-flash",
            messages=[
                {"role": "system", "content": "Summarize in one sentence."},
                {"role": "user", "content": text},
            ],
            max_tokens=80,
        )
        return resp.choices[0].message.content


async def main():
    docs = ["First report text...", "Second report text...", "Third report text..."]
    for summary in await asyncio.gather(*(summarize(d) for d in docs)):
        print("-", summary)


asyncio.run(main())

```

## ¿Cómo transmito la respuesta en streaming?

Pasa `stream=True` e itera sobre los chunks; cada uno lleva un fragmento de texto en `delta.content`. Con `stream_options={"include_usage": True}`, el último chunk lleva los recuentos de tokens. La [página de streaming](https://llmwithcrypto.com/es/docs/streaming/) explica el formato.

*stream.py*

```python
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)

stream = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Write a haiku about latency."}],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=120,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage.prompt_tokens, "in,", chunk.usage.completion_tokens, "out")

```

## ¿Cómo sé cuánto ha costado una solicitud?

Multiplica los recuentos de `usage` por los precios del modelo por millón de tokens. A fecha de 23 de octubre de 2026, DeepSeek V4 Pro cuesta $1.254 por millón de tokens de entrada y $3.762 por millón de tokens de salida; el ejemplo fija esos dos números en el código, así que actualízalos desde la [página de precios](https://llmwithcrypto.com/es/pricing/) cuando cambien los precios. El panel muestra el coste exacto de cada llamada.

*cost.py*

```python
import os

from openai import OpenAI

# prices per 1M tokens of the models you use, copied from the pricing page
PRICES = {"deepseek-v4-pro": (1.254, 3.762)}

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)
resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Give me three names for a coffee shop."}],
    max_tokens=100,
)
price_in, price_out = PRICES[resp.model]
cost = (resp.usage.prompt_tokens * price_in + resp.usage.completion_tokens * price_out) / 1_000_000
print(resp.choices[0].message.content)
print(f"cost: ${cost:.6f}")

```

## ¿Cómo migro una app de OpenAI existente?

Tres cambios, normalmente en un solo archivo:

1. **El cliente.** Añade `base_url` y lee la clave desde `LLMWITHCRYPTO_API_KEY` donde crees `OpenAI()` o `AsyncOpenAI()`.
2. **Los nombres de los modelos.** Sustituye cada nombre de `gpt-…` por un id de la [página de modelos](https://llmwithcrypto.com/es/models/). Busca en todo el proyecto: los nombres de modelos se esconden en archivos de configuración, prompts y tests.
3. **Las funciones de las que dependes.** El chat, el streaming y los system prompts funcionan en todas partes. El tool calling y la salida JSON dependen del modelo, así que ejecuta tus tests existentes contra el modelo que elijas.

Todo lo demás se mantiene: tus prompts, tu lógica de reintentos, tu parseo de `choices` y `usage`. La [guía de cambio](https://llmwithcrypto.com/es/guides/switch-openai-sdk-to-open-models/) recorre los detalles.

## ¿Dónde debe estar la clave?

En el entorno, nunca en el código. En local, basta con un archivo `.env` que cargue tu app y que esté listado en `.gitignore`; en producción, usa el almacén de secretos de tu host o de tu CI. Da a cada app o servicio su propia clave para poder revocar una sin detener las demás. Crea una clave API por app, agente o compañero de equipo y revoca cualquiera desde el panel sin tocar las demás.

## Python: preguntas frecuentes

### ¿El SDK reintenta por su cuenta?

Sí, el paquete `openai` reintenta algunos errores dos veces por defecto (`max_retries`). La [página de errores](https://llmwithcrypto.com/es/docs/errors/) indica qué errores merecen un reintento.

### ¿Puedo seguir usando mi código de OpenAI?

Sí. La API habla el formato chat completions de OpenAI: apunta el SDK de OpenAI, LangChain o cualquier herramienta compatible con OpenAI a nuestra URL base con tu clave, y cambia el nombre del modelo. La [guía de cambio](https://llmwithcrypto.com/es/guides/switch-openai-sdk-to-open-models/) indica qué revisar.

### ¿Qué frameworks de Python funcionan?

Cualquiera que acepte una base URL compatible con OpenAI. La [página de LangChain](https://llmwithcrypto.com/es/docs/langchain/) muestra LangChain y LlamaIndex.

---

LLMwithCrypto: LLMwithCrypto es una API de LLM compatible con OpenAI para modelos de pesos abiertos — DeepSeek V4 Pro, DeepSeek V4.1 Flash, DeepSeek R1, Qwen3.5 397B A17B, Qwen3 235B A22B Instruct, gpt-oss-120b, gpt-oss-20b, GLM-4.7, Llama 3.3 70B Instruct, Gemma 4 31B, Mistral Large 3, Mistral Small 4 — con pago por token desde un saldo de criptomonedas prepago, a un 5% por debajo del precio medio de los hosts públicos. Sin KYC: sin identificación, sin selfie, sin documentos. Los prompts y las salidas no se almacenan.