# Python: l'SDK OpenAI puntato sui modelli open-weight

> Chiama LLM open-weight da Python con il pacchetto openai: una chiamata, batch asincroni con limite di concorrenza e costo di ogni richiesta.

- URL: https://llmwithcrypto.com/it/docs/python/
- Ultimo aggiornamento: 2026-10-23
- Editore: LLMwithCrypto (https://llmwithcrypto.com)

Il pacchetto ufficiale `openai` funziona così com'è: passa il nostro base URL e la tua chiave quando crei il client. Tutto il resto del tuo codice resta uguale, a parte il nome del modello.

**Risposta rapida — Come chiamo LLMwithCrypto da Python?**

Installa il pacchetto ufficiale con `pip install openai`, poi crea il client con `base_url="https://llmwithcrypto.com/api/v1"` e la tua chiave da `LLMWITHCRYPTO_API_KEY`. **LLMwithCrypto** risponde a `client.chat.completions.create()` come l'API di OpenAI, per 12 modelli open-weight come `deepseek-v4-pro` o `gpt-oss-120b`. Streaming, async e tool call funzionano come al solito, come documentato il 23 ottobre 2026.

## Cosa ti serve

| Attributo | Valore |
| --- | --- |
| Python | 3.9 o superiore |
| Pacchetto | `openai` (ufficiale); `requests` per la chiamata ai crediti |
| Base URL | `https://llmwithcrypto.com/api/v1` |
| Chiave | Nella variabile d'ambiente `LLMWITHCRYPTO_API_KEY`, mai nel codice |
| Id dei modelli | Sulla [pagina dei modelli](https://llmwithcrypto.com/it/models/) o da `client.models.list()` |

## Come invio una singola richiesta?

Crea il client una volta e riutilizzalo: mantiene la connessione aperta tra una chiamata e l'altra. Qui l'SDK non legge da solo alcuna variabile d'ambiente per il base URL, quindi passalo esplicitamente.

*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")

```

## Come eseguo molte richieste insieme?

Usa `AsyncOpenAI` con `asyncio.gather` e un semaforo per limitare quante richieste vengono eseguite in parallelo. Quattro è un punto di partenza sicuro; aumentalo restando sotto il tuo rate limit. Ogni account ha un limite di richieste e di token al minuto, mostrato nella dashboard; chiedi al supporto e può essere alzato.

*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())

```

## Come faccio lo streaming della risposta?

Passa `stream=True` e itera sui chunk; ognuno contiene un pezzo di testo in `delta.content`. Con `stream_options={"include_usage": True}`, l'ultimo chunk contiene i conteggi dei token. La [pagina sullo streaming](https://llmwithcrypto.com/it/docs/streaming/) spiega il 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")

```

## Come faccio a sapere quanto è costata una richiesta?

Moltiplica i conteggi `usage` per i prezzi del modello per milione di token. Al 23 ottobre 2026, DeepSeek V4 Pro costa $1.254 per milione di token di input e $3.762 per milione di token di output; l'esempio fissa a mano questi due numeri, quindi aggiornali dalla [pagina dei prezzi](https://llmwithcrypto.com/it/pricing/) quando cambiano. La dashboard mostra il costo esatto di ogni chiamata.

*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}")

```

## Come migro un'app OpenAI esistente?

Tre modifiche, di solito in un unico file:

1. **Il client.** Aggiungi `base_url` e leggi la chiave da `LLMWITHCRYPTO_API_KEY` dove crei `OpenAI()` o `AsyncOpenAI()`.
2. **I nomi dei modelli.** Sostituisci ogni nome `gpt-…` con un id dalla [pagina dei modelli](https://llmwithcrypto.com/it/models/). Cerca in tutto il progetto: i nomi dei modelli si nascondono nei file di configurazione, nei prompt e nei test.
3. **Le funzionalità su cui fai affidamento.** Chat, streaming e system prompt funzionano ovunque. Il tool calling e l'output JSON dipendono dal modello, quindi esegui i tuoi test esistenti sul modello che scegli.

Tutto il resto resta: i tuoi prompt, la tua logica di retry, il tuo parsing di `choices` e `usage`. La [guida alla migrazione](https://llmwithcrypto.com/it/guides/switch-openai-sdk-to-open-models/) illustra i dettagli.

## Dove dovrebbe stare la chiave?

Nell'ambiente, mai nel codice. In locale basta un file `.env` caricato dalla tua app e elencato in `.gitignore`; in produzione, usa il secret store del tuo host o della CI. Assegna a ogni app o servizio la sua chiave, così puoi revocarne una senza fermare le altre. Crea una chiave API per ogni app, agente o membro del team e revoca quella che vuoi dalla dashboard senza toccare le altre.

## Python: domande frequenti

### L'SDK riprova da solo?

Sì, il pacchetto `openai` riprova alcuni errori due volte per impostazione predefinita (`max_retries`). La [pagina degli errori](https://llmwithcrypto.com/it/docs/errors/) elenca quali errori vale la pena riprovare.

### Posso continuare a usare il mio codice OpenAI?

Sì. L'API parla il formato chat completions di OpenAI: punta l'SDK di OpenAI, LangChain o qualsiasi strumento compatibile con OpenAI alla nostra base URL con la tua chiave e cambia il nome del modello. La [guida alla migrazione](https://llmwithcrypto.com/it/guides/switch-openai-sdk-to-open-models/) elenca cosa controllare.

### Quali framework Python funzionano?

Qualsiasi cosa che accetti un base URL compatibile con OpenAI. La [pagina LangChain](https://llmwithcrypto.com/it/docs/langchain/) mostra LangChain e LlamaIndex.

---

LLMwithCrypto: LLMwithCrypto è un'API LLM compatibile con OpenAI per modelli open-weight — 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 — pagati a token da un saldo prepagato in criptovalute, al 5% sotto il prezzo mediano degli host pubblici. Senza KYC: niente documento, niente selfie, niente documenti. I prompt e gli output non vengono memorizzati.